tenants.go

// Code generated by Fern. DO NOT EDIT.

package cloudpdf

import (
	json "encoding/json"
	fmt "fmt"
	internal "github.com/embedpdf/cloudpdf-sdk-go/v3/internal"
	big "math/big"
)

var (
	tenantsCreateRequestFieldID   = big.NewInt(1 << 0)
	tenantsCreateRequestFieldName = big.NewInt(1 << 1)
)

type TenantsCreateRequest struct {
	ID   string  `json:"id" url:"-"`
	Name *string `json:"name,omitempty" url:"-"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`
}

func (t *TenantsCreateRequest) require(field *big.Int) {
	if t.explicitFields == nil {
		t.explicitFields = big.NewInt(0)
	}
	t.explicitFields.Or(t.explicitFields, field)
}

// SetID sets the ID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsCreateRequest) SetID(id string) {
	t.ID = id
	t.require(tenantsCreateRequestFieldID)
}

// SetName sets the Name field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsCreateRequest) SetName(name *string) {
	t.Name = name
	t.require(tenantsCreateRequestFieldName)
}

func (t *TenantsCreateRequest) UnmarshalJSON(data []byte) error {
	type unmarshaler TenantsCreateRequest
	var body unmarshaler
	if err := json.Unmarshal(data, &body); err != nil {
		return err
	}
	*t = TenantsCreateRequest(body)
	return nil
}

func (t *TenantsCreateRequest) MarshalJSON() ([]byte, error) {
	type embed TenantsCreateRequest
	var marshaler = struct {
		embed
	}{
		embed: embed(*t),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, t.explicitFields)
	return json.Marshal(explicitMarshaler)
}

var (
	deleteTenantsRequestFieldTenantID = big.NewInt(1 << 0)
)

type DeleteTenantsRequest struct {
	TenantID string `json:"-" url:"-"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`
}

func (d *DeleteTenantsRequest) require(field *big.Int) {
	if d.explicitFields == nil {
		d.explicitFields = big.NewInt(0)
	}
	d.explicitFields.Or(d.explicitFields, field)
}

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DeleteTenantsRequest) SetTenantID(tenantID string) {
	d.TenantID = tenantID
	d.require(deleteTenantsRequestFieldTenantID)
}

var (
	getTenantsRequestFieldTenantID = big.NewInt(1 << 0)
)

type GetTenantsRequest struct {
	TenantID string `json:"-" url:"-"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`
}

func (g *GetTenantsRequest) require(field *big.Int) {
	if g.explicitFields == nil {
		g.explicitFields = big.NewInt(0)
	}
	g.explicitFields.Or(g.explicitFields, field)
}

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (g *GetTenantsRequest) SetTenantID(tenantID string) {
	g.TenantID = tenantID
	g.require(getTenantsRequestFieldTenantID)
}

var (
	listTenantsRequestFieldLimit  = big.NewInt(1 << 0)
	listTenantsRequestFieldCursor = big.NewInt(1 << 1)
)

type ListTenantsRequest struct {
	Limit  *int    `json:"-" url:"limit,omitempty"`
	Cursor *string `json:"-" url:"cursor,omitempty"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`
}

func (l *ListTenantsRequest) require(field *big.Int) {
	if l.explicitFields == nil {
		l.explicitFields = big.NewInt(0)
	}
	l.explicitFields.Or(l.explicitFields, field)
}

// SetLimit sets the Limit field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (l *ListTenantsRequest) SetLimit(limit *int) {
	l.Limit = limit
	l.require(listTenantsRequestFieldLimit)
}

// SetCursor sets the Cursor field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (l *ListTenantsRequest) SetCursor(cursor *string) {
	l.Cursor = cursor
	l.require(listTenantsRequestFieldCursor)
}

var (
	resumeTenantsRequestFieldTenantID = big.NewInt(1 << 0)
)

type ResumeTenantsRequest struct {
	TenantID string `json:"-" url:"-"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`
}

func (r *ResumeTenantsRequest) require(field *big.Int) {
	if r.explicitFields == nil {
		r.explicitFields = big.NewInt(0)
	}
	r.explicitFields.Or(r.explicitFields, field)
}

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResumeTenantsRequest) SetTenantID(tenantID string) {
	r.TenantID = tenantID
	r.require(resumeTenantsRequestFieldTenantID)
}

var (
	tenantsSuspendRequestFieldTenantID = big.NewInt(1 << 0)
	tenantsSuspendRequestFieldReason   = big.NewInt(1 << 1)
)

type TenantsSuspendRequest struct {
	TenantID string  `json:"-" url:"-"`
	Reason   *string `json:"reason,omitempty" url:"-"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`
}

func (t *TenantsSuspendRequest) require(field *big.Int) {
	if t.explicitFields == nil {
		t.explicitFields = big.NewInt(0)
	}
	t.explicitFields.Or(t.explicitFields, field)
}

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsSuspendRequest) SetTenantID(tenantID string) {
	t.TenantID = tenantID
	t.require(tenantsSuspendRequestFieldTenantID)
}

// SetReason sets the Reason field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsSuspendRequest) SetReason(reason *string) {
	t.Reason = reason
	t.require(tenantsSuspendRequestFieldReason)
}

func (t *TenantsSuspendRequest) UnmarshalJSON(data []byte) error {
	type unmarshaler TenantsSuspendRequest
	var body unmarshaler
	if err := json.Unmarshal(data, &body); err != nil {
		return err
	}
	*t = TenantsSuspendRequest(body)
	return nil
}

func (t *TenantsSuspendRequest) MarshalJSON() ([]byte, error) {
	type embed TenantsSuspendRequest
	var marshaler = struct {
		embed
	}{
		embed: embed(*t),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, t.explicitFields)
	return json.Marshal(explicitMarshaler)
}

var (
	tenantsCreate200ResponseFieldTenant  = big.NewInt(1 << 0)
	tenantsCreate200ResponseFieldCreated = big.NewInt(1 << 1)
)

type TenantsCreate200Response struct {
	Tenant  *TenantsCreate200ResponseTenant `json:"tenant" url:"tenant"`
	Created bool                            `json:"created" url:"created"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (t *TenantsCreate200Response) GetTenant() *TenantsCreate200ResponseTenant {
	if t == nil {
		return nil
	}
	return t.Tenant
}

func (t *TenantsCreate200Response) GetCreated() bool {
	if t == nil {
		return false
	}
	return t.Created
}

func (t *TenantsCreate200Response) GetExtraProperties() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.extraProperties
}

func (t *TenantsCreate200Response) require(field *big.Int) {
	if t.explicitFields == nil {
		t.explicitFields = big.NewInt(0)
	}
	t.explicitFields.Or(t.explicitFields, field)
}

// SetTenant sets the Tenant field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsCreate200Response) SetTenant(tenant *TenantsCreate200ResponseTenant) {
	t.Tenant = tenant
	t.require(tenantsCreate200ResponseFieldTenant)
}

// SetCreated sets the Created field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsCreate200Response) SetCreated(created bool) {
	t.Created = created
	t.require(tenantsCreate200ResponseFieldCreated)
}

func (t *TenantsCreate200Response) UnmarshalJSON(data []byte) error {
	type unmarshaler TenantsCreate200Response
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*t = TenantsCreate200Response(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TenantsCreate200Response) MarshalJSON() ([]byte, error) {
	type embed TenantsCreate200Response
	var marshaler = struct {
		embed
	}{
		embed: embed(*t),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, t.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (t *TenantsCreate200Response) String() string {
	if t == nil {
		return "<nil>"
	}
	if len(t.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(t.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(t); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", t)
}

var (
	tenantsCreate200ResponseTenantFieldID              = big.NewInt(1 << 0)
	tenantsCreate200ResponseTenantFieldName            = big.NewInt(1 << 1)
	tenantsCreate200ResponseTenantFieldAutoProvisioned = big.NewInt(1 << 2)
	tenantsCreate200ResponseTenantFieldStatus          = big.NewInt(1 << 3)
	tenantsCreate200ResponseTenantFieldCreatedAt       = big.NewInt(1 << 4)
)

type TenantsCreate200ResponseTenant struct {
	ID              string                                `json:"id" url:"id"`
	Name            string                                `json:"name" url:"name"`
	AutoProvisioned bool                                  `json:"autoProvisioned" url:"autoProvisioned"`
	Status          *TenantsCreate200ResponseTenantStatus `json:"status,omitempty" url:"status,omitempty"`
	CreatedAt       float64                               `json:"createdAt" url:"createdAt"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (t *TenantsCreate200ResponseTenant) GetID() string {
	if t == nil {
		return ""
	}
	return t.ID
}

func (t *TenantsCreate200ResponseTenant) GetName() string {
	if t == nil {
		return ""
	}
	return t.Name
}

func (t *TenantsCreate200ResponseTenant) GetAutoProvisioned() bool {
	if t == nil {
		return false
	}
	return t.AutoProvisioned
}

func (t *TenantsCreate200ResponseTenant) GetStatus() *TenantsCreate200ResponseTenantStatus {
	if t == nil {
		return nil
	}
	return t.Status
}

func (t *TenantsCreate200ResponseTenant) GetCreatedAt() float64 {
	if t == nil {
		return 0
	}
	return t.CreatedAt
}

func (t *TenantsCreate200ResponseTenant) GetExtraProperties() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.extraProperties
}

func (t *TenantsCreate200ResponseTenant) require(field *big.Int) {
	if t.explicitFields == nil {
		t.explicitFields = big.NewInt(0)
	}
	t.explicitFields.Or(t.explicitFields, field)
}

// SetID sets the ID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsCreate200ResponseTenant) SetID(id string) {
	t.ID = id
	t.require(tenantsCreate200ResponseTenantFieldID)
}

// SetName sets the Name field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsCreate200ResponseTenant) SetName(name string) {
	t.Name = name
	t.require(tenantsCreate200ResponseTenantFieldName)
}

// SetAutoProvisioned sets the AutoProvisioned field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsCreate200ResponseTenant) SetAutoProvisioned(autoProvisioned bool) {
	t.AutoProvisioned = autoProvisioned
	t.require(tenantsCreate200ResponseTenantFieldAutoProvisioned)
}

// SetStatus sets the Status field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsCreate200ResponseTenant) SetStatus(status *TenantsCreate200ResponseTenantStatus) {
	t.Status = status
	t.require(tenantsCreate200ResponseTenantFieldStatus)
}

// SetCreatedAt sets the CreatedAt field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsCreate200ResponseTenant) SetCreatedAt(createdAt float64) {
	t.CreatedAt = createdAt
	t.require(tenantsCreate200ResponseTenantFieldCreatedAt)
}

func (t *TenantsCreate200ResponseTenant) UnmarshalJSON(data []byte) error {
	type unmarshaler TenantsCreate200ResponseTenant
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*t = TenantsCreate200ResponseTenant(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TenantsCreate200ResponseTenant) MarshalJSON() ([]byte, error) {
	type embed TenantsCreate200ResponseTenant
	var marshaler = struct {
		embed
	}{
		embed: embed(*t),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, t.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (t *TenantsCreate200ResponseTenant) String() string {
	if t == nil {
		return "<nil>"
	}
	if len(t.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(t.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(t); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", t)
}

type TenantsCreate200ResponseTenantStatus string

const (
	TenantsCreate200ResponseTenantStatusActive    TenantsCreate200ResponseTenantStatus = "active"
	TenantsCreate200ResponseTenantStatusSuspended TenantsCreate200ResponseTenantStatus = "suspended"
)

func NewTenantsCreate200ResponseTenantStatusFromString(s string) (TenantsCreate200ResponseTenantStatus, error) {
	switch s {
	case "active":
		return TenantsCreate200ResponseTenantStatusActive, nil
	case "suspended":
		return TenantsCreate200ResponseTenantStatusSuspended, nil
	}
	var t TenantsCreate200ResponseTenantStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (t TenantsCreate200ResponseTenantStatus) Ptr() *TenantsCreate200ResponseTenantStatus {
	return &t
}

var (
	tenantsGet200ResponseFieldTenant = big.NewInt(1 << 0)
)

type TenantsGet200Response struct {
	Tenant *TenantsGet200ResponseTenant `json:"tenant" url:"tenant"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (t *TenantsGet200Response) GetTenant() *TenantsGet200ResponseTenant {
	if t == nil {
		return nil
	}
	return t.Tenant
}

func (t *TenantsGet200Response) GetExtraProperties() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.extraProperties
}

func (t *TenantsGet200Response) require(field *big.Int) {
	if t.explicitFields == nil {
		t.explicitFields = big.NewInt(0)
	}
	t.explicitFields.Or(t.explicitFields, field)
}

// SetTenant sets the Tenant field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsGet200Response) SetTenant(tenant *TenantsGet200ResponseTenant) {
	t.Tenant = tenant
	t.require(tenantsGet200ResponseFieldTenant)
}

func (t *TenantsGet200Response) UnmarshalJSON(data []byte) error {
	type unmarshaler TenantsGet200Response
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*t = TenantsGet200Response(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TenantsGet200Response) MarshalJSON() ([]byte, error) {
	type embed TenantsGet200Response
	var marshaler = struct {
		embed
	}{
		embed: embed(*t),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, t.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (t *TenantsGet200Response) String() string {
	if t == nil {
		return "<nil>"
	}
	if len(t.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(t.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(t); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", t)
}

var (
	tenantsGet200ResponseTenantFieldID              = big.NewInt(1 << 0)
	tenantsGet200ResponseTenantFieldName            = big.NewInt(1 << 1)
	tenantsGet200ResponseTenantFieldAutoProvisioned = big.NewInt(1 << 2)
	tenantsGet200ResponseTenantFieldStatus          = big.NewInt(1 << 3)
	tenantsGet200ResponseTenantFieldCreatedAt       = big.NewInt(1 << 4)
)

type TenantsGet200ResponseTenant struct {
	ID              string                             `json:"id" url:"id"`
	Name            string                             `json:"name" url:"name"`
	AutoProvisioned bool                               `json:"autoProvisioned" url:"autoProvisioned"`
	Status          *TenantsGet200ResponseTenantStatus `json:"status,omitempty" url:"status,omitempty"`
	CreatedAt       float64                            `json:"createdAt" url:"createdAt"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (t *TenantsGet200ResponseTenant) GetID() string {
	if t == nil {
		return ""
	}
	return t.ID
}

func (t *TenantsGet200ResponseTenant) GetName() string {
	if t == nil {
		return ""
	}
	return t.Name
}

func (t *TenantsGet200ResponseTenant) GetAutoProvisioned() bool {
	if t == nil {
		return false
	}
	return t.AutoProvisioned
}

func (t *TenantsGet200ResponseTenant) GetStatus() *TenantsGet200ResponseTenantStatus {
	if t == nil {
		return nil
	}
	return t.Status
}

func (t *TenantsGet200ResponseTenant) GetCreatedAt() float64 {
	if t == nil {
		return 0
	}
	return t.CreatedAt
}

func (t *TenantsGet200ResponseTenant) GetExtraProperties() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.extraProperties
}

func (t *TenantsGet200ResponseTenant) require(field *big.Int) {
	if t.explicitFields == nil {
		t.explicitFields = big.NewInt(0)
	}
	t.explicitFields.Or(t.explicitFields, field)
}

// SetID sets the ID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsGet200ResponseTenant) SetID(id string) {
	t.ID = id
	t.require(tenantsGet200ResponseTenantFieldID)
}

// SetName sets the Name field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsGet200ResponseTenant) SetName(name string) {
	t.Name = name
	t.require(tenantsGet200ResponseTenantFieldName)
}

// SetAutoProvisioned sets the AutoProvisioned field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsGet200ResponseTenant) SetAutoProvisioned(autoProvisioned bool) {
	t.AutoProvisioned = autoProvisioned
	t.require(tenantsGet200ResponseTenantFieldAutoProvisioned)
}

// SetStatus sets the Status field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsGet200ResponseTenant) SetStatus(status *TenantsGet200ResponseTenantStatus) {
	t.Status = status
	t.require(tenantsGet200ResponseTenantFieldStatus)
}

// SetCreatedAt sets the CreatedAt field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsGet200ResponseTenant) SetCreatedAt(createdAt float64) {
	t.CreatedAt = createdAt
	t.require(tenantsGet200ResponseTenantFieldCreatedAt)
}

func (t *TenantsGet200ResponseTenant) UnmarshalJSON(data []byte) error {
	type unmarshaler TenantsGet200ResponseTenant
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*t = TenantsGet200ResponseTenant(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TenantsGet200ResponseTenant) MarshalJSON() ([]byte, error) {
	type embed TenantsGet200ResponseTenant
	var marshaler = struct {
		embed
	}{
		embed: embed(*t),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, t.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (t *TenantsGet200ResponseTenant) String() string {
	if t == nil {
		return "<nil>"
	}
	if len(t.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(t.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(t); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", t)
}

type TenantsGet200ResponseTenantStatus string

const (
	TenantsGet200ResponseTenantStatusActive    TenantsGet200ResponseTenantStatus = "active"
	TenantsGet200ResponseTenantStatusSuspended TenantsGet200ResponseTenantStatus = "suspended"
)

func NewTenantsGet200ResponseTenantStatusFromString(s string) (TenantsGet200ResponseTenantStatus, error) {
	switch s {
	case "active":
		return TenantsGet200ResponseTenantStatusActive, nil
	case "suspended":
		return TenantsGet200ResponseTenantStatusSuspended, nil
	}
	var t TenantsGet200ResponseTenantStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (t TenantsGet200ResponseTenantStatus) Ptr() *TenantsGet200ResponseTenantStatus {
	return &t
}

var (
	tenantsList200ResponseFieldTenants    = big.NewInt(1 << 0)
	tenantsList200ResponseFieldNextCursor = big.NewInt(1 << 1)
)

type TenantsList200Response struct {
	Tenants    []*TenantsList200ResponseTenantsItem `json:"tenants" url:"tenants"`
	NextCursor *string                              `json:"nextCursor,omitempty" url:"nextCursor,omitempty"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (t *TenantsList200Response) GetTenants() []*TenantsList200ResponseTenantsItem {
	if t == nil {
		return nil
	}
	return t.Tenants
}

func (t *TenantsList200Response) GetNextCursor() *string {
	if t == nil {
		return nil
	}
	return t.NextCursor
}

func (t *TenantsList200Response) GetExtraProperties() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.extraProperties
}

func (t *TenantsList200Response) require(field *big.Int) {
	if t.explicitFields == nil {
		t.explicitFields = big.NewInt(0)
	}
	t.explicitFields.Or(t.explicitFields, field)
}

// SetTenants sets the Tenants field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsList200Response) SetTenants(tenants []*TenantsList200ResponseTenantsItem) {
	t.Tenants = tenants
	t.require(tenantsList200ResponseFieldTenants)
}

// SetNextCursor sets the NextCursor field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsList200Response) SetNextCursor(nextCursor *string) {
	t.NextCursor = nextCursor
	t.require(tenantsList200ResponseFieldNextCursor)
}

func (t *TenantsList200Response) UnmarshalJSON(data []byte) error {
	type unmarshaler TenantsList200Response
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*t = TenantsList200Response(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TenantsList200Response) MarshalJSON() ([]byte, error) {
	type embed TenantsList200Response
	var marshaler = struct {
		embed
	}{
		embed: embed(*t),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, t.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (t *TenantsList200Response) String() string {
	if t == nil {
		return "<nil>"
	}
	if len(t.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(t.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(t); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", t)
}

var (
	tenantsList200ResponseTenantsItemFieldID              = big.NewInt(1 << 0)
	tenantsList200ResponseTenantsItemFieldName            = big.NewInt(1 << 1)
	tenantsList200ResponseTenantsItemFieldAutoProvisioned = big.NewInt(1 << 2)
	tenantsList200ResponseTenantsItemFieldStatus          = big.NewInt(1 << 3)
	tenantsList200ResponseTenantsItemFieldCreatedAt       = big.NewInt(1 << 4)
)

type TenantsList200ResponseTenantsItem struct {
	ID              string                                   `json:"id" url:"id"`
	Name            string                                   `json:"name" url:"name"`
	AutoProvisioned bool                                     `json:"autoProvisioned" url:"autoProvisioned"`
	Status          *TenantsList200ResponseTenantsItemStatus `json:"status,omitempty" url:"status,omitempty"`
	CreatedAt       float64                                  `json:"createdAt" url:"createdAt"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (t *TenantsList200ResponseTenantsItem) GetID() string {
	if t == nil {
		return ""
	}
	return t.ID
}

func (t *TenantsList200ResponseTenantsItem) GetName() string {
	if t == nil {
		return ""
	}
	return t.Name
}

func (t *TenantsList200ResponseTenantsItem) GetAutoProvisioned() bool {
	if t == nil {
		return false
	}
	return t.AutoProvisioned
}

func (t *TenantsList200ResponseTenantsItem) GetStatus() *TenantsList200ResponseTenantsItemStatus {
	if t == nil {
		return nil
	}
	return t.Status
}

func (t *TenantsList200ResponseTenantsItem) GetCreatedAt() float64 {
	if t == nil {
		return 0
	}
	return t.CreatedAt
}

func (t *TenantsList200ResponseTenantsItem) GetExtraProperties() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.extraProperties
}

func (t *TenantsList200ResponseTenantsItem) require(field *big.Int) {
	if t.explicitFields == nil {
		t.explicitFields = big.NewInt(0)
	}
	t.explicitFields.Or(t.explicitFields, field)
}

// SetID sets the ID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsList200ResponseTenantsItem) SetID(id string) {
	t.ID = id
	t.require(tenantsList200ResponseTenantsItemFieldID)
}

// SetName sets the Name field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsList200ResponseTenantsItem) SetName(name string) {
	t.Name = name
	t.require(tenantsList200ResponseTenantsItemFieldName)
}

// SetAutoProvisioned sets the AutoProvisioned field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsList200ResponseTenantsItem) SetAutoProvisioned(autoProvisioned bool) {
	t.AutoProvisioned = autoProvisioned
	t.require(tenantsList200ResponseTenantsItemFieldAutoProvisioned)
}

// SetStatus sets the Status field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsList200ResponseTenantsItem) SetStatus(status *TenantsList200ResponseTenantsItemStatus) {
	t.Status = status
	t.require(tenantsList200ResponseTenantsItemFieldStatus)
}

// SetCreatedAt sets the CreatedAt field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsList200ResponseTenantsItem) SetCreatedAt(createdAt float64) {
	t.CreatedAt = createdAt
	t.require(tenantsList200ResponseTenantsItemFieldCreatedAt)
}

func (t *TenantsList200ResponseTenantsItem) UnmarshalJSON(data []byte) error {
	type unmarshaler TenantsList200ResponseTenantsItem
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*t = TenantsList200ResponseTenantsItem(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TenantsList200ResponseTenantsItem) MarshalJSON() ([]byte, error) {
	type embed TenantsList200ResponseTenantsItem
	var marshaler = struct {
		embed
	}{
		embed: embed(*t),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, t.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (t *TenantsList200ResponseTenantsItem) String() string {
	if t == nil {
		return "<nil>"
	}
	if len(t.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(t.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(t); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", t)
}

type TenantsList200ResponseTenantsItemStatus string

const (
	TenantsList200ResponseTenantsItemStatusActive    TenantsList200ResponseTenantsItemStatus = "active"
	TenantsList200ResponseTenantsItemStatusSuspended TenantsList200ResponseTenantsItemStatus = "suspended"
)

func NewTenantsList200ResponseTenantsItemStatusFromString(s string) (TenantsList200ResponseTenantsItemStatus, error) {
	switch s {
	case "active":
		return TenantsList200ResponseTenantsItemStatusActive, nil
	case "suspended":
		return TenantsList200ResponseTenantsItemStatusSuspended, nil
	}
	var t TenantsList200ResponseTenantsItemStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (t TenantsList200ResponseTenantsItemStatus) Ptr() *TenantsList200ResponseTenantsItemStatus {
	return &t
}

var (
	tenantsUsage200ResponseFieldTenantID    = big.NewInt(1 << 0)
	tenantsUsage200ResponseFieldPeriodStart = big.NewInt(1 << 1)
	tenantsUsage200ResponseFieldPeriodEnd   = big.NewInt(1 << 2)
	tenantsUsage200ResponseFieldMetrics     = big.NewInt(1 << 3)
)

type TenantsUsage200Response struct {
	TenantID    string                          `json:"tenantId" url:"tenantId"`
	PeriodStart string                          `json:"periodStart" url:"periodStart"`
	PeriodEnd   string                          `json:"periodEnd" url:"periodEnd"`
	Metrics     *TenantsUsage200ResponseMetrics `json:"metrics" url:"metrics"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (t *TenantsUsage200Response) GetTenantID() string {
	if t == nil {
		return ""
	}
	return t.TenantID
}

func (t *TenantsUsage200Response) GetPeriodStart() string {
	if t == nil {
		return ""
	}
	return t.PeriodStart
}

func (t *TenantsUsage200Response) GetPeriodEnd() string {
	if t == nil {
		return ""
	}
	return t.PeriodEnd
}

func (t *TenantsUsage200Response) GetMetrics() *TenantsUsage200ResponseMetrics {
	if t == nil {
		return nil
	}
	return t.Metrics
}

func (t *TenantsUsage200Response) GetExtraProperties() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.extraProperties
}

func (t *TenantsUsage200Response) require(field *big.Int) {
	if t.explicitFields == nil {
		t.explicitFields = big.NewInt(0)
	}
	t.explicitFields.Or(t.explicitFields, field)
}

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsUsage200Response) SetTenantID(tenantID string) {
	t.TenantID = tenantID
	t.require(tenantsUsage200ResponseFieldTenantID)
}

// SetPeriodStart sets the PeriodStart field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsUsage200Response) SetPeriodStart(periodStart string) {
	t.PeriodStart = periodStart
	t.require(tenantsUsage200ResponseFieldPeriodStart)
}

// SetPeriodEnd sets the PeriodEnd field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsUsage200Response) SetPeriodEnd(periodEnd string) {
	t.PeriodEnd = periodEnd
	t.require(tenantsUsage200ResponseFieldPeriodEnd)
}

// SetMetrics sets the Metrics field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsUsage200Response) SetMetrics(metrics *TenantsUsage200ResponseMetrics) {
	t.Metrics = metrics
	t.require(tenantsUsage200ResponseFieldMetrics)
}

func (t *TenantsUsage200Response) UnmarshalJSON(data []byte) error {
	type unmarshaler TenantsUsage200Response
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*t = TenantsUsage200Response(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TenantsUsage200Response) MarshalJSON() ([]byte, error) {
	type embed TenantsUsage200Response
	var marshaler = struct {
		embed
	}{
		embed: embed(*t),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, t.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (t *TenantsUsage200Response) String() string {
	if t == nil {
		return "<nil>"
	}
	if len(t.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(t.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(t); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", t)
}

var (
	tenantsUsage200ResponseMetricsFieldPdfViews     = big.NewInt(1 << 0)
	tenantsUsage200ResponseMetricsFieldPdfUploads   = big.NewInt(1 << 1)
	tenantsUsage200ResponseMetricsFieldStorageBytes = big.NewInt(1 << 2)
)

type TenantsUsage200ResponseMetrics struct {
	PdfViews     float64 `json:"pdf.views" url:"pdf.views"`
	PdfUploads   float64 `json:"pdf.uploads" url:"pdf.uploads"`
	StorageBytes float64 `json:"storage.bytes" url:"storage.bytes"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (t *TenantsUsage200ResponseMetrics) GetPdfViews() float64 {
	if t == nil {
		return 0
	}
	return t.PdfViews
}

func (t *TenantsUsage200ResponseMetrics) GetPdfUploads() float64 {
	if t == nil {
		return 0
	}
	return t.PdfUploads
}

func (t *TenantsUsage200ResponseMetrics) GetStorageBytes() float64 {
	if t == nil {
		return 0
	}
	return t.StorageBytes
}

func (t *TenantsUsage200ResponseMetrics) GetExtraProperties() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.extraProperties
}

func (t *TenantsUsage200ResponseMetrics) require(field *big.Int) {
	if t.explicitFields == nil {
		t.explicitFields = big.NewInt(0)
	}
	t.explicitFields.Or(t.explicitFields, field)
}

// SetPdfViews sets the PdfViews field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsUsage200ResponseMetrics) SetPdfViews(pdfViews float64) {
	t.PdfViews = pdfViews
	t.require(tenantsUsage200ResponseMetricsFieldPdfViews)
}

// SetPdfUploads sets the PdfUploads field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsUsage200ResponseMetrics) SetPdfUploads(pdfUploads float64) {
	t.PdfUploads = pdfUploads
	t.require(tenantsUsage200ResponseMetricsFieldPdfUploads)
}

// SetStorageBytes sets the StorageBytes field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *TenantsUsage200ResponseMetrics) SetStorageBytes(storageBytes float64) {
	t.StorageBytes = storageBytes
	t.require(tenantsUsage200ResponseMetricsFieldStorageBytes)
}

func (t *TenantsUsage200ResponseMetrics) UnmarshalJSON(data []byte) error {
	type unmarshaler TenantsUsage200ResponseMetrics
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*t = TenantsUsage200ResponseMetrics(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TenantsUsage200ResponseMetrics) MarshalJSON() ([]byte, error) {
	type embed TenantsUsage200ResponseMetrics
	var marshaler = struct {
		embed
	}{
		embed: embed(*t),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, t.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (t *TenantsUsage200ResponseMetrics) String() string {
	if t == nil {
		return "<nil>"
	}
	if len(t.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(t.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(t); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", t)
}

var (
	usageTenantsRequestFieldTenantID = big.NewInt(1 << 0)
	usageTenantsRequestFieldPeriod   = big.NewInt(1 << 1)
)

type UsageTenantsRequest struct {
	TenantID string  `json:"-" url:"-"`
	Period   *string `json:"-" url:"period,omitempty"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`
}

func (u *UsageTenantsRequest) require(field *big.Int) {
	if u.explicitFields == nil {
		u.explicitFields = big.NewInt(0)
	}
	u.explicitFields.Or(u.explicitFields, field)
}

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (u *UsageTenantsRequest) SetTenantID(tenantID string) {
	u.TenantID = tenantID
	u.require(usageTenantsRequestFieldTenantID)
}

// SetPeriod sets the Period field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (u *UsageTenantsRequest) SetPeriod(period *string) {
	u.Period = period
	u.require(usageTenantsRequestFieldPeriod)
}