types.go

// This file was auto-generated by Fern from our API Definition.

package schematichq

import (
	json "encoding/json"
	fmt "fmt"
	internal "github.com/schematichq/schematic-go/internal"
	time "time"
)

type APIError struct {
	// Error message
	Error string `json:"error" url:"error"`

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

func (a *APIError) GetError() string {
	if a == nil {
		return ""
	}
	return a.Error
}

func (a *APIError) GetExtraProperties() map[string]interface{} {
	return a.extraProperties
}

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

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

type BillingPriceResponseData struct {
	Currency        string `json:"currency" url:"currency"`
	ExternalPriceID string `json:"external_price_id" url:"external_price_id"`
	ID              string `json:"id" url:"id"`
	Interval        string `json:"interval" url:"interval"`
	Price           int    `json:"price" url:"price"`

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

func (b *BillingPriceResponseData) GetCurrency() string {
	if b == nil {
		return ""
	}
	return b.Currency
}

func (b *BillingPriceResponseData) GetExternalPriceID() string {
	if b == nil {
		return ""
	}
	return b.ExternalPriceID
}

func (b *BillingPriceResponseData) GetID() string {
	if b == nil {
		return ""
	}
	return b.ID
}

func (b *BillingPriceResponseData) GetInterval() string {
	if b == nil {
		return ""
	}
	return b.Interval
}

func (b *BillingPriceResponseData) GetPrice() int {
	if b == nil {
		return 0
	}
	return b.Price
}

func (b *BillingPriceResponseData) GetExtraProperties() map[string]interface{} {
	return b.extraProperties
}

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

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

type BillingPriceView struct {
	CreatedAt         time.Time `json:"created_at" url:"created_at"`
	Currency          string    `json:"currency" url:"currency"`
	ID                string    `json:"id" url:"id"`
	Interval          string    `json:"interval" url:"interval"`
	MeterID           *string   `json:"meter_id,omitempty" url:"meter_id,omitempty"`
	Price             int       `json:"price" url:"price"`
	PriceExternalID   string    `json:"price_external_id" url:"price_external_id"`
	PriceID           string    `json:"price_id" url:"price_id"`
	ProductExternalID string    `json:"product_external_id" url:"product_external_id"`
	ProductID         string    `json:"product_id" url:"product_id"`
	ProductName       string    `json:"product_name" url:"product_name"`
	UpdatedAt         time.Time `json:"updated_at" url:"updated_at"`
	UsageType         string    `json:"usage_type" url:"usage_type"`

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

func (b *BillingPriceView) GetCreatedAt() time.Time {
	if b == nil {
		return time.Time{}
	}
	return b.CreatedAt
}

func (b *BillingPriceView) GetCurrency() string {
	if b == nil {
		return ""
	}
	return b.Currency
}

func (b *BillingPriceView) GetID() string {
	if b == nil {
		return ""
	}
	return b.ID
}

func (b *BillingPriceView) GetInterval() string {
	if b == nil {
		return ""
	}
	return b.Interval
}

func (b *BillingPriceView) GetMeterID() *string {
	if b == nil {
		return nil
	}
	return b.MeterID
}

func (b *BillingPriceView) GetPrice() int {
	if b == nil {
		return 0
	}
	return b.Price
}

func (b *BillingPriceView) GetPriceExternalID() string {
	if b == nil {
		return ""
	}
	return b.PriceExternalID
}

func (b *BillingPriceView) GetPriceID() string {
	if b == nil {
		return ""
	}
	return b.PriceID
}

func (b *BillingPriceView) GetProductExternalID() string {
	if b == nil {
		return ""
	}
	return b.ProductExternalID
}

func (b *BillingPriceView) GetProductID() string {
	if b == nil {
		return ""
	}
	return b.ProductID
}

func (b *BillingPriceView) GetProductName() string {
	if b == nil {
		return ""
	}
	return b.ProductName
}

func (b *BillingPriceView) GetUpdatedAt() time.Time {
	if b == nil {
		return time.Time{}
	}
	return b.UpdatedAt
}

func (b *BillingPriceView) GetUsageType() string {
	if b == nil {
		return ""
	}
	return b.UsageType
}

func (b *BillingPriceView) GetExtraProperties() map[string]interface{} {
	return b.extraProperties
}

func (b *BillingPriceView) UnmarshalJSON(data []byte) error {
	type embed BillingPriceView
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*b),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*b = BillingPriceView(unmarshaler.embed)
	b.CreatedAt = unmarshaler.CreatedAt.Time()
	b.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *b)
	if err != nil {
		return err
	}
	b.extraProperties = extraProperties
	b.rawJSON = json.RawMessage(data)
	return nil
}

func (b *BillingPriceView) MarshalJSON() ([]byte, error) {
	type embed BillingPriceView
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*b),
		CreatedAt: internal.NewDateTime(b.CreatedAt),
		UpdatedAt: internal.NewDateTime(b.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type BillingProductDetailResponseData struct {
	AccountID     string                      `json:"account_id" url:"account_id"`
	CreatedAt     time.Time                   `json:"created_at" url:"created_at"`
	Currency      string                      `json:"currency" url:"currency"`
	EnvironmentID string                      `json:"environment_id" url:"environment_id"`
	ExternalID    string                      `json:"external_id" url:"external_id"`
	Name          string                      `json:"name" url:"name"`
	Price         float64                     `json:"price" url:"price"`
	Prices        []*BillingPriceResponseData `json:"prices,omitempty" url:"prices,omitempty"`
	ProductID     string                      `json:"product_id" url:"product_id"`
	Quantity      float64                     `json:"quantity" url:"quantity"`
	UpdatedAt     time.Time                   `json:"updated_at" url:"updated_at"`

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

func (b *BillingProductDetailResponseData) GetAccountID() string {
	if b == nil {
		return ""
	}
	return b.AccountID
}

func (b *BillingProductDetailResponseData) GetCreatedAt() time.Time {
	if b == nil {
		return time.Time{}
	}
	return b.CreatedAt
}

func (b *BillingProductDetailResponseData) GetCurrency() string {
	if b == nil {
		return ""
	}
	return b.Currency
}

func (b *BillingProductDetailResponseData) GetEnvironmentID() string {
	if b == nil {
		return ""
	}
	return b.EnvironmentID
}

func (b *BillingProductDetailResponseData) GetExternalID() string {
	if b == nil {
		return ""
	}
	return b.ExternalID
}

func (b *BillingProductDetailResponseData) GetName() string {
	if b == nil {
		return ""
	}
	return b.Name
}

func (b *BillingProductDetailResponseData) GetPrice() float64 {
	if b == nil {
		return 0
	}
	return b.Price
}

func (b *BillingProductDetailResponseData) GetPrices() []*BillingPriceResponseData {
	if b == nil {
		return nil
	}
	return b.Prices
}

func (b *BillingProductDetailResponseData) GetProductID() string {
	if b == nil {
		return ""
	}
	return b.ProductID
}

func (b *BillingProductDetailResponseData) GetQuantity() float64 {
	if b == nil {
		return 0
	}
	return b.Quantity
}

func (b *BillingProductDetailResponseData) GetUpdatedAt() time.Time {
	if b == nil {
		return time.Time{}
	}
	return b.UpdatedAt
}

func (b *BillingProductDetailResponseData) GetExtraProperties() map[string]interface{} {
	return b.extraProperties
}

func (b *BillingProductDetailResponseData) UnmarshalJSON(data []byte) error {
	type embed BillingProductDetailResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*b),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*b = BillingProductDetailResponseData(unmarshaler.embed)
	b.CreatedAt = unmarshaler.CreatedAt.Time()
	b.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *b)
	if err != nil {
		return err
	}
	b.extraProperties = extraProperties
	b.rawJSON = json.RawMessage(data)
	return nil
}

func (b *BillingProductDetailResponseData) MarshalJSON() ([]byte, error) {
	type embed BillingProductDetailResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*b),
		CreatedAt: internal.NewDateTime(b.CreatedAt),
		UpdatedAt: internal.NewDateTime(b.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type BillingProductForSubscriptionResponseData struct {
	CreatedAt       time.Time `json:"created_at" url:"created_at"`
	Currency        string    `json:"currency" url:"currency"`
	EnvironmentID   string    `json:"environment_id" url:"environment_id"`
	ExternalID      string    `json:"external_id" url:"external_id"`
	ID              string    `json:"id" url:"id"`
	Interval        string    `json:"interval" url:"interval"`
	MeterID         *string   `json:"meter_id,omitempty" url:"meter_id,omitempty"`
	Name            string    `json:"name" url:"name"`
	Price           int       `json:"price" url:"price"`
	PriceExternalID string    `json:"price_external_id" url:"price_external_id"`
	Quantity        float64   `json:"quantity" url:"quantity"`
	SubscriptionID  string    `json:"subscription_id" url:"subscription_id"`
	UpdatedAt       time.Time `json:"updated_at" url:"updated_at"`
	UsageType       string    `json:"usage_type" url:"usage_type"`

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

func (b *BillingProductForSubscriptionResponseData) GetCreatedAt() time.Time {
	if b == nil {
		return time.Time{}
	}
	return b.CreatedAt
}

func (b *BillingProductForSubscriptionResponseData) GetCurrency() string {
	if b == nil {
		return ""
	}
	return b.Currency
}

func (b *BillingProductForSubscriptionResponseData) GetEnvironmentID() string {
	if b == nil {
		return ""
	}
	return b.EnvironmentID
}

func (b *BillingProductForSubscriptionResponseData) GetExternalID() string {
	if b == nil {
		return ""
	}
	return b.ExternalID
}

func (b *BillingProductForSubscriptionResponseData) GetID() string {
	if b == nil {
		return ""
	}
	return b.ID
}

func (b *BillingProductForSubscriptionResponseData) GetInterval() string {
	if b == nil {
		return ""
	}
	return b.Interval
}

func (b *BillingProductForSubscriptionResponseData) GetMeterID() *string {
	if b == nil {
		return nil
	}
	return b.MeterID
}

func (b *BillingProductForSubscriptionResponseData) GetName() string {
	if b == nil {
		return ""
	}
	return b.Name
}

func (b *BillingProductForSubscriptionResponseData) GetPrice() int {
	if b == nil {
		return 0
	}
	return b.Price
}

func (b *BillingProductForSubscriptionResponseData) GetPriceExternalID() string {
	if b == nil {
		return ""
	}
	return b.PriceExternalID
}

func (b *BillingProductForSubscriptionResponseData) GetQuantity() float64 {
	if b == nil {
		return 0
	}
	return b.Quantity
}

func (b *BillingProductForSubscriptionResponseData) GetSubscriptionID() string {
	if b == nil {
		return ""
	}
	return b.SubscriptionID
}

func (b *BillingProductForSubscriptionResponseData) GetUpdatedAt() time.Time {
	if b == nil {
		return time.Time{}
	}
	return b.UpdatedAt
}

func (b *BillingProductForSubscriptionResponseData) GetUsageType() string {
	if b == nil {
		return ""
	}
	return b.UsageType
}

func (b *BillingProductForSubscriptionResponseData) GetExtraProperties() map[string]interface{} {
	return b.extraProperties
}

func (b *BillingProductForSubscriptionResponseData) UnmarshalJSON(data []byte) error {
	type embed BillingProductForSubscriptionResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*b),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*b = BillingProductForSubscriptionResponseData(unmarshaler.embed)
	b.CreatedAt = unmarshaler.CreatedAt.Time()
	b.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *b)
	if err != nil {
		return err
	}
	b.extraProperties = extraProperties
	b.rawJSON = json.RawMessage(data)
	return nil
}

func (b *BillingProductForSubscriptionResponseData) MarshalJSON() ([]byte, error) {
	type embed BillingProductForSubscriptionResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*b),
		CreatedAt: internal.NewDateTime(b.CreatedAt),
		UpdatedAt: internal.NewDateTime(b.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type BillingProductPriceResponseData struct {
	CreatedAt         time.Time `json:"created_at" url:"created_at"`
	Currency          string    `json:"currency" url:"currency"`
	ID                string    `json:"id" url:"id"`
	Interval          string    `json:"interval" url:"interval"`
	MeterID           *string   `json:"meter_id,omitempty" url:"meter_id,omitempty"`
	Price             int       `json:"price" url:"price"`
	PriceExternalID   string    `json:"price_external_id" url:"price_external_id"`
	ProductExternalID string    `json:"product_external_id" url:"product_external_id"`
	UpdatedAt         time.Time `json:"updated_at" url:"updated_at"`
	UsageType         string    `json:"usage_type" url:"usage_type"`

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

func (b *BillingProductPriceResponseData) GetCreatedAt() time.Time {
	if b == nil {
		return time.Time{}
	}
	return b.CreatedAt
}

func (b *BillingProductPriceResponseData) GetCurrency() string {
	if b == nil {
		return ""
	}
	return b.Currency
}

func (b *BillingProductPriceResponseData) GetID() string {
	if b == nil {
		return ""
	}
	return b.ID
}

func (b *BillingProductPriceResponseData) GetInterval() string {
	if b == nil {
		return ""
	}
	return b.Interval
}

func (b *BillingProductPriceResponseData) GetMeterID() *string {
	if b == nil {
		return nil
	}
	return b.MeterID
}

func (b *BillingProductPriceResponseData) GetPrice() int {
	if b == nil {
		return 0
	}
	return b.Price
}

func (b *BillingProductPriceResponseData) GetPriceExternalID() string {
	if b == nil {
		return ""
	}
	return b.PriceExternalID
}

func (b *BillingProductPriceResponseData) GetProductExternalID() string {
	if b == nil {
		return ""
	}
	return b.ProductExternalID
}

func (b *BillingProductPriceResponseData) GetUpdatedAt() time.Time {
	if b == nil {
		return time.Time{}
	}
	return b.UpdatedAt
}

func (b *BillingProductPriceResponseData) GetUsageType() string {
	if b == nil {
		return ""
	}
	return b.UsageType
}

func (b *BillingProductPriceResponseData) GetExtraProperties() map[string]interface{} {
	return b.extraProperties
}

func (b *BillingProductPriceResponseData) UnmarshalJSON(data []byte) error {
	type embed BillingProductPriceResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*b),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*b = BillingProductPriceResponseData(unmarshaler.embed)
	b.CreatedAt = unmarshaler.CreatedAt.Time()
	b.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *b)
	if err != nil {
		return err
	}
	b.extraProperties = extraProperties
	b.rawJSON = json.RawMessage(data)
	return nil
}

func (b *BillingProductPriceResponseData) MarshalJSON() ([]byte, error) {
	type embed BillingProductPriceResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*b),
		CreatedAt: internal.NewDateTime(b.CreatedAt),
		UpdatedAt: internal.NewDateTime(b.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type BillingSubscriptionView struct {
	CompanyID              *string                                      `json:"company_id,omitempty" url:"company_id,omitempty"`
	CreatedAt              time.Time                                    `json:"created_at" url:"created_at"`
	Currency               string                                       `json:"currency" url:"currency"`
	CustomerExternalID     string                                       `json:"customer_external_id" url:"customer_external_id"`
	ExpiredAt              *time.Time                                   `json:"expired_at,omitempty" url:"expired_at,omitempty"`
	ID                     string                                       `json:"id" url:"id"`
	Interval               string                                       `json:"interval" url:"interval"`
	LatestInvoice          *InvoiceResponseData                         `json:"latest_invoice,omitempty" url:"latest_invoice,omitempty"`
	Metadata               map[string]interface{}                       `json:"metadata,omitempty" url:"metadata,omitempty"`
	PaymentMethod          *PaymentMethodResponseData                   `json:"payment_method,omitempty" url:"payment_method,omitempty"`
	PeriodEnd              int                                          `json:"period_end" url:"period_end"`
	PeriodStart            int                                          `json:"period_start" url:"period_start"`
	Products               []*BillingProductForSubscriptionResponseData `json:"products,omitempty" url:"products,omitempty"`
	Status                 string                                       `json:"status" url:"status"`
	SubscriptionExternalID string                                       `json:"subscription_external_id" url:"subscription_external_id"`
	TotalPrice             int                                          `json:"total_price" url:"total_price"`
	TrialEnd               *int                                         `json:"trial_end,omitempty" url:"trial_end,omitempty"`

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

func (b *BillingSubscriptionView) GetCompanyID() *string {
	if b == nil {
		return nil
	}
	return b.CompanyID
}

func (b *BillingSubscriptionView) GetCreatedAt() time.Time {
	if b == nil {
		return time.Time{}
	}
	return b.CreatedAt
}

func (b *BillingSubscriptionView) GetCurrency() string {
	if b == nil {
		return ""
	}
	return b.Currency
}

func (b *BillingSubscriptionView) GetCustomerExternalID() string {
	if b == nil {
		return ""
	}
	return b.CustomerExternalID
}

func (b *BillingSubscriptionView) GetExpiredAt() *time.Time {
	if b == nil {
		return nil
	}
	return b.ExpiredAt
}

func (b *BillingSubscriptionView) GetID() string {
	if b == nil {
		return ""
	}
	return b.ID
}

func (b *BillingSubscriptionView) GetInterval() string {
	if b == nil {
		return ""
	}
	return b.Interval
}

func (b *BillingSubscriptionView) GetLatestInvoice() *InvoiceResponseData {
	if b == nil {
		return nil
	}
	return b.LatestInvoice
}

func (b *BillingSubscriptionView) GetMetadata() map[string]interface{} {
	if b == nil {
		return nil
	}
	return b.Metadata
}

func (b *BillingSubscriptionView) GetPaymentMethod() *PaymentMethodResponseData {
	if b == nil {
		return nil
	}
	return b.PaymentMethod
}

func (b *BillingSubscriptionView) GetPeriodEnd() int {
	if b == nil {
		return 0
	}
	return b.PeriodEnd
}

func (b *BillingSubscriptionView) GetPeriodStart() int {
	if b == nil {
		return 0
	}
	return b.PeriodStart
}

func (b *BillingSubscriptionView) GetProducts() []*BillingProductForSubscriptionResponseData {
	if b == nil {
		return nil
	}
	return b.Products
}

func (b *BillingSubscriptionView) GetStatus() string {
	if b == nil {
		return ""
	}
	return b.Status
}

func (b *BillingSubscriptionView) GetSubscriptionExternalID() string {
	if b == nil {
		return ""
	}
	return b.SubscriptionExternalID
}

func (b *BillingSubscriptionView) GetTotalPrice() int {
	if b == nil {
		return 0
	}
	return b.TotalPrice
}

func (b *BillingSubscriptionView) GetTrialEnd() *int {
	if b == nil {
		return nil
	}
	return b.TrialEnd
}

func (b *BillingSubscriptionView) GetExtraProperties() map[string]interface{} {
	return b.extraProperties
}

func (b *BillingSubscriptionView) UnmarshalJSON(data []byte) error {
	type embed BillingSubscriptionView
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		ExpiredAt *internal.DateTime `json:"expired_at,omitempty"`
	}{
		embed: embed(*b),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*b = BillingSubscriptionView(unmarshaler.embed)
	b.CreatedAt = unmarshaler.CreatedAt.Time()
	b.ExpiredAt = unmarshaler.ExpiredAt.TimePtr()
	extraProperties, err := internal.ExtractExtraProperties(data, *b)
	if err != nil {
		return err
	}
	b.extraProperties = extraProperties
	b.rawJSON = json.RawMessage(data)
	return nil
}

func (b *BillingSubscriptionView) MarshalJSON() ([]byte, error) {
	type embed BillingSubscriptionView
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		ExpiredAt *internal.DateTime `json:"expired_at,omitempty"`
	}{
		embed:     embed(*b),
		CreatedAt: internal.NewDateTime(b.CreatedAt),
		ExpiredAt: internal.NewOptionalDateTime(b.ExpiredAt),
	}
	return json.Marshal(marshaler)
}

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

type CompanyDetailResponseData struct {
	AddOns               []*CompanyPlanWithBillingSubView `json:"add_ons,omitempty" url:"add_ons,omitempty"`
	BillingSubscription  *BillingSubscriptionView         `json:"billing_subscription,omitempty" url:"billing_subscription,omitempty"`
	BillingSubscriptions []*BillingSubscriptionView       `json:"billing_subscriptions,omitempty" url:"billing_subscriptions,omitempty"`
	CreatedAt            time.Time                        `json:"created_at" url:"created_at"`
	EntityTraits         []*EntityTraitDetailResponseData `json:"entity_traits,omitempty" url:"entity_traits,omitempty"`
	EnvironmentID        string                           `json:"environment_id" url:"environment_id"`
	ID                   string                           `json:"id" url:"id"`
	Keys                 []*EntityKeyDetailResponseData   `json:"keys,omitempty" url:"keys,omitempty"`
	LastSeenAt           *time.Time                       `json:"last_seen_at,omitempty" url:"last_seen_at,omitempty"`
	LogoURL              *string                          `json:"logo_url,omitempty" url:"logo_url,omitempty"`
	Name                 string                           `json:"name" url:"name"`
	Plan                 *CompanyPlanWithBillingSubView   `json:"plan,omitempty" url:"plan,omitempty"`
	Plans                []*GenericPreviewObject          `json:"plans,omitempty" url:"plans,omitempty"`
	// A map of trait names to trait values
	Traits    map[string]interface{} `json:"traits,omitempty" url:"traits,omitempty"`
	UpdatedAt time.Time              `json:"updated_at" url:"updated_at"`
	UserCount int                    `json:"user_count" url:"user_count"`

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

func (c *CompanyDetailResponseData) GetAddOns() []*CompanyPlanWithBillingSubView {
	if c == nil {
		return nil
	}
	return c.AddOns
}

func (c *CompanyDetailResponseData) GetBillingSubscription() *BillingSubscriptionView {
	if c == nil {
		return nil
	}
	return c.BillingSubscription
}

func (c *CompanyDetailResponseData) GetBillingSubscriptions() []*BillingSubscriptionView {
	if c == nil {
		return nil
	}
	return c.BillingSubscriptions
}

func (c *CompanyDetailResponseData) GetCreatedAt() time.Time {
	if c == nil {
		return time.Time{}
	}
	return c.CreatedAt
}

func (c *CompanyDetailResponseData) GetEntityTraits() []*EntityTraitDetailResponseData {
	if c == nil {
		return nil
	}
	return c.EntityTraits
}

func (c *CompanyDetailResponseData) GetEnvironmentID() string {
	if c == nil {
		return ""
	}
	return c.EnvironmentID
}

func (c *CompanyDetailResponseData) GetID() string {
	if c == nil {
		return ""
	}
	return c.ID
}

func (c *CompanyDetailResponseData) GetKeys() []*EntityKeyDetailResponseData {
	if c == nil {
		return nil
	}
	return c.Keys
}

func (c *CompanyDetailResponseData) GetLastSeenAt() *time.Time {
	if c == nil {
		return nil
	}
	return c.LastSeenAt
}

func (c *CompanyDetailResponseData) GetLogoURL() *string {
	if c == nil {
		return nil
	}
	return c.LogoURL
}

func (c *CompanyDetailResponseData) GetName() string {
	if c == nil {
		return ""
	}
	return c.Name
}

func (c *CompanyDetailResponseData) GetPlan() *CompanyPlanWithBillingSubView {
	if c == nil {
		return nil
	}
	return c.Plan
}

func (c *CompanyDetailResponseData) GetPlans() []*GenericPreviewObject {
	if c == nil {
		return nil
	}
	return c.Plans
}

func (c *CompanyDetailResponseData) GetTraits() map[string]interface{} {
	if c == nil {
		return nil
	}
	return c.Traits
}

func (c *CompanyDetailResponseData) GetUpdatedAt() time.Time {
	if c == nil {
		return time.Time{}
	}
	return c.UpdatedAt
}

func (c *CompanyDetailResponseData) GetUserCount() int {
	if c == nil {
		return 0
	}
	return c.UserCount
}

func (c *CompanyDetailResponseData) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

func (c *CompanyDetailResponseData) UnmarshalJSON(data []byte) error {
	type embed CompanyDetailResponseData
	var unmarshaler = struct {
		embed
		CreatedAt  *internal.DateTime `json:"created_at"`
		LastSeenAt *internal.DateTime `json:"last_seen_at,omitempty"`
		UpdatedAt  *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*c),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*c = CompanyDetailResponseData(unmarshaler.embed)
	c.CreatedAt = unmarshaler.CreatedAt.Time()
	c.LastSeenAt = unmarshaler.LastSeenAt.TimePtr()
	c.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *c)
	if err != nil {
		return err
	}
	c.extraProperties = extraProperties
	c.rawJSON = json.RawMessage(data)
	return nil
}

func (c *CompanyDetailResponseData) MarshalJSON() ([]byte, error) {
	type embed CompanyDetailResponseData
	var marshaler = struct {
		embed
		CreatedAt  *internal.DateTime `json:"created_at"`
		LastSeenAt *internal.DateTime `json:"last_seen_at,omitempty"`
		UpdatedAt  *internal.DateTime `json:"updated_at"`
	}{
		embed:      embed(*c),
		CreatedAt:  internal.NewDateTime(c.CreatedAt),
		LastSeenAt: internal.NewOptionalDateTime(c.LastSeenAt),
		UpdatedAt:  internal.NewDateTime(c.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type CompanyMembershipDetailResponseData struct {
	Company   *CompanyResponseData `json:"company,omitempty" url:"company,omitempty"`
	CompanyID string               `json:"company_id" url:"company_id"`
	CreatedAt time.Time            `json:"created_at" url:"created_at"`
	ID        string               `json:"id" url:"id"`
	UpdatedAt time.Time            `json:"updated_at" url:"updated_at"`
	UserID    string               `json:"user_id" url:"user_id"`

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

func (c *CompanyMembershipDetailResponseData) GetCompany() *CompanyResponseData {
	if c == nil {
		return nil
	}
	return c.Company
}

func (c *CompanyMembershipDetailResponseData) GetCompanyID() string {
	if c == nil {
		return ""
	}
	return c.CompanyID
}

func (c *CompanyMembershipDetailResponseData) GetCreatedAt() time.Time {
	if c == nil {
		return time.Time{}
	}
	return c.CreatedAt
}

func (c *CompanyMembershipDetailResponseData) GetID() string {
	if c == nil {
		return ""
	}
	return c.ID
}

func (c *CompanyMembershipDetailResponseData) GetUpdatedAt() time.Time {
	if c == nil {
		return time.Time{}
	}
	return c.UpdatedAt
}

func (c *CompanyMembershipDetailResponseData) GetUserID() string {
	if c == nil {
		return ""
	}
	return c.UserID
}

func (c *CompanyMembershipDetailResponseData) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

func (c *CompanyMembershipDetailResponseData) UnmarshalJSON(data []byte) error {
	type embed CompanyMembershipDetailResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*c),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*c = CompanyMembershipDetailResponseData(unmarshaler.embed)
	c.CreatedAt = unmarshaler.CreatedAt.Time()
	c.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *c)
	if err != nil {
		return err
	}
	c.extraProperties = extraProperties
	c.rawJSON = json.RawMessage(data)
	return nil
}

func (c *CompanyMembershipDetailResponseData) MarshalJSON() ([]byte, error) {
	type embed CompanyMembershipDetailResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*c),
		CreatedAt: internal.NewDateTime(c.CreatedAt),
		UpdatedAt: internal.NewDateTime(c.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type CompanyMembershipResponseData struct {
	CompanyID string    `json:"company_id" url:"company_id"`
	CreatedAt time.Time `json:"created_at" url:"created_at"`
	ID        string    `json:"id" url:"id"`
	UpdatedAt time.Time `json:"updated_at" url:"updated_at"`
	UserID    string    `json:"user_id" url:"user_id"`

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

func (c *CompanyMembershipResponseData) GetCompanyID() string {
	if c == nil {
		return ""
	}
	return c.CompanyID
}

func (c *CompanyMembershipResponseData) GetCreatedAt() time.Time {
	if c == nil {
		return time.Time{}
	}
	return c.CreatedAt
}

func (c *CompanyMembershipResponseData) GetID() string {
	if c == nil {
		return ""
	}
	return c.ID
}

func (c *CompanyMembershipResponseData) GetUpdatedAt() time.Time {
	if c == nil {
		return time.Time{}
	}
	return c.UpdatedAt
}

func (c *CompanyMembershipResponseData) GetUserID() string {
	if c == nil {
		return ""
	}
	return c.UserID
}

func (c *CompanyMembershipResponseData) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

func (c *CompanyMembershipResponseData) UnmarshalJSON(data []byte) error {
	type embed CompanyMembershipResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*c),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*c = CompanyMembershipResponseData(unmarshaler.embed)
	c.CreatedAt = unmarshaler.CreatedAt.Time()
	c.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *c)
	if err != nil {
		return err
	}
	c.extraProperties = extraProperties
	c.rawJSON = json.RawMessage(data)
	return nil
}

func (c *CompanyMembershipResponseData) MarshalJSON() ([]byte, error) {
	type embed CompanyMembershipResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*c),
		CreatedAt: internal.NewDateTime(c.CreatedAt),
		UpdatedAt: internal.NewDateTime(c.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type CompanyPlanWithBillingSubView struct {
	BillingProductID *string `json:"billing_product_id,omitempty" url:"billing_product_id,omitempty"`
	Description      *string `json:"description,omitempty" url:"description,omitempty"`
	ID               string  `json:"id" url:"id"`
	ImageURL         *string `json:"image_url,omitempty" url:"image_url,omitempty"`
	Name             string  `json:"name" url:"name"`
	PlanPeriod       *string `json:"plan_period,omitempty" url:"plan_period,omitempty"`
	PlanPrice        *int    `json:"plan_price,omitempty" url:"plan_price,omitempty"`

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

func (c *CompanyPlanWithBillingSubView) GetBillingProductID() *string {
	if c == nil {
		return nil
	}
	return c.BillingProductID
}

func (c *CompanyPlanWithBillingSubView) GetDescription() *string {
	if c == nil {
		return nil
	}
	return c.Description
}

func (c *CompanyPlanWithBillingSubView) GetID() string {
	if c == nil {
		return ""
	}
	return c.ID
}

func (c *CompanyPlanWithBillingSubView) GetImageURL() *string {
	if c == nil {
		return nil
	}
	return c.ImageURL
}

func (c *CompanyPlanWithBillingSubView) GetName() string {
	if c == nil {
		return ""
	}
	return c.Name
}

func (c *CompanyPlanWithBillingSubView) GetPlanPeriod() *string {
	if c == nil {
		return nil
	}
	return c.PlanPeriod
}

func (c *CompanyPlanWithBillingSubView) GetPlanPrice() *int {
	if c == nil {
		return nil
	}
	return c.PlanPrice
}

func (c *CompanyPlanWithBillingSubView) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

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

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

type CompanyResponseData struct {
	CreatedAt     time.Time  `json:"created_at" url:"created_at"`
	EnvironmentID string     `json:"environment_id" url:"environment_id"`
	ID            string     `json:"id" url:"id"`
	LastSeenAt    *time.Time `json:"last_seen_at,omitempty" url:"last_seen_at,omitempty"`
	LogoURL       *string    `json:"logo_url,omitempty" url:"logo_url,omitempty"`
	Name          string     `json:"name" url:"name"`
	UpdatedAt     time.Time  `json:"updated_at" url:"updated_at"`

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

func (c *CompanyResponseData) GetCreatedAt() time.Time {
	if c == nil {
		return time.Time{}
	}
	return c.CreatedAt
}

func (c *CompanyResponseData) GetEnvironmentID() string {
	if c == nil {
		return ""
	}
	return c.EnvironmentID
}

func (c *CompanyResponseData) GetID() string {
	if c == nil {
		return ""
	}
	return c.ID
}

func (c *CompanyResponseData) GetLastSeenAt() *time.Time {
	if c == nil {
		return nil
	}
	return c.LastSeenAt
}

func (c *CompanyResponseData) GetLogoURL() *string {
	if c == nil {
		return nil
	}
	return c.LogoURL
}

func (c *CompanyResponseData) GetName() string {
	if c == nil {
		return ""
	}
	return c.Name
}

func (c *CompanyResponseData) GetUpdatedAt() time.Time {
	if c == nil {
		return time.Time{}
	}
	return c.UpdatedAt
}

func (c *CompanyResponseData) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

func (c *CompanyResponseData) UnmarshalJSON(data []byte) error {
	type embed CompanyResponseData
	var unmarshaler = struct {
		embed
		CreatedAt  *internal.DateTime `json:"created_at"`
		LastSeenAt *internal.DateTime `json:"last_seen_at,omitempty"`
		UpdatedAt  *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*c),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*c = CompanyResponseData(unmarshaler.embed)
	c.CreatedAt = unmarshaler.CreatedAt.Time()
	c.LastSeenAt = unmarshaler.LastSeenAt.TimePtr()
	c.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *c)
	if err != nil {
		return err
	}
	c.extraProperties = extraProperties
	c.rawJSON = json.RawMessage(data)
	return nil
}

func (c *CompanyResponseData) MarshalJSON() ([]byte, error) {
	type embed CompanyResponseData
	var marshaler = struct {
		embed
		CreatedAt  *internal.DateTime `json:"created_at"`
		LastSeenAt *internal.DateTime `json:"last_seen_at,omitempty"`
		UpdatedAt  *internal.DateTime `json:"updated_at"`
	}{
		embed:      embed(*c),
		CreatedAt:  internal.NewDateTime(c.CreatedAt),
		LastSeenAt: internal.NewOptionalDateTime(c.LastSeenAt),
		UpdatedAt:  internal.NewDateTime(c.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type CompanySubscriptionResponseData struct {
	Currency               string                                       `json:"currency" url:"currency"`
	CustomerExternalID     string                                       `json:"customer_external_id" url:"customer_external_id"`
	ExpiredAt              *time.Time                                   `json:"expired_at,omitempty" url:"expired_at,omitempty"`
	Interval               string                                       `json:"interval" url:"interval"`
	LatestInvoice          *InvoiceResponseData                         `json:"latest_invoice,omitempty" url:"latest_invoice,omitempty"`
	PaymentMethod          *PaymentMethodResponseData                   `json:"payment_method,omitempty" url:"payment_method,omitempty"`
	Products               []*BillingProductForSubscriptionResponseData `json:"products,omitempty" url:"products,omitempty"`
	Status                 string                                       `json:"status" url:"status"`
	SubscriptionExternalID string                                       `json:"subscription_external_id" url:"subscription_external_id"`
	TotalPrice             int                                          `json:"total_price" url:"total_price"`

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

func (c *CompanySubscriptionResponseData) GetCurrency() string {
	if c == nil {
		return ""
	}
	return c.Currency
}

func (c *CompanySubscriptionResponseData) GetCustomerExternalID() string {
	if c == nil {
		return ""
	}
	return c.CustomerExternalID
}

func (c *CompanySubscriptionResponseData) GetExpiredAt() *time.Time {
	if c == nil {
		return nil
	}
	return c.ExpiredAt
}

func (c *CompanySubscriptionResponseData) GetInterval() string {
	if c == nil {
		return ""
	}
	return c.Interval
}

func (c *CompanySubscriptionResponseData) GetLatestInvoice() *InvoiceResponseData {
	if c == nil {
		return nil
	}
	return c.LatestInvoice
}

func (c *CompanySubscriptionResponseData) GetPaymentMethod() *PaymentMethodResponseData {
	if c == nil {
		return nil
	}
	return c.PaymentMethod
}

func (c *CompanySubscriptionResponseData) GetProducts() []*BillingProductForSubscriptionResponseData {
	if c == nil {
		return nil
	}
	return c.Products
}

func (c *CompanySubscriptionResponseData) GetStatus() string {
	if c == nil {
		return ""
	}
	return c.Status
}

func (c *CompanySubscriptionResponseData) GetSubscriptionExternalID() string {
	if c == nil {
		return ""
	}
	return c.SubscriptionExternalID
}

func (c *CompanySubscriptionResponseData) GetTotalPrice() int {
	if c == nil {
		return 0
	}
	return c.TotalPrice
}

func (c *CompanySubscriptionResponseData) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

func (c *CompanySubscriptionResponseData) UnmarshalJSON(data []byte) error {
	type embed CompanySubscriptionResponseData
	var unmarshaler = struct {
		embed
		ExpiredAt *internal.DateTime `json:"expired_at,omitempty"`
	}{
		embed: embed(*c),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*c = CompanySubscriptionResponseData(unmarshaler.embed)
	c.ExpiredAt = unmarshaler.ExpiredAt.TimePtr()
	extraProperties, err := internal.ExtractExtraProperties(data, *c)
	if err != nil {
		return err
	}
	c.extraProperties = extraProperties
	c.rawJSON = json.RawMessage(data)
	return nil
}

func (c *CompanySubscriptionResponseData) MarshalJSON() ([]byte, error) {
	type embed CompanySubscriptionResponseData
	var marshaler = struct {
		embed
		ExpiredAt *internal.DateTime `json:"expired_at,omitempty"`
	}{
		embed:     embed(*c),
		ExpiredAt: internal.NewOptionalDateTime(c.ExpiredAt),
	}
	return json.Marshal(marshaler)
}

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

type ComponentHydrateResponseData struct {
	ActiveAddOns                 []*CompanyPlanDetailResponseData     `json:"active_add_ons,omitempty" url:"active_add_ons,omitempty"`
	ActivePlans                  []*CompanyPlanDetailResponseData     `json:"active_plans,omitempty" url:"active_plans,omitempty"`
	ActiveUsageBasedEntitlements []*UsageBasedEntitlementResponseData `json:"active_usage_based_entitlements,omitempty" url:"active_usage_based_entitlements,omitempty"`
	Capabilities                 *ComponentCapabilities               `json:"capabilities,omitempty" url:"capabilities,omitempty"`
	Company                      *CompanyDetailResponseData           `json:"company,omitempty" url:"company,omitempty"`
	Component                    *ComponentResponseData               `json:"component,omitempty" url:"component,omitempty"`
	FeatureUsage                 *FeatureUsageDetailResponseData      `json:"feature_usage,omitempty" url:"feature_usage,omitempty"`
	StripeEmbed                  *StripeEmbedInfo                     `json:"stripe_embed,omitempty" url:"stripe_embed,omitempty"`
	Subscription                 *CompanySubscriptionResponseData     `json:"subscription,omitempty" url:"subscription,omitempty"`
	UpcomingInvoice              *InvoiceResponseData                 `json:"upcoming_invoice,omitempty" url:"upcoming_invoice,omitempty"`

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

func (c *ComponentHydrateResponseData) GetActiveAddOns() []*CompanyPlanDetailResponseData {
	if c == nil {
		return nil
	}
	return c.ActiveAddOns
}

func (c *ComponentHydrateResponseData) GetActivePlans() []*CompanyPlanDetailResponseData {
	if c == nil {
		return nil
	}
	return c.ActivePlans
}

func (c *ComponentHydrateResponseData) GetActiveUsageBasedEntitlements() []*UsageBasedEntitlementResponseData {
	if c == nil {
		return nil
	}
	return c.ActiveUsageBasedEntitlements
}

func (c *ComponentHydrateResponseData) GetCapabilities() *ComponentCapabilities {
	if c == nil {
		return nil
	}
	return c.Capabilities
}

func (c *ComponentHydrateResponseData) GetCompany() *CompanyDetailResponseData {
	if c == nil {
		return nil
	}
	return c.Company
}

func (c *ComponentHydrateResponseData) GetComponent() *ComponentResponseData {
	if c == nil {
		return nil
	}
	return c.Component
}

func (c *ComponentHydrateResponseData) GetFeatureUsage() *FeatureUsageDetailResponseData {
	if c == nil {
		return nil
	}
	return c.FeatureUsage
}

func (c *ComponentHydrateResponseData) GetStripeEmbed() *StripeEmbedInfo {
	if c == nil {
		return nil
	}
	return c.StripeEmbed
}

func (c *ComponentHydrateResponseData) GetSubscription() *CompanySubscriptionResponseData {
	if c == nil {
		return nil
	}
	return c.Subscription
}

func (c *ComponentHydrateResponseData) GetUpcomingInvoice() *InvoiceResponseData {
	if c == nil {
		return nil
	}
	return c.UpcomingInvoice
}

func (c *ComponentHydrateResponseData) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

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

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

// The created resource
type CountResponse struct {
	Count int `json:"count" url:"count"`

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

func (c *CountResponse) GetCount() int {
	if c == nil {
		return 0
	}
	return c.Count
}

func (c *CountResponse) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

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

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

type CreateEntitlementReqCommon struct {
	FeatureID              string                                            `json:"feature_id" url:"feature_id"`
	MeteredMonthlyPriceID  *string                                           `json:"metered_monthly_price_id,omitempty" url:"metered_monthly_price_id,omitempty"`
	MeteredYearlyPriceID   *string                                           `json:"metered_yearly_price_id,omitempty" url:"metered_yearly_price_id,omitempty"`
	MetricPeriod           *CreateEntitlementReqCommonMetricPeriod           `json:"metric_period,omitempty" url:"metric_period,omitempty"`
	MetricPeriodMonthReset *CreateEntitlementReqCommonMetricPeriodMonthReset `json:"metric_period_month_reset,omitempty" url:"metric_period_month_reset,omitempty"`
	ValueBool              *bool                                             `json:"value_bool,omitempty" url:"value_bool,omitempty"`
	ValueNumeric           *int                                              `json:"value_numeric,omitempty" url:"value_numeric,omitempty"`
	ValueTraitID           *string                                           `json:"value_trait_id,omitempty" url:"value_trait_id,omitempty"`
	ValueType              CreateEntitlementReqCommonValueType               `json:"value_type" url:"value_type"`

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

func (c *CreateEntitlementReqCommon) GetFeatureID() string {
	if c == nil {
		return ""
	}
	return c.FeatureID
}

func (c *CreateEntitlementReqCommon) GetMeteredMonthlyPriceID() *string {
	if c == nil {
		return nil
	}
	return c.MeteredMonthlyPriceID
}

func (c *CreateEntitlementReqCommon) GetMeteredYearlyPriceID() *string {
	if c == nil {
		return nil
	}
	return c.MeteredYearlyPriceID
}

func (c *CreateEntitlementReqCommon) GetMetricPeriod() *CreateEntitlementReqCommonMetricPeriod {
	if c == nil {
		return nil
	}
	return c.MetricPeriod
}

func (c *CreateEntitlementReqCommon) GetMetricPeriodMonthReset() *CreateEntitlementReqCommonMetricPeriodMonthReset {
	if c == nil {
		return nil
	}
	return c.MetricPeriodMonthReset
}

func (c *CreateEntitlementReqCommon) GetValueBool() *bool {
	if c == nil {
		return nil
	}
	return c.ValueBool
}

func (c *CreateEntitlementReqCommon) GetValueNumeric() *int {
	if c == nil {
		return nil
	}
	return c.ValueNumeric
}

func (c *CreateEntitlementReqCommon) GetValueTraitID() *string {
	if c == nil {
		return nil
	}
	return c.ValueTraitID
}

func (c *CreateEntitlementReqCommon) GetValueType() CreateEntitlementReqCommonValueType {
	if c == nil {
		return ""
	}
	return c.ValueType
}

func (c *CreateEntitlementReqCommon) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

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

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

type CreateEntitlementReqCommonMetricPeriod string

const (
	CreateEntitlementReqCommonMetricPeriodAllTime      CreateEntitlementReqCommonMetricPeriod = "all_time"
	CreateEntitlementReqCommonMetricPeriodBilling      CreateEntitlementReqCommonMetricPeriod = "billing"
	CreateEntitlementReqCommonMetricPeriodCurrentMonth CreateEntitlementReqCommonMetricPeriod = "current_month"
	CreateEntitlementReqCommonMetricPeriodCurrentWeek  CreateEntitlementReqCommonMetricPeriod = "current_week"
	CreateEntitlementReqCommonMetricPeriodCurrentDay   CreateEntitlementReqCommonMetricPeriod = "current_day"
)

func NewCreateEntitlementReqCommonMetricPeriodFromString(s string) (CreateEntitlementReqCommonMetricPeriod, error) {
	switch s {
	case "all_time":
		return CreateEntitlementReqCommonMetricPeriodAllTime, nil
	case "billing":
		return CreateEntitlementReqCommonMetricPeriodBilling, nil
	case "current_month":
		return CreateEntitlementReqCommonMetricPeriodCurrentMonth, nil
	case "current_week":
		return CreateEntitlementReqCommonMetricPeriodCurrentWeek, nil
	case "current_day":
		return CreateEntitlementReqCommonMetricPeriodCurrentDay, nil
	}
	var t CreateEntitlementReqCommonMetricPeriod
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (c CreateEntitlementReqCommonMetricPeriod) Ptr() *CreateEntitlementReqCommonMetricPeriod {
	return &c
}

type CreateEntitlementReqCommonMetricPeriodMonthReset string

const (
	CreateEntitlementReqCommonMetricPeriodMonthResetFirstOfMonth CreateEntitlementReqCommonMetricPeriodMonthReset = "first_of_month"
	CreateEntitlementReqCommonMetricPeriodMonthResetBillingCycle CreateEntitlementReqCommonMetricPeriodMonthReset = "billing_cycle"
)

func NewCreateEntitlementReqCommonMetricPeriodMonthResetFromString(s string) (CreateEntitlementReqCommonMetricPeriodMonthReset, error) {
	switch s {
	case "first_of_month":
		return CreateEntitlementReqCommonMetricPeriodMonthResetFirstOfMonth, nil
	case "billing_cycle":
		return CreateEntitlementReqCommonMetricPeriodMonthResetBillingCycle, nil
	}
	var t CreateEntitlementReqCommonMetricPeriodMonthReset
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (c CreateEntitlementReqCommonMetricPeriodMonthReset) Ptr() *CreateEntitlementReqCommonMetricPeriodMonthReset {
	return &c
}

type CreateEntitlementReqCommonValueType string

const (
	CreateEntitlementReqCommonValueTypeBoolean   CreateEntitlementReqCommonValueType = "boolean"
	CreateEntitlementReqCommonValueTypeNumeric   CreateEntitlementReqCommonValueType = "numeric"
	CreateEntitlementReqCommonValueTypeTrait     CreateEntitlementReqCommonValueType = "trait"
	CreateEntitlementReqCommonValueTypeUnlimited CreateEntitlementReqCommonValueType = "unlimited"
)

func NewCreateEntitlementReqCommonValueTypeFromString(s string) (CreateEntitlementReqCommonValueType, error) {
	switch s {
	case "boolean":
		return CreateEntitlementReqCommonValueTypeBoolean, nil
	case "numeric":
		return CreateEntitlementReqCommonValueTypeNumeric, nil
	case "trait":
		return CreateEntitlementReqCommonValueTypeTrait, nil
	case "unlimited":
		return CreateEntitlementReqCommonValueTypeUnlimited, nil
	}
	var t CreateEntitlementReqCommonValueType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (c CreateEntitlementReqCommonValueType) Ptr() *CreateEntitlementReqCommonValueType {
	return &c
}

type CreateOrUpdateConditionGroupRequestBody struct {
	Conditions []*CreateOrUpdateConditionRequestBody `json:"conditions,omitempty" url:"conditions,omitempty"`
	FlagID     *string                               `json:"flag_id,omitempty" url:"flag_id,omitempty"`
	ID         *string                               `json:"id,omitempty" url:"id,omitempty"`
	PlanID     *string                               `json:"plan_id,omitempty" url:"plan_id,omitempty"`

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

func (c *CreateOrUpdateConditionGroupRequestBody) GetConditions() []*CreateOrUpdateConditionRequestBody {
	if c == nil {
		return nil
	}
	return c.Conditions
}

func (c *CreateOrUpdateConditionGroupRequestBody) GetFlagID() *string {
	if c == nil {
		return nil
	}
	return c.FlagID
}

func (c *CreateOrUpdateConditionGroupRequestBody) GetID() *string {
	if c == nil {
		return nil
	}
	return c.ID
}

func (c *CreateOrUpdateConditionGroupRequestBody) GetPlanID() *string {
	if c == nil {
		return nil
	}
	return c.PlanID
}

func (c *CreateOrUpdateConditionGroupRequestBody) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

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

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

type CreateOrUpdateConditionRequestBody struct {
	// Optionally provide a trait ID to compare a metric or trait value against instead of a value
	ComparisonTraitID *string                                         `json:"comparison_trait_id,omitempty" url:"comparison_trait_id,omitempty"`
	ConditionType     CreateOrUpdateConditionRequestBodyConditionType `json:"condition_type" url:"condition_type"`
	// Name of track event type used to measure this condition
	EventSubtype *string `json:"event_subtype,omitempty" url:"event_subtype,omitempty"`
	ID           *string `json:"id,omitempty" url:"id,omitempty"`
	// Period of time over which to measure the track event metric
	MetricPeriod *CreateOrUpdateConditionRequestBodyMetricPeriod `json:"metric_period,omitempty" url:"metric_period,omitempty"`
	// When metric_period=current_month, specify whether the month restarts based on the calendar month or the billing period
	MetricPeriodMonthReset *CreateOrUpdateConditionRequestBodyMetricPeriodMonthReset `json:"metric_period_month_reset,omitempty" url:"metric_period_month_reset,omitempty"`
	// Value to compare the track event metric against
	MetricValue *int                                       `json:"metric_value,omitempty" url:"metric_value,omitempty"`
	Operator    CreateOrUpdateConditionRequestBodyOperator `json:"operator" url:"operator"`
	// List of resource IDs (companies, users, or plans) targeted by this condition
	ResourceIDs []string `json:"resource_ids,omitempty" url:"resource_ids,omitempty"`
	// ID of trait to use to measure this condition
	TraitID *string `json:"trait_id,omitempty" url:"trait_id,omitempty"`
	// Value to compare the trait value against
	TraitValue *string `json:"trait_value,omitempty" url:"trait_value,omitempty"`

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

func (c *CreateOrUpdateConditionRequestBody) GetComparisonTraitID() *string {
	if c == nil {
		return nil
	}
	return c.ComparisonTraitID
}

func (c *CreateOrUpdateConditionRequestBody) GetConditionType() CreateOrUpdateConditionRequestBodyConditionType {
	if c == nil {
		return ""
	}
	return c.ConditionType
}

func (c *CreateOrUpdateConditionRequestBody) GetEventSubtype() *string {
	if c == nil {
		return nil
	}
	return c.EventSubtype
}

func (c *CreateOrUpdateConditionRequestBody) GetID() *string {
	if c == nil {
		return nil
	}
	return c.ID
}

func (c *CreateOrUpdateConditionRequestBody) GetMetricPeriod() *CreateOrUpdateConditionRequestBodyMetricPeriod {
	if c == nil {
		return nil
	}
	return c.MetricPeriod
}

func (c *CreateOrUpdateConditionRequestBody) GetMetricPeriodMonthReset() *CreateOrUpdateConditionRequestBodyMetricPeriodMonthReset {
	if c == nil {
		return nil
	}
	return c.MetricPeriodMonthReset
}

func (c *CreateOrUpdateConditionRequestBody) GetMetricValue() *int {
	if c == nil {
		return nil
	}
	return c.MetricValue
}

func (c *CreateOrUpdateConditionRequestBody) GetOperator() CreateOrUpdateConditionRequestBodyOperator {
	if c == nil {
		return ""
	}
	return c.Operator
}

func (c *CreateOrUpdateConditionRequestBody) GetResourceIDs() []string {
	if c == nil {
		return nil
	}
	return c.ResourceIDs
}

func (c *CreateOrUpdateConditionRequestBody) GetTraitID() *string {
	if c == nil {
		return nil
	}
	return c.TraitID
}

func (c *CreateOrUpdateConditionRequestBody) GetTraitValue() *string {
	if c == nil {
		return nil
	}
	return c.TraitValue
}

func (c *CreateOrUpdateConditionRequestBody) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

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

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

type CreateOrUpdateConditionRequestBodyConditionType string

const (
	CreateOrUpdateConditionRequestBodyConditionTypeCompany        CreateOrUpdateConditionRequestBodyConditionType = "company"
	CreateOrUpdateConditionRequestBodyConditionTypeMetric         CreateOrUpdateConditionRequestBodyConditionType = "metric"
	CreateOrUpdateConditionRequestBodyConditionTypeTrait          CreateOrUpdateConditionRequestBodyConditionType = "trait"
	CreateOrUpdateConditionRequestBodyConditionTypeUser           CreateOrUpdateConditionRequestBodyConditionType = "user"
	CreateOrUpdateConditionRequestBodyConditionTypePlan           CreateOrUpdateConditionRequestBodyConditionType = "plan"
	CreateOrUpdateConditionRequestBodyConditionTypeBillingProduct CreateOrUpdateConditionRequestBodyConditionType = "billing_product"
	CreateOrUpdateConditionRequestBodyConditionTypeCrmProduct     CreateOrUpdateConditionRequestBodyConditionType = "crm_product"
	CreateOrUpdateConditionRequestBodyConditionTypeBasePlan       CreateOrUpdateConditionRequestBodyConditionType = "base_plan"
)

func NewCreateOrUpdateConditionRequestBodyConditionTypeFromString(s string) (CreateOrUpdateConditionRequestBodyConditionType, error) {
	switch s {
	case "company":
		return CreateOrUpdateConditionRequestBodyConditionTypeCompany, nil
	case "metric":
		return CreateOrUpdateConditionRequestBodyConditionTypeMetric, nil
	case "trait":
		return CreateOrUpdateConditionRequestBodyConditionTypeTrait, nil
	case "user":
		return CreateOrUpdateConditionRequestBodyConditionTypeUser, nil
	case "plan":
		return CreateOrUpdateConditionRequestBodyConditionTypePlan, nil
	case "billing_product":
		return CreateOrUpdateConditionRequestBodyConditionTypeBillingProduct, nil
	case "crm_product":
		return CreateOrUpdateConditionRequestBodyConditionTypeCrmProduct, nil
	case "base_plan":
		return CreateOrUpdateConditionRequestBodyConditionTypeBasePlan, nil
	}
	var t CreateOrUpdateConditionRequestBodyConditionType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (c CreateOrUpdateConditionRequestBodyConditionType) Ptr() *CreateOrUpdateConditionRequestBodyConditionType {
	return &c
}

// Period of time over which to measure the track event metric
type CreateOrUpdateConditionRequestBodyMetricPeriod string

const (
	CreateOrUpdateConditionRequestBodyMetricPeriodAllTime      CreateOrUpdateConditionRequestBodyMetricPeriod = "all_time"
	CreateOrUpdateConditionRequestBodyMetricPeriodBilling      CreateOrUpdateConditionRequestBodyMetricPeriod = "billing"
	CreateOrUpdateConditionRequestBodyMetricPeriodCurrentMonth CreateOrUpdateConditionRequestBodyMetricPeriod = "current_month"
	CreateOrUpdateConditionRequestBodyMetricPeriodCurrentWeek  CreateOrUpdateConditionRequestBodyMetricPeriod = "current_week"
	CreateOrUpdateConditionRequestBodyMetricPeriodCurrentDay   CreateOrUpdateConditionRequestBodyMetricPeriod = "current_day"
)

func NewCreateOrUpdateConditionRequestBodyMetricPeriodFromString(s string) (CreateOrUpdateConditionRequestBodyMetricPeriod, error) {
	switch s {
	case "all_time":
		return CreateOrUpdateConditionRequestBodyMetricPeriodAllTime, nil
	case "billing":
		return CreateOrUpdateConditionRequestBodyMetricPeriodBilling, nil
	case "current_month":
		return CreateOrUpdateConditionRequestBodyMetricPeriodCurrentMonth, nil
	case "current_week":
		return CreateOrUpdateConditionRequestBodyMetricPeriodCurrentWeek, nil
	case "current_day":
		return CreateOrUpdateConditionRequestBodyMetricPeriodCurrentDay, nil
	}
	var t CreateOrUpdateConditionRequestBodyMetricPeriod
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (c CreateOrUpdateConditionRequestBodyMetricPeriod) Ptr() *CreateOrUpdateConditionRequestBodyMetricPeriod {
	return &c
}

// When metric_period=current_month, specify whether the month restarts based on the calendar month or the billing period
type CreateOrUpdateConditionRequestBodyMetricPeriodMonthReset string

const (
	CreateOrUpdateConditionRequestBodyMetricPeriodMonthResetFirstOfMonth CreateOrUpdateConditionRequestBodyMetricPeriodMonthReset = "first_of_month"
	CreateOrUpdateConditionRequestBodyMetricPeriodMonthResetBillingCycle CreateOrUpdateConditionRequestBodyMetricPeriodMonthReset = "billing_cycle"
)

func NewCreateOrUpdateConditionRequestBodyMetricPeriodMonthResetFromString(s string) (CreateOrUpdateConditionRequestBodyMetricPeriodMonthReset, error) {
	switch s {
	case "first_of_month":
		return CreateOrUpdateConditionRequestBodyMetricPeriodMonthResetFirstOfMonth, nil
	case "billing_cycle":
		return CreateOrUpdateConditionRequestBodyMetricPeriodMonthResetBillingCycle, nil
	}
	var t CreateOrUpdateConditionRequestBodyMetricPeriodMonthReset
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (c CreateOrUpdateConditionRequestBodyMetricPeriodMonthReset) Ptr() *CreateOrUpdateConditionRequestBodyMetricPeriodMonthReset {
	return &c
}

type CreateOrUpdateConditionRequestBodyOperator string

const (
	CreateOrUpdateConditionRequestBodyOperatorEq       CreateOrUpdateConditionRequestBodyOperator = "eq"
	CreateOrUpdateConditionRequestBodyOperatorNe       CreateOrUpdateConditionRequestBodyOperator = "ne"
	CreateOrUpdateConditionRequestBodyOperatorGt       CreateOrUpdateConditionRequestBodyOperator = "gt"
	CreateOrUpdateConditionRequestBodyOperatorGte      CreateOrUpdateConditionRequestBodyOperator = "gte"
	CreateOrUpdateConditionRequestBodyOperatorLt       CreateOrUpdateConditionRequestBodyOperator = "lt"
	CreateOrUpdateConditionRequestBodyOperatorLte      CreateOrUpdateConditionRequestBodyOperator = "lte"
	CreateOrUpdateConditionRequestBodyOperatorIsEmpty  CreateOrUpdateConditionRequestBodyOperator = "is_empty"
	CreateOrUpdateConditionRequestBodyOperatorNotEmpty CreateOrUpdateConditionRequestBodyOperator = "not_empty"
)

func NewCreateOrUpdateConditionRequestBodyOperatorFromString(s string) (CreateOrUpdateConditionRequestBodyOperator, error) {
	switch s {
	case "eq":
		return CreateOrUpdateConditionRequestBodyOperatorEq, nil
	case "ne":
		return CreateOrUpdateConditionRequestBodyOperatorNe, nil
	case "gt":
		return CreateOrUpdateConditionRequestBodyOperatorGt, nil
	case "gte":
		return CreateOrUpdateConditionRequestBodyOperatorGte, nil
	case "lt":
		return CreateOrUpdateConditionRequestBodyOperatorLt, nil
	case "lte":
		return CreateOrUpdateConditionRequestBodyOperatorLte, nil
	case "is_empty":
		return CreateOrUpdateConditionRequestBodyOperatorIsEmpty, nil
	case "not_empty":
		return CreateOrUpdateConditionRequestBodyOperatorNotEmpty, nil
	}
	var t CreateOrUpdateConditionRequestBodyOperator
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (c CreateOrUpdateConditionRequestBodyOperator) Ptr() *CreateOrUpdateConditionRequestBodyOperator {
	return &c
}

type DeleteResponse struct {
	// Whether the delete was successful
	Deleted *bool `json:"deleted,omitempty" url:"deleted,omitempty"`

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

func (d *DeleteResponse) GetDeleted() *bool {
	if d == nil {
		return nil
	}
	return d.Deleted
}

func (d *DeleteResponse) GetExtraProperties() map[string]interface{} {
	return d.extraProperties
}

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

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

type EntityKeyDefinitionResponseData struct {
	CreatedAt  time.Time `json:"created_at" url:"created_at"`
	EntityType string    `json:"entity_type" url:"entity_type"`
	ID         string    `json:"id" url:"id"`
	Key        string    `json:"key" url:"key"`
	UpdatedAt  time.Time `json:"updated_at" url:"updated_at"`

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

func (e *EntityKeyDefinitionResponseData) GetCreatedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.CreatedAt
}

func (e *EntityKeyDefinitionResponseData) GetEntityType() string {
	if e == nil {
		return ""
	}
	return e.EntityType
}

func (e *EntityKeyDefinitionResponseData) GetID() string {
	if e == nil {
		return ""
	}
	return e.ID
}

func (e *EntityKeyDefinitionResponseData) GetKey() string {
	if e == nil {
		return ""
	}
	return e.Key
}

func (e *EntityKeyDefinitionResponseData) GetUpdatedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.UpdatedAt
}

func (e *EntityKeyDefinitionResponseData) GetExtraProperties() map[string]interface{} {
	return e.extraProperties
}

func (e *EntityKeyDefinitionResponseData) UnmarshalJSON(data []byte) error {
	type embed EntityKeyDefinitionResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*e),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*e = EntityKeyDefinitionResponseData(unmarshaler.embed)
	e.CreatedAt = unmarshaler.CreatedAt.Time()
	e.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *e)
	if err != nil {
		return err
	}
	e.extraProperties = extraProperties
	e.rawJSON = json.RawMessage(data)
	return nil
}

func (e *EntityKeyDefinitionResponseData) MarshalJSON() ([]byte, error) {
	type embed EntityKeyDefinitionResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*e),
		CreatedAt: internal.NewDateTime(e.CreatedAt),
		UpdatedAt: internal.NewDateTime(e.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type EntityKeyDetailResponseData struct {
	CreatedAt     time.Time                        `json:"created_at" url:"created_at"`
	Definition    *EntityKeyDefinitionResponseData `json:"definition,omitempty" url:"definition,omitempty"`
	DefinitionID  string                           `json:"definition_id" url:"definition_id"`
	EntityID      string                           `json:"entity_id" url:"entity_id"`
	EntityType    string                           `json:"entity_type" url:"entity_type"`
	EnvironmentID string                           `json:"environment_id" url:"environment_id"`
	ID            string                           `json:"id" url:"id"`
	Key           string                           `json:"key" url:"key"`
	UpdatedAt     time.Time                        `json:"updated_at" url:"updated_at"`
	Value         string                           `json:"value" url:"value"`

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

func (e *EntityKeyDetailResponseData) GetCreatedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.CreatedAt
}

func (e *EntityKeyDetailResponseData) GetDefinition() *EntityKeyDefinitionResponseData {
	if e == nil {
		return nil
	}
	return e.Definition
}

func (e *EntityKeyDetailResponseData) GetDefinitionID() string {
	if e == nil {
		return ""
	}
	return e.DefinitionID
}

func (e *EntityKeyDetailResponseData) GetEntityID() string {
	if e == nil {
		return ""
	}
	return e.EntityID
}

func (e *EntityKeyDetailResponseData) GetEntityType() string {
	if e == nil {
		return ""
	}
	return e.EntityType
}

func (e *EntityKeyDetailResponseData) GetEnvironmentID() string {
	if e == nil {
		return ""
	}
	return e.EnvironmentID
}

func (e *EntityKeyDetailResponseData) GetID() string {
	if e == nil {
		return ""
	}
	return e.ID
}

func (e *EntityKeyDetailResponseData) GetKey() string {
	if e == nil {
		return ""
	}
	return e.Key
}

func (e *EntityKeyDetailResponseData) GetUpdatedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.UpdatedAt
}

func (e *EntityKeyDetailResponseData) GetValue() string {
	if e == nil {
		return ""
	}
	return e.Value
}

func (e *EntityKeyDetailResponseData) GetExtraProperties() map[string]interface{} {
	return e.extraProperties
}

func (e *EntityKeyDetailResponseData) UnmarshalJSON(data []byte) error {
	type embed EntityKeyDetailResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*e),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*e = EntityKeyDetailResponseData(unmarshaler.embed)
	e.CreatedAt = unmarshaler.CreatedAt.Time()
	e.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *e)
	if err != nil {
		return err
	}
	e.extraProperties = extraProperties
	e.rawJSON = json.RawMessage(data)
	return nil
}

func (e *EntityKeyDetailResponseData) MarshalJSON() ([]byte, error) {
	type embed EntityKeyDetailResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*e),
		CreatedAt: internal.NewDateTime(e.CreatedAt),
		UpdatedAt: internal.NewDateTime(e.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type EntityKeyResponseData struct {
	CreatedAt     time.Time `json:"created_at" url:"created_at"`
	DefinitionID  string    `json:"definition_id" url:"definition_id"`
	EntityID      string    `json:"entity_id" url:"entity_id"`
	EntityType    string    `json:"entity_type" url:"entity_type"`
	EnvironmentID string    `json:"environment_id" url:"environment_id"`
	ID            string    `json:"id" url:"id"`
	Key           string    `json:"key" url:"key"`
	UpdatedAt     time.Time `json:"updated_at" url:"updated_at"`
	Value         string    `json:"value" url:"value"`

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

func (e *EntityKeyResponseData) GetCreatedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.CreatedAt
}

func (e *EntityKeyResponseData) GetDefinitionID() string {
	if e == nil {
		return ""
	}
	return e.DefinitionID
}

func (e *EntityKeyResponseData) GetEntityID() string {
	if e == nil {
		return ""
	}
	return e.EntityID
}

func (e *EntityKeyResponseData) GetEntityType() string {
	if e == nil {
		return ""
	}
	return e.EntityType
}

func (e *EntityKeyResponseData) GetEnvironmentID() string {
	if e == nil {
		return ""
	}
	return e.EnvironmentID
}

func (e *EntityKeyResponseData) GetID() string {
	if e == nil {
		return ""
	}
	return e.ID
}

func (e *EntityKeyResponseData) GetKey() string {
	if e == nil {
		return ""
	}
	return e.Key
}

func (e *EntityKeyResponseData) GetUpdatedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.UpdatedAt
}

func (e *EntityKeyResponseData) GetValue() string {
	if e == nil {
		return ""
	}
	return e.Value
}

func (e *EntityKeyResponseData) GetExtraProperties() map[string]interface{} {
	return e.extraProperties
}

func (e *EntityKeyResponseData) UnmarshalJSON(data []byte) error {
	type embed EntityKeyResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*e),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*e = EntityKeyResponseData(unmarshaler.embed)
	e.CreatedAt = unmarshaler.CreatedAt.Time()
	e.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *e)
	if err != nil {
		return err
	}
	e.extraProperties = extraProperties
	e.rawJSON = json.RawMessage(data)
	return nil
}

func (e *EntityKeyResponseData) MarshalJSON() ([]byte, error) {
	type embed EntityKeyResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*e),
		CreatedAt: internal.NewDateTime(e.CreatedAt),
		UpdatedAt: internal.NewDateTime(e.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type EntityTraitDefinitionResponseData struct {
	CreatedAt   time.Time `json:"created_at" url:"created_at"`
	DisplayName string    `json:"display_name" url:"display_name"`
	EntityType  string    `json:"entity_type" url:"entity_type"`
	Hierarchy   []string  `json:"hierarchy,omitempty" url:"hierarchy,omitempty"`
	ID          string    `json:"id" url:"id"`
	TraitType   string    `json:"trait_type" url:"trait_type"`
	UpdatedAt   time.Time `json:"updated_at" url:"updated_at"`

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

func (e *EntityTraitDefinitionResponseData) GetCreatedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.CreatedAt
}

func (e *EntityTraitDefinitionResponseData) GetDisplayName() string {
	if e == nil {
		return ""
	}
	return e.DisplayName
}

func (e *EntityTraitDefinitionResponseData) GetEntityType() string {
	if e == nil {
		return ""
	}
	return e.EntityType
}

func (e *EntityTraitDefinitionResponseData) GetHierarchy() []string {
	if e == nil {
		return nil
	}
	return e.Hierarchy
}

func (e *EntityTraitDefinitionResponseData) GetID() string {
	if e == nil {
		return ""
	}
	return e.ID
}

func (e *EntityTraitDefinitionResponseData) GetTraitType() string {
	if e == nil {
		return ""
	}
	return e.TraitType
}

func (e *EntityTraitDefinitionResponseData) GetUpdatedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.UpdatedAt
}

func (e *EntityTraitDefinitionResponseData) GetExtraProperties() map[string]interface{} {
	return e.extraProperties
}

func (e *EntityTraitDefinitionResponseData) UnmarshalJSON(data []byte) error {
	type embed EntityTraitDefinitionResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*e),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*e = EntityTraitDefinitionResponseData(unmarshaler.embed)
	e.CreatedAt = unmarshaler.CreatedAt.Time()
	e.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *e)
	if err != nil {
		return err
	}
	e.extraProperties = extraProperties
	e.rawJSON = json.RawMessage(data)
	return nil
}

func (e *EntityTraitDefinitionResponseData) MarshalJSON() ([]byte, error) {
	type embed EntityTraitDefinitionResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*e),
		CreatedAt: internal.NewDateTime(e.CreatedAt),
		UpdatedAt: internal.NewDateTime(e.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type EntityTraitDetailResponseData struct {
	CreatedAt     time.Time                          `json:"created_at" url:"created_at"`
	Definition    *EntityTraitDefinitionResponseData `json:"definition,omitempty" url:"definition,omitempty"`
	DefinitionID  string                             `json:"definition_id" url:"definition_id"`
	EnvironmentID string                             `json:"environment_id" url:"environment_id"`
	ID            string                             `json:"id" url:"id"`
	UpdatedAt     time.Time                          `json:"updated_at" url:"updated_at"`
	Value         string                             `json:"value" url:"value"`

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

func (e *EntityTraitDetailResponseData) GetCreatedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.CreatedAt
}

func (e *EntityTraitDetailResponseData) GetDefinition() *EntityTraitDefinitionResponseData {
	if e == nil {
		return nil
	}
	return e.Definition
}

func (e *EntityTraitDetailResponseData) GetDefinitionID() string {
	if e == nil {
		return ""
	}
	return e.DefinitionID
}

func (e *EntityTraitDetailResponseData) GetEnvironmentID() string {
	if e == nil {
		return ""
	}
	return e.EnvironmentID
}

func (e *EntityTraitDetailResponseData) GetID() string {
	if e == nil {
		return ""
	}
	return e.ID
}

func (e *EntityTraitDetailResponseData) GetUpdatedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.UpdatedAt
}

func (e *EntityTraitDetailResponseData) GetValue() string {
	if e == nil {
		return ""
	}
	return e.Value
}

func (e *EntityTraitDetailResponseData) GetExtraProperties() map[string]interface{} {
	return e.extraProperties
}

func (e *EntityTraitDetailResponseData) UnmarshalJSON(data []byte) error {
	type embed EntityTraitDetailResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*e),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*e = EntityTraitDetailResponseData(unmarshaler.embed)
	e.CreatedAt = unmarshaler.CreatedAt.Time()
	e.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *e)
	if err != nil {
		return err
	}
	e.extraProperties = extraProperties
	e.rawJSON = json.RawMessage(data)
	return nil
}

func (e *EntityTraitDetailResponseData) MarshalJSON() ([]byte, error) {
	type embed EntityTraitDetailResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*e),
		CreatedAt: internal.NewDateTime(e.CreatedAt),
		UpdatedAt: internal.NewDateTime(e.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type EntityTraitResponseData struct {
	CreatedAt     time.Time `json:"created_at" url:"created_at"`
	DefinitionID  string    `json:"definition_id" url:"definition_id"`
	EnvironmentID string    `json:"environment_id" url:"environment_id"`
	ID            string    `json:"id" url:"id"`
	UpdatedAt     time.Time `json:"updated_at" url:"updated_at"`
	Value         string    `json:"value" url:"value"`

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

func (e *EntityTraitResponseData) GetCreatedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.CreatedAt
}

func (e *EntityTraitResponseData) GetDefinitionID() string {
	if e == nil {
		return ""
	}
	return e.DefinitionID
}

func (e *EntityTraitResponseData) GetEnvironmentID() string {
	if e == nil {
		return ""
	}
	return e.EnvironmentID
}

func (e *EntityTraitResponseData) GetID() string {
	if e == nil {
		return ""
	}
	return e.ID
}

func (e *EntityTraitResponseData) GetUpdatedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.UpdatedAt
}

func (e *EntityTraitResponseData) GetValue() string {
	if e == nil {
		return ""
	}
	return e.Value
}

func (e *EntityTraitResponseData) GetExtraProperties() map[string]interface{} {
	return e.extraProperties
}

func (e *EntityTraitResponseData) UnmarshalJSON(data []byte) error {
	type embed EntityTraitResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*e),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*e = EntityTraitResponseData(unmarshaler.embed)
	e.CreatedAt = unmarshaler.CreatedAt.Time()
	e.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *e)
	if err != nil {
		return err
	}
	e.extraProperties = extraProperties
	e.rawJSON = json.RawMessage(data)
	return nil
}

func (e *EntityTraitResponseData) MarshalJSON() ([]byte, error) {
	type embed EntityTraitResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*e),
		CreatedAt: internal.NewDateTime(e.CreatedAt),
		UpdatedAt: internal.NewDateTime(e.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type EventResponseData struct {
	APIKey        *string                `json:"api_key,omitempty" url:"api_key,omitempty"`
	Body          map[string]interface{} `json:"body,omitempty" url:"body,omitempty"`
	BodyPreview   string                 `json:"body_preview" url:"body_preview"`
	CapturedAt    time.Time              `json:"captured_at" url:"captured_at"`
	CompanyID     *string                `json:"company_id,omitempty" url:"company_id,omitempty"`
	EnrichedAt    *time.Time             `json:"enriched_at,omitempty" url:"enriched_at,omitempty"`
	EnvironmentID *string                `json:"environment_id,omitempty" url:"environment_id,omitempty"`
	ErrorMessage  *string                `json:"error_message,omitempty" url:"error_message,omitempty"`
	FeatureIDs    []string               `json:"feature_ids,omitempty" url:"feature_ids,omitempty"`
	ID            string                 `json:"id" url:"id"`
	LoadedAt      *time.Time             `json:"loaded_at,omitempty" url:"loaded_at,omitempty"`
	ProcessedAt   *time.Time             `json:"processed_at,omitempty" url:"processed_at,omitempty"`
	SentAt        *time.Time             `json:"sent_at,omitempty" url:"sent_at,omitempty"`
	Status        string                 `json:"status" url:"status"`
	Subtype       *string                `json:"subtype,omitempty" url:"subtype,omitempty"`
	Type          string                 `json:"type" url:"type"`
	UpdatedAt     time.Time              `json:"updated_at" url:"updated_at"`
	UserID        *string                `json:"user_id,omitempty" url:"user_id,omitempty"`

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

func (e *EventResponseData) GetAPIKey() *string {
	if e == nil {
		return nil
	}
	return e.APIKey
}

func (e *EventResponseData) GetBody() map[string]interface{} {
	if e == nil {
		return nil
	}
	return e.Body
}

func (e *EventResponseData) GetBodyPreview() string {
	if e == nil {
		return ""
	}
	return e.BodyPreview
}

func (e *EventResponseData) GetCapturedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.CapturedAt
}

func (e *EventResponseData) GetCompanyID() *string {
	if e == nil {
		return nil
	}
	return e.CompanyID
}

func (e *EventResponseData) GetEnrichedAt() *time.Time {
	if e == nil {
		return nil
	}
	return e.EnrichedAt
}

func (e *EventResponseData) GetEnvironmentID() *string {
	if e == nil {
		return nil
	}
	return e.EnvironmentID
}

func (e *EventResponseData) GetErrorMessage() *string {
	if e == nil {
		return nil
	}
	return e.ErrorMessage
}

func (e *EventResponseData) GetFeatureIDs() []string {
	if e == nil {
		return nil
	}
	return e.FeatureIDs
}

func (e *EventResponseData) GetID() string {
	if e == nil {
		return ""
	}
	return e.ID
}

func (e *EventResponseData) GetLoadedAt() *time.Time {
	if e == nil {
		return nil
	}
	return e.LoadedAt
}

func (e *EventResponseData) GetProcessedAt() *time.Time {
	if e == nil {
		return nil
	}
	return e.ProcessedAt
}

func (e *EventResponseData) GetSentAt() *time.Time {
	if e == nil {
		return nil
	}
	return e.SentAt
}

func (e *EventResponseData) GetStatus() string {
	if e == nil {
		return ""
	}
	return e.Status
}

func (e *EventResponseData) GetSubtype() *string {
	if e == nil {
		return nil
	}
	return e.Subtype
}

func (e *EventResponseData) GetType() string {
	if e == nil {
		return ""
	}
	return e.Type
}

func (e *EventResponseData) GetUpdatedAt() time.Time {
	if e == nil {
		return time.Time{}
	}
	return e.UpdatedAt
}

func (e *EventResponseData) GetUserID() *string {
	if e == nil {
		return nil
	}
	return e.UserID
}

func (e *EventResponseData) GetExtraProperties() map[string]interface{} {
	return e.extraProperties
}

func (e *EventResponseData) UnmarshalJSON(data []byte) error {
	type embed EventResponseData
	var unmarshaler = struct {
		embed
		CapturedAt  *internal.DateTime `json:"captured_at"`
		EnrichedAt  *internal.DateTime `json:"enriched_at,omitempty"`
		LoadedAt    *internal.DateTime `json:"loaded_at,omitempty"`
		ProcessedAt *internal.DateTime `json:"processed_at,omitempty"`
		SentAt      *internal.DateTime `json:"sent_at,omitempty"`
		UpdatedAt   *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*e),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*e = EventResponseData(unmarshaler.embed)
	e.CapturedAt = unmarshaler.CapturedAt.Time()
	e.EnrichedAt = unmarshaler.EnrichedAt.TimePtr()
	e.LoadedAt = unmarshaler.LoadedAt.TimePtr()
	e.ProcessedAt = unmarshaler.ProcessedAt.TimePtr()
	e.SentAt = unmarshaler.SentAt.TimePtr()
	e.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *e)
	if err != nil {
		return err
	}
	e.extraProperties = extraProperties
	e.rawJSON = json.RawMessage(data)
	return nil
}

func (e *EventResponseData) MarshalJSON() ([]byte, error) {
	type embed EventResponseData
	var marshaler = struct {
		embed
		CapturedAt  *internal.DateTime `json:"captured_at"`
		EnrichedAt  *internal.DateTime `json:"enriched_at,omitempty"`
		LoadedAt    *internal.DateTime `json:"loaded_at,omitempty"`
		ProcessedAt *internal.DateTime `json:"processed_at,omitempty"`
		SentAt      *internal.DateTime `json:"sent_at,omitempty"`
		UpdatedAt   *internal.DateTime `json:"updated_at"`
	}{
		embed:       embed(*e),
		CapturedAt:  internal.NewDateTime(e.CapturedAt),
		EnrichedAt:  internal.NewOptionalDateTime(e.EnrichedAt),
		LoadedAt:    internal.NewOptionalDateTime(e.LoadedAt),
		ProcessedAt: internal.NewOptionalDateTime(e.ProcessedAt),
		SentAt:      internal.NewOptionalDateTime(e.SentAt),
		UpdatedAt:   internal.NewDateTime(e.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type EventSummaryResponseData struct {
	CompanyCount  int        `json:"company_count" url:"company_count"`
	EnvironmentID string     `json:"environment_id" url:"environment_id"`
	EventCount    int        `json:"event_count" url:"event_count"`
	EventSubtype  string     `json:"event_subtype" url:"event_subtype"`
	LastSeenAt    *time.Time `json:"last_seen_at,omitempty" url:"last_seen_at,omitempty"`
	UserCount     int        `json:"user_count" url:"user_count"`

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

func (e *EventSummaryResponseData) GetCompanyCount() int {
	if e == nil {
		return 0
	}
	return e.CompanyCount
}

func (e *EventSummaryResponseData) GetEnvironmentID() string {
	if e == nil {
		return ""
	}
	return e.EnvironmentID
}

func (e *EventSummaryResponseData) GetEventCount() int {
	if e == nil {
		return 0
	}
	return e.EventCount
}

func (e *EventSummaryResponseData) GetEventSubtype() string {
	if e == nil {
		return ""
	}
	return e.EventSubtype
}

func (e *EventSummaryResponseData) GetLastSeenAt() *time.Time {
	if e == nil {
		return nil
	}
	return e.LastSeenAt
}

func (e *EventSummaryResponseData) GetUserCount() int {
	if e == nil {
		return 0
	}
	return e.UserCount
}

func (e *EventSummaryResponseData) GetExtraProperties() map[string]interface{} {
	return e.extraProperties
}

func (e *EventSummaryResponseData) UnmarshalJSON(data []byte) error {
	type embed EventSummaryResponseData
	var unmarshaler = struct {
		embed
		LastSeenAt *internal.DateTime `json:"last_seen_at,omitempty"`
	}{
		embed: embed(*e),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*e = EventSummaryResponseData(unmarshaler.embed)
	e.LastSeenAt = unmarshaler.LastSeenAt.TimePtr()
	extraProperties, err := internal.ExtractExtraProperties(data, *e)
	if err != nil {
		return err
	}
	e.extraProperties = extraProperties
	e.rawJSON = json.RawMessage(data)
	return nil
}

func (e *EventSummaryResponseData) MarshalJSON() ([]byte, error) {
	type embed EventSummaryResponseData
	var marshaler = struct {
		embed
		LastSeenAt *internal.DateTime `json:"last_seen_at,omitempty"`
	}{
		embed:      embed(*e),
		LastSeenAt: internal.NewOptionalDateTime(e.LastSeenAt),
	}
	return json.Marshal(marshaler)
}

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

type FeatureDetailResponseData struct {
	CreatedAt      time.Time                          `json:"created_at" url:"created_at"`
	Description    string                             `json:"description" url:"description"`
	EventSubtype   *string                            `json:"event_subtype,omitempty" url:"event_subtype,omitempty"`
	EventSummary   *EventSummaryResponseData          `json:"event_summary,omitempty" url:"event_summary,omitempty"`
	FeatureType    string                             `json:"feature_type" url:"feature_type"`
	Flags          []*FlagDetailResponseData          `json:"flags,omitempty" url:"flags,omitempty"`
	Icon           string                             `json:"icon" url:"icon"`
	ID             string                             `json:"id" url:"id"`
	LifecyclePhase *string                            `json:"lifecycle_phase,omitempty" url:"lifecycle_phase,omitempty"`
	MaintainerID   *string                            `json:"maintainer_id,omitempty" url:"maintainer_id,omitempty"`
	Name           string                             `json:"name" url:"name"`
	Plans          []*PreviewObject                   `json:"plans,omitempty" url:"plans,omitempty"`
	Trait          *EntityTraitDefinitionResponseData `json:"trait,omitempty" url:"trait,omitempty"`
	TraitID        *string                            `json:"trait_id,omitempty" url:"trait_id,omitempty"`
	UpdatedAt      time.Time                          `json:"updated_at" url:"updated_at"`

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

func (f *FeatureDetailResponseData) GetCreatedAt() time.Time {
	if f == nil {
		return time.Time{}
	}
	return f.CreatedAt
}

func (f *FeatureDetailResponseData) GetDescription() string {
	if f == nil {
		return ""
	}
	return f.Description
}

func (f *FeatureDetailResponseData) GetEventSubtype() *string {
	if f == nil {
		return nil
	}
	return f.EventSubtype
}

func (f *FeatureDetailResponseData) GetEventSummary() *EventSummaryResponseData {
	if f == nil {
		return nil
	}
	return f.EventSummary
}

func (f *FeatureDetailResponseData) GetFeatureType() string {
	if f == nil {
		return ""
	}
	return f.FeatureType
}

func (f *FeatureDetailResponseData) GetFlags() []*FlagDetailResponseData {
	if f == nil {
		return nil
	}
	return f.Flags
}

func (f *FeatureDetailResponseData) GetIcon() string {
	if f == nil {
		return ""
	}
	return f.Icon
}

func (f *FeatureDetailResponseData) GetID() string {
	if f == nil {
		return ""
	}
	return f.ID
}

func (f *FeatureDetailResponseData) GetLifecyclePhase() *string {
	if f == nil {
		return nil
	}
	return f.LifecyclePhase
}

func (f *FeatureDetailResponseData) GetMaintainerID() *string {
	if f == nil {
		return nil
	}
	return f.MaintainerID
}

func (f *FeatureDetailResponseData) GetName() string {
	if f == nil {
		return ""
	}
	return f.Name
}

func (f *FeatureDetailResponseData) GetPlans() []*PreviewObject {
	if f == nil {
		return nil
	}
	return f.Plans
}

func (f *FeatureDetailResponseData) GetTrait() *EntityTraitDefinitionResponseData {
	if f == nil {
		return nil
	}
	return f.Trait
}

func (f *FeatureDetailResponseData) GetTraitID() *string {
	if f == nil {
		return nil
	}
	return f.TraitID
}

func (f *FeatureDetailResponseData) GetUpdatedAt() time.Time {
	if f == nil {
		return time.Time{}
	}
	return f.UpdatedAt
}

func (f *FeatureDetailResponseData) GetExtraProperties() map[string]interface{} {
	return f.extraProperties
}

func (f *FeatureDetailResponseData) UnmarshalJSON(data []byte) error {
	type embed FeatureDetailResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*f),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*f = FeatureDetailResponseData(unmarshaler.embed)
	f.CreatedAt = unmarshaler.CreatedAt.Time()
	f.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *f)
	if err != nil {
		return err
	}
	f.extraProperties = extraProperties
	f.rawJSON = json.RawMessage(data)
	return nil
}

func (f *FeatureDetailResponseData) MarshalJSON() ([]byte, error) {
	type embed FeatureDetailResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*f),
		CreatedAt: internal.NewDateTime(f.CreatedAt),
		UpdatedAt: internal.NewDateTime(f.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type FeatureResponseData struct {
	CreatedAt      time.Time `json:"created_at" url:"created_at"`
	Description    string    `json:"description" url:"description"`
	EventSubtype   *string   `json:"event_subtype,omitempty" url:"event_subtype,omitempty"`
	FeatureType    string    `json:"feature_type" url:"feature_type"`
	Icon           string    `json:"icon" url:"icon"`
	ID             string    `json:"id" url:"id"`
	LifecyclePhase *string   `json:"lifecycle_phase,omitempty" url:"lifecycle_phase,omitempty"`
	MaintainerID   *string   `json:"maintainer_id,omitempty" url:"maintainer_id,omitempty"`
	Name           string    `json:"name" url:"name"`
	TraitID        *string   `json:"trait_id,omitempty" url:"trait_id,omitempty"`
	UpdatedAt      time.Time `json:"updated_at" url:"updated_at"`

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

func (f *FeatureResponseData) GetCreatedAt() time.Time {
	if f == nil {
		return time.Time{}
	}
	return f.CreatedAt
}

func (f *FeatureResponseData) GetDescription() string {
	if f == nil {
		return ""
	}
	return f.Description
}

func (f *FeatureResponseData) GetEventSubtype() *string {
	if f == nil {
		return nil
	}
	return f.EventSubtype
}

func (f *FeatureResponseData) GetFeatureType() string {
	if f == nil {
		return ""
	}
	return f.FeatureType
}

func (f *FeatureResponseData) GetIcon() string {
	if f == nil {
		return ""
	}
	return f.Icon
}

func (f *FeatureResponseData) GetID() string {
	if f == nil {
		return ""
	}
	return f.ID
}

func (f *FeatureResponseData) GetLifecyclePhase() *string {
	if f == nil {
		return nil
	}
	return f.LifecyclePhase
}

func (f *FeatureResponseData) GetMaintainerID() *string {
	if f == nil {
		return nil
	}
	return f.MaintainerID
}

func (f *FeatureResponseData) GetName() string {
	if f == nil {
		return ""
	}
	return f.Name
}

func (f *FeatureResponseData) GetTraitID() *string {
	if f == nil {
		return nil
	}
	return f.TraitID
}

func (f *FeatureResponseData) GetUpdatedAt() time.Time {
	if f == nil {
		return time.Time{}
	}
	return f.UpdatedAt
}

func (f *FeatureResponseData) GetExtraProperties() map[string]interface{} {
	return f.extraProperties
}

func (f *FeatureResponseData) UnmarshalJSON(data []byte) error {
	type embed FeatureResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*f),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*f = FeatureResponseData(unmarshaler.embed)
	f.CreatedAt = unmarshaler.CreatedAt.Time()
	f.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *f)
	if err != nil {
		return err
	}
	f.extraProperties = extraProperties
	f.rawJSON = json.RawMessage(data)
	return nil
}

func (f *FeatureResponseData) MarshalJSON() ([]byte, error) {
	type embed FeatureResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*f),
		CreatedAt: internal.NewDateTime(f.CreatedAt),
		UpdatedAt: internal.NewDateTime(f.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type FeatureUsageDetailResponseData struct {
	Features []*FeatureUsageResponseData `json:"features,omitempty" url:"features,omitempty"`

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

func (f *FeatureUsageDetailResponseData) GetFeatures() []*FeatureUsageResponseData {
	if f == nil {
		return nil
	}
	return f.Features
}

func (f *FeatureUsageDetailResponseData) GetExtraProperties() map[string]interface{} {
	return f.extraProperties
}

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

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

type FeatureUsageResponseData struct {
	// Whether further usage is permitted.
	Access bool `json:"access" url:"access"`
	// The maximum amount of usage that is permitted; a null value indicates that unlimited usage is permitted.
	Allocation *int `json:"allocation,omitempty" url:"allocation,omitempty"`
	// The type of allocation that is being used.
	AllocationType  FeatureUsageResponseDataAllocationType `json:"allocation_type" url:"allocation_type"`
	EntitlementID   string                                 `json:"entitlement_id" url:"entitlement_id"`
	EntitlementType string                                 `json:"entitlement_type" url:"entitlement_type"`
	Feature         *FeatureDetailResponseData             `json:"feature,omitempty" url:"feature,omitempty"`
	// The time at which the metric will resets.
	MetricResetAt *time.Time `json:"metric_reset_at,omitempty" url:"metric_reset_at,omitempty"`
	// If the period is current_month, when the month resets.
	MonthReset *string `json:"month_reset,omitempty" url:"month_reset,omitempty"`
	// The period over which usage is measured.
	Period *string           `json:"period,omitempty" url:"period,omitempty"`
	Plan   *PlanResponseData `json:"plan,omitempty" url:"plan,omitempty"`
	// The amount of usage that has been consumed; a null value indicates that usage is not being measured.
	Usage *int `json:"usage,omitempty" url:"usage,omitempty"`

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

func (f *FeatureUsageResponseData) GetAccess() bool {
	if f == nil {
		return false
	}
	return f.Access
}

func (f *FeatureUsageResponseData) GetAllocation() *int {
	if f == nil {
		return nil
	}
	return f.Allocation
}

func (f *FeatureUsageResponseData) GetAllocationType() FeatureUsageResponseDataAllocationType {
	if f == nil {
		return ""
	}
	return f.AllocationType
}

func (f *FeatureUsageResponseData) GetEntitlementID() string {
	if f == nil {
		return ""
	}
	return f.EntitlementID
}

func (f *FeatureUsageResponseData) GetEntitlementType() string {
	if f == nil {
		return ""
	}
	return f.EntitlementType
}

func (f *FeatureUsageResponseData) GetFeature() *FeatureDetailResponseData {
	if f == nil {
		return nil
	}
	return f.Feature
}

func (f *FeatureUsageResponseData) GetMetricResetAt() *time.Time {
	if f == nil {
		return nil
	}
	return f.MetricResetAt
}

func (f *FeatureUsageResponseData) GetMonthReset() *string {
	if f == nil {
		return nil
	}
	return f.MonthReset
}

func (f *FeatureUsageResponseData) GetPeriod() *string {
	if f == nil {
		return nil
	}
	return f.Period
}

func (f *FeatureUsageResponseData) GetPlan() *PlanResponseData {
	if f == nil {
		return nil
	}
	return f.Plan
}

func (f *FeatureUsageResponseData) GetUsage() *int {
	if f == nil {
		return nil
	}
	return f.Usage
}

func (f *FeatureUsageResponseData) GetExtraProperties() map[string]interface{} {
	return f.extraProperties
}

func (f *FeatureUsageResponseData) UnmarshalJSON(data []byte) error {
	type embed FeatureUsageResponseData
	var unmarshaler = struct {
		embed
		MetricResetAt *internal.DateTime `json:"metric_reset_at,omitempty"`
	}{
		embed: embed(*f),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*f = FeatureUsageResponseData(unmarshaler.embed)
	f.MetricResetAt = unmarshaler.MetricResetAt.TimePtr()
	extraProperties, err := internal.ExtractExtraProperties(data, *f)
	if err != nil {
		return err
	}
	f.extraProperties = extraProperties
	f.rawJSON = json.RawMessage(data)
	return nil
}

func (f *FeatureUsageResponseData) MarshalJSON() ([]byte, error) {
	type embed FeatureUsageResponseData
	var marshaler = struct {
		embed
		MetricResetAt *internal.DateTime `json:"metric_reset_at,omitempty"`
	}{
		embed:         embed(*f),
		MetricResetAt: internal.NewOptionalDateTime(f.MetricResetAt),
	}
	return json.Marshal(marshaler)
}

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

// The type of allocation that is being used.
type FeatureUsageResponseDataAllocationType string

const (
	FeatureUsageResponseDataAllocationTypeBoolean   FeatureUsageResponseDataAllocationType = "boolean"
	FeatureUsageResponseDataAllocationTypeNumeric   FeatureUsageResponseDataAllocationType = "numeric"
	FeatureUsageResponseDataAllocationTypeTrait     FeatureUsageResponseDataAllocationType = "trait"
	FeatureUsageResponseDataAllocationTypeUnlimited FeatureUsageResponseDataAllocationType = "unlimited"
)

func NewFeatureUsageResponseDataAllocationTypeFromString(s string) (FeatureUsageResponseDataAllocationType, error) {
	switch s {
	case "boolean":
		return FeatureUsageResponseDataAllocationTypeBoolean, nil
	case "numeric":
		return FeatureUsageResponseDataAllocationTypeNumeric, nil
	case "trait":
		return FeatureUsageResponseDataAllocationTypeTrait, nil
	case "unlimited":
		return FeatureUsageResponseDataAllocationTypeUnlimited, nil
	}
	var t FeatureUsageResponseDataAllocationType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (f FeatureUsageResponseDataAllocationType) Ptr() *FeatureUsageResponseDataAllocationType {
	return &f
}

type FlagDetailResponseData struct {
	CreatedAt     time.Time                 `json:"created_at" url:"created_at"`
	DefaultValue  bool                      `json:"default_value" url:"default_value"`
	Description   string                    `json:"description" url:"description"`
	Feature       *FeatureResponseData      `json:"feature,omitempty" url:"feature,omitempty"`
	FeatureID     *string                   `json:"feature_id,omitempty" url:"feature_id,omitempty"`
	FlagType      string                    `json:"flag_type" url:"flag_type"`
	ID            string                    `json:"id" url:"id"`
	Key           string                    `json:"key" url:"key"`
	LastCheckedAt *time.Time                `json:"last_checked_at,omitempty" url:"last_checked_at,omitempty"`
	MaintainerID  *string                   `json:"maintainer_id,omitempty" url:"maintainer_id,omitempty"`
	Name          string                    `json:"name" url:"name"`
	Rules         []*RuleDetailResponseData `json:"rules,omitempty" url:"rules,omitempty"`
	UpdatedAt     time.Time                 `json:"updated_at" url:"updated_at"`

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

func (f *FlagDetailResponseData) GetCreatedAt() time.Time {
	if f == nil {
		return time.Time{}
	}
	return f.CreatedAt
}

func (f *FlagDetailResponseData) GetDefaultValue() bool {
	if f == nil {
		return false
	}
	return f.DefaultValue
}

func (f *FlagDetailResponseData) GetDescription() string {
	if f == nil {
		return ""
	}
	return f.Description
}

func (f *FlagDetailResponseData) GetFeature() *FeatureResponseData {
	if f == nil {
		return nil
	}
	return f.Feature
}

func (f *FlagDetailResponseData) GetFeatureID() *string {
	if f == nil {
		return nil
	}
	return f.FeatureID
}

func (f *FlagDetailResponseData) GetFlagType() string {
	if f == nil {
		return ""
	}
	return f.FlagType
}

func (f *FlagDetailResponseData) GetID() string {
	if f == nil {
		return ""
	}
	return f.ID
}

func (f *FlagDetailResponseData) GetKey() string {
	if f == nil {
		return ""
	}
	return f.Key
}

func (f *FlagDetailResponseData) GetLastCheckedAt() *time.Time {
	if f == nil {
		return nil
	}
	return f.LastCheckedAt
}

func (f *FlagDetailResponseData) GetMaintainerID() *string {
	if f == nil {
		return nil
	}
	return f.MaintainerID
}

func (f *FlagDetailResponseData) GetName() string {
	if f == nil {
		return ""
	}
	return f.Name
}

func (f *FlagDetailResponseData) GetRules() []*RuleDetailResponseData {
	if f == nil {
		return nil
	}
	return f.Rules
}

func (f *FlagDetailResponseData) GetUpdatedAt() time.Time {
	if f == nil {
		return time.Time{}
	}
	return f.UpdatedAt
}

func (f *FlagDetailResponseData) GetExtraProperties() map[string]interface{} {
	return f.extraProperties
}

func (f *FlagDetailResponseData) UnmarshalJSON(data []byte) error {
	type embed FlagDetailResponseData
	var unmarshaler = struct {
		embed
		CreatedAt     *internal.DateTime `json:"created_at"`
		LastCheckedAt *internal.DateTime `json:"last_checked_at,omitempty"`
		UpdatedAt     *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*f),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*f = FlagDetailResponseData(unmarshaler.embed)
	f.CreatedAt = unmarshaler.CreatedAt.Time()
	f.LastCheckedAt = unmarshaler.LastCheckedAt.TimePtr()
	f.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *f)
	if err != nil {
		return err
	}
	f.extraProperties = extraProperties
	f.rawJSON = json.RawMessage(data)
	return nil
}

func (f *FlagDetailResponseData) MarshalJSON() ([]byte, error) {
	type embed FlagDetailResponseData
	var marshaler = struct {
		embed
		CreatedAt     *internal.DateTime `json:"created_at"`
		LastCheckedAt *internal.DateTime `json:"last_checked_at,omitempty"`
		UpdatedAt     *internal.DateTime `json:"updated_at"`
	}{
		embed:         embed(*f),
		CreatedAt:     internal.NewDateTime(f.CreatedAt),
		LastCheckedAt: internal.NewOptionalDateTime(f.LastCheckedAt),
		UpdatedAt:     internal.NewDateTime(f.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type GenericPreviewObject struct {
	Description *string `json:"description,omitempty" url:"description,omitempty"`
	ID          string  `json:"id" url:"id"`
	ImageURL    *string `json:"image_url,omitempty" url:"image_url,omitempty"`
	Name        string  `json:"name" url:"name"`

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

func (g *GenericPreviewObject) GetDescription() *string {
	if g == nil {
		return nil
	}
	return g.Description
}

func (g *GenericPreviewObject) GetID() string {
	if g == nil {
		return ""
	}
	return g.ID
}

func (g *GenericPreviewObject) GetImageURL() *string {
	if g == nil {
		return nil
	}
	return g.ImageURL
}

func (g *GenericPreviewObject) GetName() string {
	if g == nil {
		return ""
	}
	return g.Name
}

func (g *GenericPreviewObject) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

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

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

type InvoiceRequestBody struct {
	AmountDue               int        `json:"amount_due" url:"amount_due"`
	AmountPaid              int        `json:"amount_paid" url:"amount_paid"`
	AmountRemaining         int        `json:"amount_remaining" url:"amount_remaining"`
	CollectionMethod        string     `json:"collection_method" url:"collection_method"`
	Currency                string     `json:"currency" url:"currency"`
	CustomerExternalID      string     `json:"customer_external_id" url:"customer_external_id"`
	DueDate                 *time.Time `json:"due_date,omitempty" url:"due_date,omitempty"`
	PaymentMethodExternalID *string    `json:"payment_method_external_id,omitempty" url:"payment_method_external_id,omitempty"`
	SubscriptionExternalID  *string    `json:"subscription_external_id,omitempty" url:"subscription_external_id,omitempty"`
	Subtotal                int        `json:"subtotal" url:"subtotal"`
	URL                     *string    `json:"url,omitempty" url:"url,omitempty"`

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

func (i *InvoiceRequestBody) GetAmountDue() int {
	if i == nil {
		return 0
	}
	return i.AmountDue
}

func (i *InvoiceRequestBody) GetAmountPaid() int {
	if i == nil {
		return 0
	}
	return i.AmountPaid
}

func (i *InvoiceRequestBody) GetAmountRemaining() int {
	if i == nil {
		return 0
	}
	return i.AmountRemaining
}

func (i *InvoiceRequestBody) GetCollectionMethod() string {
	if i == nil {
		return ""
	}
	return i.CollectionMethod
}

func (i *InvoiceRequestBody) GetCurrency() string {
	if i == nil {
		return ""
	}
	return i.Currency
}

func (i *InvoiceRequestBody) GetCustomerExternalID() string {
	if i == nil {
		return ""
	}
	return i.CustomerExternalID
}

func (i *InvoiceRequestBody) GetDueDate() *time.Time {
	if i == nil {
		return nil
	}
	return i.DueDate
}

func (i *InvoiceRequestBody) GetPaymentMethodExternalID() *string {
	if i == nil {
		return nil
	}
	return i.PaymentMethodExternalID
}

func (i *InvoiceRequestBody) GetSubscriptionExternalID() *string {
	if i == nil {
		return nil
	}
	return i.SubscriptionExternalID
}

func (i *InvoiceRequestBody) GetSubtotal() int {
	if i == nil {
		return 0
	}
	return i.Subtotal
}

func (i *InvoiceRequestBody) GetURL() *string {
	if i == nil {
		return nil
	}
	return i.URL
}

func (i *InvoiceRequestBody) GetExtraProperties() map[string]interface{} {
	return i.extraProperties
}

func (i *InvoiceRequestBody) UnmarshalJSON(data []byte) error {
	type embed InvoiceRequestBody
	var unmarshaler = struct {
		embed
		DueDate *internal.DateTime `json:"due_date,omitempty"`
	}{
		embed: embed(*i),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*i = InvoiceRequestBody(unmarshaler.embed)
	i.DueDate = unmarshaler.DueDate.TimePtr()
	extraProperties, err := internal.ExtractExtraProperties(data, *i)
	if err != nil {
		return err
	}
	i.extraProperties = extraProperties
	i.rawJSON = json.RawMessage(data)
	return nil
}

func (i *InvoiceRequestBody) MarshalJSON() ([]byte, error) {
	type embed InvoiceRequestBody
	var marshaler = struct {
		embed
		DueDate *internal.DateTime `json:"due_date,omitempty"`
	}{
		embed:   embed(*i),
		DueDate: internal.NewOptionalDateTime(i.DueDate),
	}
	return json.Marshal(marshaler)
}

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

type InvoiceResponseData struct {
	AmountDue               int        `json:"amount_due" url:"amount_due"`
	AmountPaid              int        `json:"amount_paid" url:"amount_paid"`
	AmountRemaining         int        `json:"amount_remaining" url:"amount_remaining"`
	CollectionMethod        string     `json:"collection_method" url:"collection_method"`
	CompanyID               *string    `json:"company_id,omitempty" url:"company_id,omitempty"`
	CreatedAt               time.Time  `json:"created_at" url:"created_at"`
	Currency                string     `json:"currency" url:"currency"`
	CustomerExternalID      string     `json:"customer_external_id" url:"customer_external_id"`
	DueDate                 *time.Time `json:"due_date,omitempty" url:"due_date,omitempty"`
	EnvironmentID           string     `json:"environment_id" url:"environment_id"`
	ExternalID              *string    `json:"external_id,omitempty" url:"external_id,omitempty"`
	ID                      string     `json:"id" url:"id"`
	PaymentMethodExternalID *string    `json:"payment_method_external_id,omitempty" url:"payment_method_external_id,omitempty"`
	SubscriptionExternalID  *string    `json:"subscription_external_id,omitempty" url:"subscription_external_id,omitempty"`
	Subtotal                int        `json:"subtotal" url:"subtotal"`
	UpdatedAt               time.Time  `json:"updated_at" url:"updated_at"`
	URL                     *string    `json:"url,omitempty" url:"url,omitempty"`

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

func (i *InvoiceResponseData) GetAmountDue() int {
	if i == nil {
		return 0
	}
	return i.AmountDue
}

func (i *InvoiceResponseData) GetAmountPaid() int {
	if i == nil {
		return 0
	}
	return i.AmountPaid
}

func (i *InvoiceResponseData) GetAmountRemaining() int {
	if i == nil {
		return 0
	}
	return i.AmountRemaining
}

func (i *InvoiceResponseData) GetCollectionMethod() string {
	if i == nil {
		return ""
	}
	return i.CollectionMethod
}

func (i *InvoiceResponseData) GetCompanyID() *string {
	if i == nil {
		return nil
	}
	return i.CompanyID
}

func (i *InvoiceResponseData) GetCreatedAt() time.Time {
	if i == nil {
		return time.Time{}
	}
	return i.CreatedAt
}

func (i *InvoiceResponseData) GetCurrency() string {
	if i == nil {
		return ""
	}
	return i.Currency
}

func (i *InvoiceResponseData) GetCustomerExternalID() string {
	if i == nil {
		return ""
	}
	return i.CustomerExternalID
}

func (i *InvoiceResponseData) GetDueDate() *time.Time {
	if i == nil {
		return nil
	}
	return i.DueDate
}

func (i *InvoiceResponseData) GetEnvironmentID() string {
	if i == nil {
		return ""
	}
	return i.EnvironmentID
}

func (i *InvoiceResponseData) GetExternalID() *string {
	if i == nil {
		return nil
	}
	return i.ExternalID
}

func (i *InvoiceResponseData) GetID() string {
	if i == nil {
		return ""
	}
	return i.ID
}

func (i *InvoiceResponseData) GetPaymentMethodExternalID() *string {
	if i == nil {
		return nil
	}
	return i.PaymentMethodExternalID
}

func (i *InvoiceResponseData) GetSubscriptionExternalID() *string {
	if i == nil {
		return nil
	}
	return i.SubscriptionExternalID
}

func (i *InvoiceResponseData) GetSubtotal() int {
	if i == nil {
		return 0
	}
	return i.Subtotal
}

func (i *InvoiceResponseData) GetUpdatedAt() time.Time {
	if i == nil {
		return time.Time{}
	}
	return i.UpdatedAt
}

func (i *InvoiceResponseData) GetURL() *string {
	if i == nil {
		return nil
	}
	return i.URL
}

func (i *InvoiceResponseData) GetExtraProperties() map[string]interface{} {
	return i.extraProperties
}

func (i *InvoiceResponseData) UnmarshalJSON(data []byte) error {
	type embed InvoiceResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		DueDate   *internal.DateTime `json:"due_date,omitempty"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*i),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*i = InvoiceResponseData(unmarshaler.embed)
	i.CreatedAt = unmarshaler.CreatedAt.Time()
	i.DueDate = unmarshaler.DueDate.TimePtr()
	i.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *i)
	if err != nil {
		return err
	}
	i.extraProperties = extraProperties
	i.rawJSON = json.RawMessage(data)
	return nil
}

func (i *InvoiceResponseData) MarshalJSON() ([]byte, error) {
	type embed InvoiceResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		DueDate   *internal.DateTime `json:"due_date,omitempty"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*i),
		CreatedAt: internal.NewDateTime(i.CreatedAt),
		DueDate:   internal.NewOptionalDateTime(i.DueDate),
		UpdatedAt: internal.NewDateTime(i.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type MeterRequestBody struct {
	DisplayName     string `json:"display_name" url:"display_name"`
	EventName       string `json:"event_name" url:"event_name"`
	EventPayloadKey string `json:"event_payload_key" url:"event_payload_key"`

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

func (m *MeterRequestBody) GetDisplayName() string {
	if m == nil {
		return ""
	}
	return m.DisplayName
}

func (m *MeterRequestBody) GetEventName() string {
	if m == nil {
		return ""
	}
	return m.EventName
}

func (m *MeterRequestBody) GetEventPayloadKey() string {
	if m == nil {
		return ""
	}
	return m.EventPayloadKey
}

func (m *MeterRequestBody) GetExtraProperties() map[string]interface{} {
	return m.extraProperties
}

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

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

type PaginationFilter struct {
	// Page limit (default 100)
	Limit *int `json:"limit,omitempty" url:"limit,omitempty"`
	// Page offset (default 0)
	Offset *int `json:"offset,omitempty" url:"offset,omitempty"`

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

func (p *PaginationFilter) GetLimit() *int {
	if p == nil {
		return nil
	}
	return p.Limit
}

func (p *PaginationFilter) GetOffset() *int {
	if p == nil {
		return nil
	}
	return p.Offset
}

func (p *PaginationFilter) GetExtraProperties() map[string]interface{} {
	return p.extraProperties
}

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

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

type PaymentMethodRequestBody struct {
	AccountLast4           *string `json:"account_last4,omitempty" url:"account_last4,omitempty"`
	AccountName            *string `json:"account_name,omitempty" url:"account_name,omitempty"`
	BankName               *string `json:"bank_name,omitempty" url:"bank_name,omitempty"`
	BillingEmail           *string `json:"billing_email,omitempty" url:"billing_email,omitempty"`
	BillingName            *string `json:"billing_name,omitempty" url:"billing_name,omitempty"`
	CardBrand              *string `json:"card_brand,omitempty" url:"card_brand,omitempty"`
	CardExpMonth           *int    `json:"card_exp_month,omitempty" url:"card_exp_month,omitempty"`
	CardExpYear            *int    `json:"card_exp_year,omitempty" url:"card_exp_year,omitempty"`
	CardLast4              *string `json:"card_last4,omitempty" url:"card_last4,omitempty"`
	CustomerExternalID     string  `json:"customer_external_id" url:"customer_external_id"`
	PaymentMethodType      string  `json:"payment_method_type" url:"payment_method_type"`
	SubscriptionExternalID *string `json:"subscription_external_id,omitempty" url:"subscription_external_id,omitempty"`

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

func (p *PaymentMethodRequestBody) GetAccountLast4() *string {
	if p == nil {
		return nil
	}
	return p.AccountLast4
}

func (p *PaymentMethodRequestBody) GetAccountName() *string {
	if p == nil {
		return nil
	}
	return p.AccountName
}

func (p *PaymentMethodRequestBody) GetBankName() *string {
	if p == nil {
		return nil
	}
	return p.BankName
}

func (p *PaymentMethodRequestBody) GetBillingEmail() *string {
	if p == nil {
		return nil
	}
	return p.BillingEmail
}

func (p *PaymentMethodRequestBody) GetBillingName() *string {
	if p == nil {
		return nil
	}
	return p.BillingName
}

func (p *PaymentMethodRequestBody) GetCardBrand() *string {
	if p == nil {
		return nil
	}
	return p.CardBrand
}

func (p *PaymentMethodRequestBody) GetCardExpMonth() *int {
	if p == nil {
		return nil
	}
	return p.CardExpMonth
}

func (p *PaymentMethodRequestBody) GetCardExpYear() *int {
	if p == nil {
		return nil
	}
	return p.CardExpYear
}

func (p *PaymentMethodRequestBody) GetCardLast4() *string {
	if p == nil {
		return nil
	}
	return p.CardLast4
}

func (p *PaymentMethodRequestBody) GetCustomerExternalID() string {
	if p == nil {
		return ""
	}
	return p.CustomerExternalID
}

func (p *PaymentMethodRequestBody) GetPaymentMethodType() string {
	if p == nil {
		return ""
	}
	return p.PaymentMethodType
}

func (p *PaymentMethodRequestBody) GetSubscriptionExternalID() *string {
	if p == nil {
		return nil
	}
	return p.SubscriptionExternalID
}

func (p *PaymentMethodRequestBody) GetExtraProperties() map[string]interface{} {
	return p.extraProperties
}

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

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

type PaymentMethodResponseData struct {
	AccountLast4           *string   `json:"account_last4,omitempty" url:"account_last4,omitempty"`
	AccountName            *string   `json:"account_name,omitempty" url:"account_name,omitempty"`
	BankName               *string   `json:"bank_name,omitempty" url:"bank_name,omitempty"`
	BillingEmail           *string   `json:"billing_email,omitempty" url:"billing_email,omitempty"`
	BillingName            *string   `json:"billing_name,omitempty" url:"billing_name,omitempty"`
	CardBrand              *string   `json:"card_brand,omitempty" url:"card_brand,omitempty"`
	CardExpMonth           *int      `json:"card_exp_month,omitempty" url:"card_exp_month,omitempty"`
	CardExpYear            *int      `json:"card_exp_year,omitempty" url:"card_exp_year,omitempty"`
	CardLast4              *string   `json:"card_last4,omitempty" url:"card_last4,omitempty"`
	CompanyID              *string   `json:"company_id,omitempty" url:"company_id,omitempty"`
	CreatedAt              time.Time `json:"created_at" url:"created_at"`
	CustomerExternalID     string    `json:"customer_external_id" url:"customer_external_id"`
	EnvironmentID          string    `json:"environment_id" url:"environment_id"`
	ExternalID             string    `json:"external_id" url:"external_id"`
	ID                     string    `json:"id" url:"id"`
	PaymentMethodType      string    `json:"payment_method_type" url:"payment_method_type"`
	SubscriptionExternalID *string   `json:"subscription_external_id,omitempty" url:"subscription_external_id,omitempty"`
	UpdatedAt              time.Time `json:"updated_at" url:"updated_at"`

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

func (p *PaymentMethodResponseData) GetAccountLast4() *string {
	if p == nil {
		return nil
	}
	return p.AccountLast4
}

func (p *PaymentMethodResponseData) GetAccountName() *string {
	if p == nil {
		return nil
	}
	return p.AccountName
}

func (p *PaymentMethodResponseData) GetBankName() *string {
	if p == nil {
		return nil
	}
	return p.BankName
}

func (p *PaymentMethodResponseData) GetBillingEmail() *string {
	if p == nil {
		return nil
	}
	return p.BillingEmail
}

func (p *PaymentMethodResponseData) GetBillingName() *string {
	if p == nil {
		return nil
	}
	return p.BillingName
}

func (p *PaymentMethodResponseData) GetCardBrand() *string {
	if p == nil {
		return nil
	}
	return p.CardBrand
}

func (p *PaymentMethodResponseData) GetCardExpMonth() *int {
	if p == nil {
		return nil
	}
	return p.CardExpMonth
}

func (p *PaymentMethodResponseData) GetCardExpYear() *int {
	if p == nil {
		return nil
	}
	return p.CardExpYear
}

func (p *PaymentMethodResponseData) GetCardLast4() *string {
	if p == nil {
		return nil
	}
	return p.CardLast4
}

func (p *PaymentMethodResponseData) GetCompanyID() *string {
	if p == nil {
		return nil
	}
	return p.CompanyID
}

func (p *PaymentMethodResponseData) GetCreatedAt() time.Time {
	if p == nil {
		return time.Time{}
	}
	return p.CreatedAt
}

func (p *PaymentMethodResponseData) GetCustomerExternalID() string {
	if p == nil {
		return ""
	}
	return p.CustomerExternalID
}

func (p *PaymentMethodResponseData) GetEnvironmentID() string {
	if p == nil {
		return ""
	}
	return p.EnvironmentID
}

func (p *PaymentMethodResponseData) GetExternalID() string {
	if p == nil {
		return ""
	}
	return p.ExternalID
}

func (p *PaymentMethodResponseData) GetID() string {
	if p == nil {
		return ""
	}
	return p.ID
}

func (p *PaymentMethodResponseData) GetPaymentMethodType() string {
	if p == nil {
		return ""
	}
	return p.PaymentMethodType
}

func (p *PaymentMethodResponseData) GetSubscriptionExternalID() *string {
	if p == nil {
		return nil
	}
	return p.SubscriptionExternalID
}

func (p *PaymentMethodResponseData) GetUpdatedAt() time.Time {
	if p == nil {
		return time.Time{}
	}
	return p.UpdatedAt
}

func (p *PaymentMethodResponseData) GetExtraProperties() map[string]interface{} {
	return p.extraProperties
}

func (p *PaymentMethodResponseData) UnmarshalJSON(data []byte) error {
	type embed PaymentMethodResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*p),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*p = PaymentMethodResponseData(unmarshaler.embed)
	p.CreatedAt = unmarshaler.CreatedAt.Time()
	p.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *p)
	if err != nil {
		return err
	}
	p.extraProperties = extraProperties
	p.rawJSON = json.RawMessage(data)
	return nil
}

func (p *PaymentMethodResponseData) MarshalJSON() ([]byte, error) {
	type embed PaymentMethodResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*p),
		CreatedAt: internal.NewDateTime(p.CreatedAt),
		UpdatedAt: internal.NewDateTime(p.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type PlanAudienceResponseData struct {
	CreatedAt     time.Time `json:"created_at" url:"created_at"`
	EnvironmentID string    `json:"environment_id" url:"environment_id"`
	FlagID        *string   `json:"flag_id,omitempty" url:"flag_id,omitempty"`
	ID            string    `json:"id" url:"id"`
	Name          string    `json:"name" url:"name"`
	PlanID        *string   `json:"plan_id,omitempty" url:"plan_id,omitempty"`
	Priority      int       `json:"priority" url:"priority"`
	RuleType      string    `json:"rule_type" url:"rule_type"`
	UpdatedAt     time.Time `json:"updated_at" url:"updated_at"`
	Value         bool      `json:"value" url:"value"`

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

func (p *PlanAudienceResponseData) GetCreatedAt() time.Time {
	if p == nil {
		return time.Time{}
	}
	return p.CreatedAt
}

func (p *PlanAudienceResponseData) GetEnvironmentID() string {
	if p == nil {
		return ""
	}
	return p.EnvironmentID
}

func (p *PlanAudienceResponseData) GetFlagID() *string {
	if p == nil {
		return nil
	}
	return p.FlagID
}

func (p *PlanAudienceResponseData) GetID() string {
	if p == nil {
		return ""
	}
	return p.ID
}

func (p *PlanAudienceResponseData) GetName() string {
	if p == nil {
		return ""
	}
	return p.Name
}

func (p *PlanAudienceResponseData) GetPlanID() *string {
	if p == nil {
		return nil
	}
	return p.PlanID
}

func (p *PlanAudienceResponseData) GetPriority() int {
	if p == nil {
		return 0
	}
	return p.Priority
}

func (p *PlanAudienceResponseData) GetRuleType() string {
	if p == nil {
		return ""
	}
	return p.RuleType
}

func (p *PlanAudienceResponseData) GetUpdatedAt() time.Time {
	if p == nil {
		return time.Time{}
	}
	return p.UpdatedAt
}

func (p *PlanAudienceResponseData) GetValue() bool {
	if p == nil {
		return false
	}
	return p.Value
}

func (p *PlanAudienceResponseData) GetExtraProperties() map[string]interface{} {
	return p.extraProperties
}

func (p *PlanAudienceResponseData) UnmarshalJSON(data []byte) error {
	type embed PlanAudienceResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*p),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*p = PlanAudienceResponseData(unmarshaler.embed)
	p.CreatedAt = unmarshaler.CreatedAt.Time()
	p.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *p)
	if err != nil {
		return err
	}
	p.extraProperties = extraProperties
	p.rawJSON = json.RawMessage(data)
	return nil
}

func (p *PlanAudienceResponseData) MarshalJSON() ([]byte, error) {
	type embed PlanAudienceResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*p),
		CreatedAt: internal.NewDateTime(p.CreatedAt),
		UpdatedAt: internal.NewDateTime(p.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type PlanEntitlementResponseData struct {
	CreatedAt              time.Time                          `json:"created_at" url:"created_at"`
	EnvironmentID          string                             `json:"environment_id" url:"environment_id"`
	Feature                *FeatureResponseData               `json:"feature,omitempty" url:"feature,omitempty"`
	FeatureID              string                             `json:"feature_id" url:"feature_id"`
	ID                     string                             `json:"id" url:"id"`
	MeteredMonthlyPrice    *BillingPriceView                  `json:"metered_monthly_price,omitempty" url:"metered_monthly_price,omitempty"`
	MeteredYearlyPrice     *BillingPriceView                  `json:"metered_yearly_price,omitempty" url:"metered_yearly_price,omitempty"`
	MetricPeriod           *string                            `json:"metric_period,omitempty" url:"metric_period,omitempty"`
	MetricPeriodMonthReset *string                            `json:"metric_period_month_reset,omitempty" url:"metric_period_month_reset,omitempty"`
	Plan                   *PlanResponseData                  `json:"plan,omitempty" url:"plan,omitempty"`
	PlanID                 string                             `json:"plan_id" url:"plan_id"`
	PriceBehavior          *string                            `json:"price_behavior,omitempty" url:"price_behavior,omitempty"`
	RuleID                 string                             `json:"rule_id" url:"rule_id"`
	UpdatedAt              time.Time                          `json:"updated_at" url:"updated_at"`
	ValueBool              *bool                              `json:"value_bool,omitempty" url:"value_bool,omitempty"`
	ValueNumeric           *int                               `json:"value_numeric,omitempty" url:"value_numeric,omitempty"`
	ValueTrait             *EntityTraitDefinitionResponseData `json:"value_trait,omitempty" url:"value_trait,omitempty"`
	ValueTraitID           *string                            `json:"value_trait_id,omitempty" url:"value_trait_id,omitempty"`
	ValueType              string                             `json:"value_type" url:"value_type"`

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

func (p *PlanEntitlementResponseData) GetCreatedAt() time.Time {
	if p == nil {
		return time.Time{}
	}
	return p.CreatedAt
}

func (p *PlanEntitlementResponseData) GetEnvironmentID() string {
	if p == nil {
		return ""
	}
	return p.EnvironmentID
}

func (p *PlanEntitlementResponseData) GetFeature() *FeatureResponseData {
	if p == nil {
		return nil
	}
	return p.Feature
}

func (p *PlanEntitlementResponseData) GetFeatureID() string {
	if p == nil {
		return ""
	}
	return p.FeatureID
}

func (p *PlanEntitlementResponseData) GetID() string {
	if p == nil {
		return ""
	}
	return p.ID
}

func (p *PlanEntitlementResponseData) GetMeteredMonthlyPrice() *BillingPriceView {
	if p == nil {
		return nil
	}
	return p.MeteredMonthlyPrice
}

func (p *PlanEntitlementResponseData) GetMeteredYearlyPrice() *BillingPriceView {
	if p == nil {
		return nil
	}
	return p.MeteredYearlyPrice
}

func (p *PlanEntitlementResponseData) GetMetricPeriod() *string {
	if p == nil {
		return nil
	}
	return p.MetricPeriod
}

func (p *PlanEntitlementResponseData) GetMetricPeriodMonthReset() *string {
	if p == nil {
		return nil
	}
	return p.MetricPeriodMonthReset
}

func (p *PlanEntitlementResponseData) GetPlan() *PlanResponseData {
	if p == nil {
		return nil
	}
	return p.Plan
}

func (p *PlanEntitlementResponseData) GetPlanID() string {
	if p == nil {
		return ""
	}
	return p.PlanID
}

func (p *PlanEntitlementResponseData) GetPriceBehavior() *string {
	if p == nil {
		return nil
	}
	return p.PriceBehavior
}

func (p *PlanEntitlementResponseData) GetRuleID() string {
	if p == nil {
		return ""
	}
	return p.RuleID
}

func (p *PlanEntitlementResponseData) GetUpdatedAt() time.Time {
	if p == nil {
		return time.Time{}
	}
	return p.UpdatedAt
}

func (p *PlanEntitlementResponseData) GetValueBool() *bool {
	if p == nil {
		return nil
	}
	return p.ValueBool
}

func (p *PlanEntitlementResponseData) GetValueNumeric() *int {
	if p == nil {
		return nil
	}
	return p.ValueNumeric
}

func (p *PlanEntitlementResponseData) GetValueTrait() *EntityTraitDefinitionResponseData {
	if p == nil {
		return nil
	}
	return p.ValueTrait
}

func (p *PlanEntitlementResponseData) GetValueTraitID() *string {
	if p == nil {
		return nil
	}
	return p.ValueTraitID
}

func (p *PlanEntitlementResponseData) GetValueType() string {
	if p == nil {
		return ""
	}
	return p.ValueType
}

func (p *PlanEntitlementResponseData) GetExtraProperties() map[string]interface{} {
	return p.extraProperties
}

func (p *PlanEntitlementResponseData) UnmarshalJSON(data []byte) error {
	type embed PlanEntitlementResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*p),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*p = PlanEntitlementResponseData(unmarshaler.embed)
	p.CreatedAt = unmarshaler.CreatedAt.Time()
	p.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *p)
	if err != nil {
		return err
	}
	p.extraProperties = extraProperties
	p.rawJSON = json.RawMessage(data)
	return nil
}

func (p *PlanEntitlementResponseData) MarshalJSON() ([]byte, error) {
	type embed PlanEntitlementResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*p),
		CreatedAt: internal.NewDateTime(p.CreatedAt),
		UpdatedAt: internal.NewDateTime(p.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type PlanResponseData struct {
	AudienceType *string   `json:"audience_type,omitempty" url:"audience_type,omitempty"`
	CreatedAt    time.Time `json:"created_at" url:"created_at"`
	Description  string    `json:"description" url:"description"`
	Icon         string    `json:"icon" url:"icon"`
	ID           string    `json:"id" url:"id"`
	Name         string    `json:"name" url:"name"`
	PlanType     string    `json:"plan_type" url:"plan_type"`
	UpdatedAt    time.Time `json:"updated_at" url:"updated_at"`

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

func (p *PlanResponseData) GetAudienceType() *string {
	if p == nil {
		return nil
	}
	return p.AudienceType
}

func (p *PlanResponseData) GetCreatedAt() time.Time {
	if p == nil {
		return time.Time{}
	}
	return p.CreatedAt
}

func (p *PlanResponseData) GetDescription() string {
	if p == nil {
		return ""
	}
	return p.Description
}

func (p *PlanResponseData) GetIcon() string {
	if p == nil {
		return ""
	}
	return p.Icon
}

func (p *PlanResponseData) GetID() string {
	if p == nil {
		return ""
	}
	return p.ID
}

func (p *PlanResponseData) GetName() string {
	if p == nil {
		return ""
	}
	return p.Name
}

func (p *PlanResponseData) GetPlanType() string {
	if p == nil {
		return ""
	}
	return p.PlanType
}

func (p *PlanResponseData) GetUpdatedAt() time.Time {
	if p == nil {
		return time.Time{}
	}
	return p.UpdatedAt
}

func (p *PlanResponseData) GetExtraProperties() map[string]interface{} {
	return p.extraProperties
}

func (p *PlanResponseData) UnmarshalJSON(data []byte) error {
	type embed PlanResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*p),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*p = PlanResponseData(unmarshaler.embed)
	p.CreatedAt = unmarshaler.CreatedAt.Time()
	p.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *p)
	if err != nil {
		return err
	}
	p.extraProperties = extraProperties
	p.rawJSON = json.RawMessage(data)
	return nil
}

func (p *PlanResponseData) MarshalJSON() ([]byte, error) {
	type embed PlanResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*p),
		CreatedAt: internal.NewDateTime(p.CreatedAt),
		UpdatedAt: internal.NewDateTime(p.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type PreviewObject struct {
	Description *string `json:"description,omitempty" url:"description,omitempty"`
	ID          string  `json:"id" url:"id"`
	ImageURL    *string `json:"image_url,omitempty" url:"image_url,omitempty"`
	Name        string  `json:"name" url:"name"`

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

func (p *PreviewObject) GetDescription() *string {
	if p == nil {
		return nil
	}
	return p.Description
}

func (p *PreviewObject) GetID() string {
	if p == nil {
		return ""
	}
	return p.ID
}

func (p *PreviewObject) GetImageURL() *string {
	if p == nil {
		return nil
	}
	return p.ImageURL
}

func (p *PreviewObject) GetName() string {
	if p == nil {
		return ""
	}
	return p.Name
}

func (p *PreviewObject) GetExtraProperties() map[string]interface{} {
	return p.extraProperties
}

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

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

type PreviewObjectResponseData struct {
	Description *string `json:"description,omitempty" url:"description,omitempty"`
	ID          string  `json:"id" url:"id"`
	ImageURL    *string `json:"image_url,omitempty" url:"image_url,omitempty"`
	Name        string  `json:"name" url:"name"`

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

func (p *PreviewObjectResponseData) GetDescription() *string {
	if p == nil {
		return nil
	}
	return p.Description
}

func (p *PreviewObjectResponseData) GetID() string {
	if p == nil {
		return ""
	}
	return p.ID
}

func (p *PreviewObjectResponseData) GetImageURL() *string {
	if p == nil {
		return nil
	}
	return p.ImageURL
}

func (p *PreviewObjectResponseData) GetName() string {
	if p == nil {
		return ""
	}
	return p.Name
}

func (p *PreviewObjectResponseData) GetExtraProperties() map[string]interface{} {
	return p.extraProperties
}

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

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

type RuleConditionDetailResponseData struct {
	ComparisonTrait        *EntityTraitDefinitionResponseData `json:"comparison_trait,omitempty" url:"comparison_trait,omitempty"`
	ComparisonTraitID      *string                            `json:"comparison_trait_id,omitempty" url:"comparison_trait_id,omitempty"`
	ConditionGroupID       *string                            `json:"condition_group_id,omitempty" url:"condition_group_id,omitempty"`
	ConditionType          string                             `json:"condition_type" url:"condition_type"`
	CreatedAt              time.Time                          `json:"created_at" url:"created_at"`
	EnvironmentID          string                             `json:"environment_id" url:"environment_id"`
	EventSubtype           *string                            `json:"event_subtype,omitempty" url:"event_subtype,omitempty"`
	FlagID                 *string                            `json:"flag_id,omitempty" url:"flag_id,omitempty"`
	ID                     string                             `json:"id" url:"id"`
	MetricPeriod           *string                            `json:"metric_period,omitempty" url:"metric_period,omitempty"`
	MetricPeriodMonthReset *string                            `json:"metric_period_month_reset,omitempty" url:"metric_period_month_reset,omitempty"`
	MetricValue            *int                               `json:"metric_value,omitempty" url:"metric_value,omitempty"`
	Operator               string                             `json:"operator" url:"operator"`
	PlanID                 *string                            `json:"plan_id,omitempty" url:"plan_id,omitempty"`
	ResourceIDs            []string                           `json:"resource_ids,omitempty" url:"resource_ids,omitempty"`
	Resources              []*PreviewObjectResponseData       `json:"resources,omitempty" url:"resources,omitempty"`
	RuleID                 string                             `json:"rule_id" url:"rule_id"`
	Trait                  *EntityTraitDefinitionResponseData `json:"trait,omitempty" url:"trait,omitempty"`
	TraitEntityType        *string                            `json:"trait_entity_type,omitempty" url:"trait_entity_type,omitempty"`
	TraitID                *string                            `json:"trait_id,omitempty" url:"trait_id,omitempty"`
	TraitValue             string                             `json:"trait_value" url:"trait_value"`
	UpdatedAt              time.Time                          `json:"updated_at" url:"updated_at"`

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

func (r *RuleConditionDetailResponseData) GetComparisonTrait() *EntityTraitDefinitionResponseData {
	if r == nil {
		return nil
	}
	return r.ComparisonTrait
}

func (r *RuleConditionDetailResponseData) GetComparisonTraitID() *string {
	if r == nil {
		return nil
	}
	return r.ComparisonTraitID
}

func (r *RuleConditionDetailResponseData) GetConditionGroupID() *string {
	if r == nil {
		return nil
	}
	return r.ConditionGroupID
}

func (r *RuleConditionDetailResponseData) GetConditionType() string {
	if r == nil {
		return ""
	}
	return r.ConditionType
}

func (r *RuleConditionDetailResponseData) GetCreatedAt() time.Time {
	if r == nil {
		return time.Time{}
	}
	return r.CreatedAt
}

func (r *RuleConditionDetailResponseData) GetEnvironmentID() string {
	if r == nil {
		return ""
	}
	return r.EnvironmentID
}

func (r *RuleConditionDetailResponseData) GetEventSubtype() *string {
	if r == nil {
		return nil
	}
	return r.EventSubtype
}

func (r *RuleConditionDetailResponseData) GetFlagID() *string {
	if r == nil {
		return nil
	}
	return r.FlagID
}

func (r *RuleConditionDetailResponseData) GetID() string {
	if r == nil {
		return ""
	}
	return r.ID
}

func (r *RuleConditionDetailResponseData) GetMetricPeriod() *string {
	if r == nil {
		return nil
	}
	return r.MetricPeriod
}

func (r *RuleConditionDetailResponseData) GetMetricPeriodMonthReset() *string {
	if r == nil {
		return nil
	}
	return r.MetricPeriodMonthReset
}

func (r *RuleConditionDetailResponseData) GetMetricValue() *int {
	if r == nil {
		return nil
	}
	return r.MetricValue
}

func (r *RuleConditionDetailResponseData) GetOperator() string {
	if r == nil {
		return ""
	}
	return r.Operator
}

func (r *RuleConditionDetailResponseData) GetPlanID() *string {
	if r == nil {
		return nil
	}
	return r.PlanID
}

func (r *RuleConditionDetailResponseData) GetResourceIDs() []string {
	if r == nil {
		return nil
	}
	return r.ResourceIDs
}

func (r *RuleConditionDetailResponseData) GetResources() []*PreviewObjectResponseData {
	if r == nil {
		return nil
	}
	return r.Resources
}

func (r *RuleConditionDetailResponseData) GetRuleID() string {
	if r == nil {
		return ""
	}
	return r.RuleID
}

func (r *RuleConditionDetailResponseData) GetTrait() *EntityTraitDefinitionResponseData {
	if r == nil {
		return nil
	}
	return r.Trait
}

func (r *RuleConditionDetailResponseData) GetTraitEntityType() *string {
	if r == nil {
		return nil
	}
	return r.TraitEntityType
}

func (r *RuleConditionDetailResponseData) GetTraitID() *string {
	if r == nil {
		return nil
	}
	return r.TraitID
}

func (r *RuleConditionDetailResponseData) GetTraitValue() string {
	if r == nil {
		return ""
	}
	return r.TraitValue
}

func (r *RuleConditionDetailResponseData) GetUpdatedAt() time.Time {
	if r == nil {
		return time.Time{}
	}
	return r.UpdatedAt
}

func (r *RuleConditionDetailResponseData) GetExtraProperties() map[string]interface{} {
	return r.extraProperties
}

func (r *RuleConditionDetailResponseData) UnmarshalJSON(data []byte) error {
	type embed RuleConditionDetailResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*r),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*r = RuleConditionDetailResponseData(unmarshaler.embed)
	r.CreatedAt = unmarshaler.CreatedAt.Time()
	r.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *RuleConditionDetailResponseData) MarshalJSON() ([]byte, error) {
	type embed RuleConditionDetailResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*r),
		CreatedAt: internal.NewDateTime(r.CreatedAt),
		UpdatedAt: internal.NewDateTime(r.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type RuleConditionGroupDetailResponseData struct {
	Conditions    []*RuleConditionDetailResponseData `json:"conditions,omitempty" url:"conditions,omitempty"`
	CreatedAt     time.Time                          `json:"created_at" url:"created_at"`
	EnvironmentID string                             `json:"environment_id" url:"environment_id"`
	FlagID        *string                            `json:"flag_id,omitempty" url:"flag_id,omitempty"`
	ID            string                             `json:"id" url:"id"`
	PlanID        *string                            `json:"plan_id,omitempty" url:"plan_id,omitempty"`
	RuleID        string                             `json:"rule_id" url:"rule_id"`
	UpdatedAt     time.Time                          `json:"updated_at" url:"updated_at"`

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

func (r *RuleConditionGroupDetailResponseData) GetConditions() []*RuleConditionDetailResponseData {
	if r == nil {
		return nil
	}
	return r.Conditions
}

func (r *RuleConditionGroupDetailResponseData) GetCreatedAt() time.Time {
	if r == nil {
		return time.Time{}
	}
	return r.CreatedAt
}

func (r *RuleConditionGroupDetailResponseData) GetEnvironmentID() string {
	if r == nil {
		return ""
	}
	return r.EnvironmentID
}

func (r *RuleConditionGroupDetailResponseData) GetFlagID() *string {
	if r == nil {
		return nil
	}
	return r.FlagID
}

func (r *RuleConditionGroupDetailResponseData) GetID() string {
	if r == nil {
		return ""
	}
	return r.ID
}

func (r *RuleConditionGroupDetailResponseData) GetPlanID() *string {
	if r == nil {
		return nil
	}
	return r.PlanID
}

func (r *RuleConditionGroupDetailResponseData) GetRuleID() string {
	if r == nil {
		return ""
	}
	return r.RuleID
}

func (r *RuleConditionGroupDetailResponseData) GetUpdatedAt() time.Time {
	if r == nil {
		return time.Time{}
	}
	return r.UpdatedAt
}

func (r *RuleConditionGroupDetailResponseData) GetExtraProperties() map[string]interface{} {
	return r.extraProperties
}

func (r *RuleConditionGroupDetailResponseData) UnmarshalJSON(data []byte) error {
	type embed RuleConditionGroupDetailResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*r),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*r = RuleConditionGroupDetailResponseData(unmarshaler.embed)
	r.CreatedAt = unmarshaler.CreatedAt.Time()
	r.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *RuleConditionGroupDetailResponseData) MarshalJSON() ([]byte, error) {
	type embed RuleConditionGroupDetailResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*r),
		CreatedAt: internal.NewDateTime(r.CreatedAt),
		UpdatedAt: internal.NewDateTime(r.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type RuleConditionGroupResponseData struct {
	CreatedAt     time.Time `json:"created_at" url:"created_at"`
	EnvironmentID string    `json:"environment_id" url:"environment_id"`
	FlagID        *string   `json:"flag_id,omitempty" url:"flag_id,omitempty"`
	ID            string    `json:"id" url:"id"`
	PlanID        *string   `json:"plan_id,omitempty" url:"plan_id,omitempty"`
	RuleID        string    `json:"rule_id" url:"rule_id"`
	UpdatedAt     time.Time `json:"updated_at" url:"updated_at"`

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

func (r *RuleConditionGroupResponseData) GetCreatedAt() time.Time {
	if r == nil {
		return time.Time{}
	}
	return r.CreatedAt
}

func (r *RuleConditionGroupResponseData) GetEnvironmentID() string {
	if r == nil {
		return ""
	}
	return r.EnvironmentID
}

func (r *RuleConditionGroupResponseData) GetFlagID() *string {
	if r == nil {
		return nil
	}
	return r.FlagID
}

func (r *RuleConditionGroupResponseData) GetID() string {
	if r == nil {
		return ""
	}
	return r.ID
}

func (r *RuleConditionGroupResponseData) GetPlanID() *string {
	if r == nil {
		return nil
	}
	return r.PlanID
}

func (r *RuleConditionGroupResponseData) GetRuleID() string {
	if r == nil {
		return ""
	}
	return r.RuleID
}

func (r *RuleConditionGroupResponseData) GetUpdatedAt() time.Time {
	if r == nil {
		return time.Time{}
	}
	return r.UpdatedAt
}

func (r *RuleConditionGroupResponseData) GetExtraProperties() map[string]interface{} {
	return r.extraProperties
}

func (r *RuleConditionGroupResponseData) UnmarshalJSON(data []byte) error {
	type embed RuleConditionGroupResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*r),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*r = RuleConditionGroupResponseData(unmarshaler.embed)
	r.CreatedAt = unmarshaler.CreatedAt.Time()
	r.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *RuleConditionGroupResponseData) MarshalJSON() ([]byte, error) {
	type embed RuleConditionGroupResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*r),
		CreatedAt: internal.NewDateTime(r.CreatedAt),
		UpdatedAt: internal.NewDateTime(r.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type RuleConditionResponseData struct {
	ComparisonTraitID      *string   `json:"comparison_trait_id,omitempty" url:"comparison_trait_id,omitempty"`
	ConditionGroupID       *string   `json:"condition_group_id,omitempty" url:"condition_group_id,omitempty"`
	ConditionType          string    `json:"condition_type" url:"condition_type"`
	CreatedAt              time.Time `json:"created_at" url:"created_at"`
	EnvironmentID          string    `json:"environment_id" url:"environment_id"`
	EventSubtype           *string   `json:"event_subtype,omitempty" url:"event_subtype,omitempty"`
	FlagID                 *string   `json:"flag_id,omitempty" url:"flag_id,omitempty"`
	ID                     string    `json:"id" url:"id"`
	MetricPeriod           *string   `json:"metric_period,omitempty" url:"metric_period,omitempty"`
	MetricPeriodMonthReset *string   `json:"metric_period_month_reset,omitempty" url:"metric_period_month_reset,omitempty"`
	MetricValue            *int      `json:"metric_value,omitempty" url:"metric_value,omitempty"`
	Operator               string    `json:"operator" url:"operator"`
	PlanID                 *string   `json:"plan_id,omitempty" url:"plan_id,omitempty"`
	ResourceIDs            []string  `json:"resource_ids,omitempty" url:"resource_ids,omitempty"`
	RuleID                 string    `json:"rule_id" url:"rule_id"`
	TraitEntityType        *string   `json:"trait_entity_type,omitempty" url:"trait_entity_type,omitempty"`
	TraitID                *string   `json:"trait_id,omitempty" url:"trait_id,omitempty"`
	TraitValue             string    `json:"trait_value" url:"trait_value"`
	UpdatedAt              time.Time `json:"updated_at" url:"updated_at"`

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

func (r *RuleConditionResponseData) GetComparisonTraitID() *string {
	if r == nil {
		return nil
	}
	return r.ComparisonTraitID
}

func (r *RuleConditionResponseData) GetConditionGroupID() *string {
	if r == nil {
		return nil
	}
	return r.ConditionGroupID
}

func (r *RuleConditionResponseData) GetConditionType() string {
	if r == nil {
		return ""
	}
	return r.ConditionType
}

func (r *RuleConditionResponseData) GetCreatedAt() time.Time {
	if r == nil {
		return time.Time{}
	}
	return r.CreatedAt
}

func (r *RuleConditionResponseData) GetEnvironmentID() string {
	if r == nil {
		return ""
	}
	return r.EnvironmentID
}

func (r *RuleConditionResponseData) GetEventSubtype() *string {
	if r == nil {
		return nil
	}
	return r.EventSubtype
}

func (r *RuleConditionResponseData) GetFlagID() *string {
	if r == nil {
		return nil
	}
	return r.FlagID
}

func (r *RuleConditionResponseData) GetID() string {
	if r == nil {
		return ""
	}
	return r.ID
}

func (r *RuleConditionResponseData) GetMetricPeriod() *string {
	if r == nil {
		return nil
	}
	return r.MetricPeriod
}

func (r *RuleConditionResponseData) GetMetricPeriodMonthReset() *string {
	if r == nil {
		return nil
	}
	return r.MetricPeriodMonthReset
}

func (r *RuleConditionResponseData) GetMetricValue() *int {
	if r == nil {
		return nil
	}
	return r.MetricValue
}

func (r *RuleConditionResponseData) GetOperator() string {
	if r == nil {
		return ""
	}
	return r.Operator
}

func (r *RuleConditionResponseData) GetPlanID() *string {
	if r == nil {
		return nil
	}
	return r.PlanID
}

func (r *RuleConditionResponseData) GetResourceIDs() []string {
	if r == nil {
		return nil
	}
	return r.ResourceIDs
}

func (r *RuleConditionResponseData) GetRuleID() string {
	if r == nil {
		return ""
	}
	return r.RuleID
}

func (r *RuleConditionResponseData) GetTraitEntityType() *string {
	if r == nil {
		return nil
	}
	return r.TraitEntityType
}

func (r *RuleConditionResponseData) GetTraitID() *string {
	if r == nil {
		return nil
	}
	return r.TraitID
}

func (r *RuleConditionResponseData) GetTraitValue() string {
	if r == nil {
		return ""
	}
	return r.TraitValue
}

func (r *RuleConditionResponseData) GetUpdatedAt() time.Time {
	if r == nil {
		return time.Time{}
	}
	return r.UpdatedAt
}

func (r *RuleConditionResponseData) GetExtraProperties() map[string]interface{} {
	return r.extraProperties
}

func (r *RuleConditionResponseData) UnmarshalJSON(data []byte) error {
	type embed RuleConditionResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*r),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*r = RuleConditionResponseData(unmarshaler.embed)
	r.CreatedAt = unmarshaler.CreatedAt.Time()
	r.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *RuleConditionResponseData) MarshalJSON() ([]byte, error) {
	type embed RuleConditionResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*r),
		CreatedAt: internal.NewDateTime(r.CreatedAt),
		UpdatedAt: internal.NewDateTime(r.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type RuleDetailResponseData struct {
	ConditionGroups []*RuleConditionGroupDetailResponseData `json:"condition_groups,omitempty" url:"condition_groups,omitempty"`
	Conditions      []*RuleConditionDetailResponseData      `json:"conditions,omitempty" url:"conditions,omitempty"`
	CreatedAt       time.Time                               `json:"created_at" url:"created_at"`
	EnvironmentID   string                                  `json:"environment_id" url:"environment_id"`
	FlagID          *string                                 `json:"flag_id,omitempty" url:"flag_id,omitempty"`
	ID              string                                  `json:"id" url:"id"`
	Name            string                                  `json:"name" url:"name"`
	PlanID          *string                                 `json:"plan_id,omitempty" url:"plan_id,omitempty"`
	Priority        int                                     `json:"priority" url:"priority"`
	RuleType        string                                  `json:"rule_type" url:"rule_type"`
	UpdatedAt       time.Time                               `json:"updated_at" url:"updated_at"`
	Value           bool                                    `json:"value" url:"value"`

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

func (r *RuleDetailResponseData) GetConditionGroups() []*RuleConditionGroupDetailResponseData {
	if r == nil {
		return nil
	}
	return r.ConditionGroups
}

func (r *RuleDetailResponseData) GetConditions() []*RuleConditionDetailResponseData {
	if r == nil {
		return nil
	}
	return r.Conditions
}

func (r *RuleDetailResponseData) GetCreatedAt() time.Time {
	if r == nil {
		return time.Time{}
	}
	return r.CreatedAt
}

func (r *RuleDetailResponseData) GetEnvironmentID() string {
	if r == nil {
		return ""
	}
	return r.EnvironmentID
}

func (r *RuleDetailResponseData) GetFlagID() *string {
	if r == nil {
		return nil
	}
	return r.FlagID
}

func (r *RuleDetailResponseData) GetID() string {
	if r == nil {
		return ""
	}
	return r.ID
}

func (r *RuleDetailResponseData) GetName() string {
	if r == nil {
		return ""
	}
	return r.Name
}

func (r *RuleDetailResponseData) GetPlanID() *string {
	if r == nil {
		return nil
	}
	return r.PlanID
}

func (r *RuleDetailResponseData) GetPriority() int {
	if r == nil {
		return 0
	}
	return r.Priority
}

func (r *RuleDetailResponseData) GetRuleType() string {
	if r == nil {
		return ""
	}
	return r.RuleType
}

func (r *RuleDetailResponseData) GetUpdatedAt() time.Time {
	if r == nil {
		return time.Time{}
	}
	return r.UpdatedAt
}

func (r *RuleDetailResponseData) GetValue() bool {
	if r == nil {
		return false
	}
	return r.Value
}

func (r *RuleDetailResponseData) GetExtraProperties() map[string]interface{} {
	return r.extraProperties
}

func (r *RuleDetailResponseData) UnmarshalJSON(data []byte) error {
	type embed RuleDetailResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*r),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*r = RuleDetailResponseData(unmarshaler.embed)
	r.CreatedAt = unmarshaler.CreatedAt.Time()
	r.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *RuleDetailResponseData) MarshalJSON() ([]byte, error) {
	type embed RuleDetailResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*r),
		CreatedAt: internal.NewDateTime(r.CreatedAt),
		UpdatedAt: internal.NewDateTime(r.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type RuleResponseData struct {
	CreatedAt     time.Time `json:"created_at" url:"created_at"`
	EnvironmentID string    `json:"environment_id" url:"environment_id"`
	FlagID        *string   `json:"flag_id,omitempty" url:"flag_id,omitempty"`
	ID            string    `json:"id" url:"id"`
	Name          string    `json:"name" url:"name"`
	PlanID        *string   `json:"plan_id,omitempty" url:"plan_id,omitempty"`
	Priority      int       `json:"priority" url:"priority"`
	RuleType      string    `json:"rule_type" url:"rule_type"`
	UpdatedAt     time.Time `json:"updated_at" url:"updated_at"`
	Value         bool      `json:"value" url:"value"`

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

func (r *RuleResponseData) GetCreatedAt() time.Time {
	if r == nil {
		return time.Time{}
	}
	return r.CreatedAt
}

func (r *RuleResponseData) GetEnvironmentID() string {
	if r == nil {
		return ""
	}
	return r.EnvironmentID
}

func (r *RuleResponseData) GetFlagID() *string {
	if r == nil {
		return nil
	}
	return r.FlagID
}

func (r *RuleResponseData) GetID() string {
	if r == nil {
		return ""
	}
	return r.ID
}

func (r *RuleResponseData) GetName() string {
	if r == nil {
		return ""
	}
	return r.Name
}

func (r *RuleResponseData) GetPlanID() *string {
	if r == nil {
		return nil
	}
	return r.PlanID
}

func (r *RuleResponseData) GetPriority() int {
	if r == nil {
		return 0
	}
	return r.Priority
}

func (r *RuleResponseData) GetRuleType() string {
	if r == nil {
		return ""
	}
	return r.RuleType
}

func (r *RuleResponseData) GetUpdatedAt() time.Time {
	if r == nil {
		return time.Time{}
	}
	return r.UpdatedAt
}

func (r *RuleResponseData) GetValue() bool {
	if r == nil {
		return false
	}
	return r.Value
}

func (r *RuleResponseData) GetExtraProperties() map[string]interface{} {
	return r.extraProperties
}

func (r *RuleResponseData) UnmarshalJSON(data []byte) error {
	type embed RuleResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*r),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*r = RuleResponseData(unmarshaler.embed)
	r.CreatedAt = unmarshaler.CreatedAt.Time()
	r.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *RuleResponseData) MarshalJSON() ([]byte, error) {
	type embed RuleResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*r),
		CreatedAt: internal.NewDateTime(r.CreatedAt),
		UpdatedAt: internal.NewDateTime(r.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type TemporaryAccessTokenResponseData struct {
	APIKeyID      string    `json:"api_key_id" url:"api_key_id"`
	CreatedAt     time.Time `json:"created_at" url:"created_at"`
	EnvironmentID string    `json:"environment_id" url:"environment_id"`
	ExpiredAt     time.Time `json:"expired_at" url:"expired_at"`
	ID            string    `json:"id" url:"id"`
	ResourceType  string    `json:"resource_type" url:"resource_type"`
	UpdatedAt     time.Time `json:"updated_at" url:"updated_at"`

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

func (t *TemporaryAccessTokenResponseData) GetAPIKeyID() string {
	if t == nil {
		return ""
	}
	return t.APIKeyID
}

func (t *TemporaryAccessTokenResponseData) GetCreatedAt() time.Time {
	if t == nil {
		return time.Time{}
	}
	return t.CreatedAt
}

func (t *TemporaryAccessTokenResponseData) GetEnvironmentID() string {
	if t == nil {
		return ""
	}
	return t.EnvironmentID
}

func (t *TemporaryAccessTokenResponseData) GetExpiredAt() time.Time {
	if t == nil {
		return time.Time{}
	}
	return t.ExpiredAt
}

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

func (t *TemporaryAccessTokenResponseData) GetResourceType() string {
	if t == nil {
		return ""
	}
	return t.ResourceType
}

func (t *TemporaryAccessTokenResponseData) GetUpdatedAt() time.Time {
	if t == nil {
		return time.Time{}
	}
	return t.UpdatedAt
}

func (t *TemporaryAccessTokenResponseData) GetExtraProperties() map[string]interface{} {
	return t.extraProperties
}

func (t *TemporaryAccessTokenResponseData) UnmarshalJSON(data []byte) error {
	type embed TemporaryAccessTokenResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		ExpiredAt *internal.DateTime `json:"expired_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*t),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*t = TemporaryAccessTokenResponseData(unmarshaler.embed)
	t.CreatedAt = unmarshaler.CreatedAt.Time()
	t.ExpiredAt = unmarshaler.ExpiredAt.Time()
	t.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TemporaryAccessTokenResponseData) MarshalJSON() ([]byte, error) {
	type embed TemporaryAccessTokenResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		ExpiredAt *internal.DateTime `json:"expired_at"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*t),
		CreatedAt: internal.NewDateTime(t.CreatedAt),
		ExpiredAt: internal.NewDateTime(t.ExpiredAt),
		UpdatedAt: internal.NewDateTime(t.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

func (t *TemporaryAccessTokenResponseData) String() string {
	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 UpdateEntitlementReqCommon struct {
	MeteredMonthlyPriceID  *string                                           `json:"metered_monthly_price_id,omitempty" url:"metered_monthly_price_id,omitempty"`
	MeteredYearlyPriceID   *string                                           `json:"metered_yearly_price_id,omitempty" url:"metered_yearly_price_id,omitempty"`
	MetricPeriod           *UpdateEntitlementReqCommonMetricPeriod           `json:"metric_period,omitempty" url:"metric_period,omitempty"`
	MetricPeriodMonthReset *UpdateEntitlementReqCommonMetricPeriodMonthReset `json:"metric_period_month_reset,omitempty" url:"metric_period_month_reset,omitempty"`
	ValueBool              *bool                                             `json:"value_bool,omitempty" url:"value_bool,omitempty"`
	ValueNumeric           *int                                              `json:"value_numeric,omitempty" url:"value_numeric,omitempty"`
	ValueTraitID           *string                                           `json:"value_trait_id,omitempty" url:"value_trait_id,omitempty"`
	ValueType              UpdateEntitlementReqCommonValueType               `json:"value_type" url:"value_type"`

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

func (u *UpdateEntitlementReqCommon) GetMeteredMonthlyPriceID() *string {
	if u == nil {
		return nil
	}
	return u.MeteredMonthlyPriceID
}

func (u *UpdateEntitlementReqCommon) GetMeteredYearlyPriceID() *string {
	if u == nil {
		return nil
	}
	return u.MeteredYearlyPriceID
}

func (u *UpdateEntitlementReqCommon) GetMetricPeriod() *UpdateEntitlementReqCommonMetricPeriod {
	if u == nil {
		return nil
	}
	return u.MetricPeriod
}

func (u *UpdateEntitlementReqCommon) GetMetricPeriodMonthReset() *UpdateEntitlementReqCommonMetricPeriodMonthReset {
	if u == nil {
		return nil
	}
	return u.MetricPeriodMonthReset
}

func (u *UpdateEntitlementReqCommon) GetValueBool() *bool {
	if u == nil {
		return nil
	}
	return u.ValueBool
}

func (u *UpdateEntitlementReqCommon) GetValueNumeric() *int {
	if u == nil {
		return nil
	}
	return u.ValueNumeric
}

func (u *UpdateEntitlementReqCommon) GetValueTraitID() *string {
	if u == nil {
		return nil
	}
	return u.ValueTraitID
}

func (u *UpdateEntitlementReqCommon) GetValueType() UpdateEntitlementReqCommonValueType {
	if u == nil {
		return ""
	}
	return u.ValueType
}

func (u *UpdateEntitlementReqCommon) GetExtraProperties() map[string]interface{} {
	return u.extraProperties
}

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

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

type UpdateEntitlementReqCommonMetricPeriod string

const (
	UpdateEntitlementReqCommonMetricPeriodAllTime      UpdateEntitlementReqCommonMetricPeriod = "all_time"
	UpdateEntitlementReqCommonMetricPeriodBilling      UpdateEntitlementReqCommonMetricPeriod = "billing"
	UpdateEntitlementReqCommonMetricPeriodCurrentMonth UpdateEntitlementReqCommonMetricPeriod = "current_month"
	UpdateEntitlementReqCommonMetricPeriodCurrentWeek  UpdateEntitlementReqCommonMetricPeriod = "current_week"
	UpdateEntitlementReqCommonMetricPeriodCurrentDay   UpdateEntitlementReqCommonMetricPeriod = "current_day"
)

func NewUpdateEntitlementReqCommonMetricPeriodFromString(s string) (UpdateEntitlementReqCommonMetricPeriod, error) {
	switch s {
	case "all_time":
		return UpdateEntitlementReqCommonMetricPeriodAllTime, nil
	case "billing":
		return UpdateEntitlementReqCommonMetricPeriodBilling, nil
	case "current_month":
		return UpdateEntitlementReqCommonMetricPeriodCurrentMonth, nil
	case "current_week":
		return UpdateEntitlementReqCommonMetricPeriodCurrentWeek, nil
	case "current_day":
		return UpdateEntitlementReqCommonMetricPeriodCurrentDay, nil
	}
	var t UpdateEntitlementReqCommonMetricPeriod
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (u UpdateEntitlementReqCommonMetricPeriod) Ptr() *UpdateEntitlementReqCommonMetricPeriod {
	return &u
}

type UpdateEntitlementReqCommonMetricPeriodMonthReset string

const (
	UpdateEntitlementReqCommonMetricPeriodMonthResetFirstOfMonth UpdateEntitlementReqCommonMetricPeriodMonthReset = "first_of_month"
	UpdateEntitlementReqCommonMetricPeriodMonthResetBillingCycle UpdateEntitlementReqCommonMetricPeriodMonthReset = "billing_cycle"
)

func NewUpdateEntitlementReqCommonMetricPeriodMonthResetFromString(s string) (UpdateEntitlementReqCommonMetricPeriodMonthReset, error) {
	switch s {
	case "first_of_month":
		return UpdateEntitlementReqCommonMetricPeriodMonthResetFirstOfMonth, nil
	case "billing_cycle":
		return UpdateEntitlementReqCommonMetricPeriodMonthResetBillingCycle, nil
	}
	var t UpdateEntitlementReqCommonMetricPeriodMonthReset
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (u UpdateEntitlementReqCommonMetricPeriodMonthReset) Ptr() *UpdateEntitlementReqCommonMetricPeriodMonthReset {
	return &u
}

type UpdateEntitlementReqCommonValueType string

const (
	UpdateEntitlementReqCommonValueTypeBoolean   UpdateEntitlementReqCommonValueType = "boolean"
	UpdateEntitlementReqCommonValueTypeNumeric   UpdateEntitlementReqCommonValueType = "numeric"
	UpdateEntitlementReqCommonValueTypeTrait     UpdateEntitlementReqCommonValueType = "trait"
	UpdateEntitlementReqCommonValueTypeUnlimited UpdateEntitlementReqCommonValueType = "unlimited"
)

func NewUpdateEntitlementReqCommonValueTypeFromString(s string) (UpdateEntitlementReqCommonValueType, error) {
	switch s {
	case "boolean":
		return UpdateEntitlementReqCommonValueTypeBoolean, nil
	case "numeric":
		return UpdateEntitlementReqCommonValueTypeNumeric, nil
	case "trait":
		return UpdateEntitlementReqCommonValueTypeTrait, nil
	case "unlimited":
		return UpdateEntitlementReqCommonValueTypeUnlimited, nil
	}
	var t UpdateEntitlementReqCommonValueType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (u UpdateEntitlementReqCommonValueType) Ptr() *UpdateEntitlementReqCommonValueType {
	return &u
}

type UpdateRuleRequestBody struct {
	ConditionGroups []*CreateOrUpdateConditionGroupRequestBody `json:"condition_groups,omitempty" url:"condition_groups,omitempty"`
	Conditions      []*CreateOrUpdateConditionRequestBody      `json:"conditions,omitempty" url:"conditions,omitempty"`
	Name            string                                     `json:"name" url:"name"`
	Priority        int                                        `json:"priority" url:"priority"`
	Value           bool                                       `json:"value" url:"value"`

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

func (u *UpdateRuleRequestBody) GetConditionGroups() []*CreateOrUpdateConditionGroupRequestBody {
	if u == nil {
		return nil
	}
	return u.ConditionGroups
}

func (u *UpdateRuleRequestBody) GetConditions() []*CreateOrUpdateConditionRequestBody {
	if u == nil {
		return nil
	}
	return u.Conditions
}

func (u *UpdateRuleRequestBody) GetName() string {
	if u == nil {
		return ""
	}
	return u.Name
}

func (u *UpdateRuleRequestBody) GetPriority() int {
	if u == nil {
		return 0
	}
	return u.Priority
}

func (u *UpdateRuleRequestBody) GetValue() bool {
	if u == nil {
		return false
	}
	return u.Value
}

func (u *UpdateRuleRequestBody) GetExtraProperties() map[string]interface{} {
	return u.extraProperties
}

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

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

type UpsertUserSubRequestBody struct {
	// Optionally specify company using Schematic company ID
	CompanyID *string `json:"company_id,omitempty" url:"company_id,omitempty"`
	// If you know the Schematic ID, you can use that here instead of keys
	ID         *string           `json:"id,omitempty" url:"id,omitempty"`
	Keys       map[string]string `json:"keys,omitempty" url:"keys,omitempty"`
	LastSeenAt *time.Time        `json:"last_seen_at,omitempty" url:"last_seen_at,omitempty"`
	Name       *string           `json:"name,omitempty" url:"name,omitempty"`
	// A map of trait names to trait values
	Traits     map[string]interface{} `json:"traits,omitempty" url:"traits,omitempty"`
	UpdateOnly *bool                  `json:"update_only,omitempty" url:"update_only,omitempty"`

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

func (u *UpsertUserSubRequestBody) GetCompanyID() *string {
	if u == nil {
		return nil
	}
	return u.CompanyID
}

func (u *UpsertUserSubRequestBody) GetID() *string {
	if u == nil {
		return nil
	}
	return u.ID
}

func (u *UpsertUserSubRequestBody) GetKeys() map[string]string {
	if u == nil {
		return nil
	}
	return u.Keys
}

func (u *UpsertUserSubRequestBody) GetLastSeenAt() *time.Time {
	if u == nil {
		return nil
	}
	return u.LastSeenAt
}

func (u *UpsertUserSubRequestBody) GetName() *string {
	if u == nil {
		return nil
	}
	return u.Name
}

func (u *UpsertUserSubRequestBody) GetTraits() map[string]interface{} {
	if u == nil {
		return nil
	}
	return u.Traits
}

func (u *UpsertUserSubRequestBody) GetUpdateOnly() *bool {
	if u == nil {
		return nil
	}
	return u.UpdateOnly
}

func (u *UpsertUserSubRequestBody) GetExtraProperties() map[string]interface{} {
	return u.extraProperties
}

func (u *UpsertUserSubRequestBody) UnmarshalJSON(data []byte) error {
	type embed UpsertUserSubRequestBody
	var unmarshaler = struct {
		embed
		LastSeenAt *internal.DateTime `json:"last_seen_at,omitempty"`
	}{
		embed: embed(*u),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*u = UpsertUserSubRequestBody(unmarshaler.embed)
	u.LastSeenAt = unmarshaler.LastSeenAt.TimePtr()
	extraProperties, err := internal.ExtractExtraProperties(data, *u)
	if err != nil {
		return err
	}
	u.extraProperties = extraProperties
	u.rawJSON = json.RawMessage(data)
	return nil
}

func (u *UpsertUserSubRequestBody) MarshalJSON() ([]byte, error) {
	type embed UpsertUserSubRequestBody
	var marshaler = struct {
		embed
		LastSeenAt *internal.DateTime `json:"last_seen_at,omitempty"`
	}{
		embed:      embed(*u),
		LastSeenAt: internal.NewOptionalDateTime(u.LastSeenAt),
	}
	return json.Marshal(marshaler)
}

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

type UserDetailResponseData struct {
	CompanyMemberships []*CompanyMembershipDetailResponseData `json:"company_memberships,omitempty" url:"company_memberships,omitempty"`
	CreatedAt          time.Time                              `json:"created_at" url:"created_at"`
	EntityTraits       []*EntityTraitDetailResponseData       `json:"entity_traits,omitempty" url:"entity_traits,omitempty"`
	EnvironmentID      string                                 `json:"environment_id" url:"environment_id"`
	ID                 string                                 `json:"id" url:"id"`
	Keys               []*EntityKeyDetailResponseData         `json:"keys,omitempty" url:"keys,omitempty"`
	LastSeenAt         *time.Time                             `json:"last_seen_at,omitempty" url:"last_seen_at,omitempty"`
	Name               string                                 `json:"name" url:"name"`
	// A map of trait names to trait values
	Traits    map[string]interface{} `json:"traits,omitempty" url:"traits,omitempty"`
	UpdatedAt time.Time              `json:"updated_at" url:"updated_at"`

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

func (u *UserDetailResponseData) GetCompanyMemberships() []*CompanyMembershipDetailResponseData {
	if u == nil {
		return nil
	}
	return u.CompanyMemberships
}

func (u *UserDetailResponseData) GetCreatedAt() time.Time {
	if u == nil {
		return time.Time{}
	}
	return u.CreatedAt
}

func (u *UserDetailResponseData) GetEntityTraits() []*EntityTraitDetailResponseData {
	if u == nil {
		return nil
	}
	return u.EntityTraits
}

func (u *UserDetailResponseData) GetEnvironmentID() string {
	if u == nil {
		return ""
	}
	return u.EnvironmentID
}

func (u *UserDetailResponseData) GetID() string {
	if u == nil {
		return ""
	}
	return u.ID
}

func (u *UserDetailResponseData) GetKeys() []*EntityKeyDetailResponseData {
	if u == nil {
		return nil
	}
	return u.Keys
}

func (u *UserDetailResponseData) GetLastSeenAt() *time.Time {
	if u == nil {
		return nil
	}
	return u.LastSeenAt
}

func (u *UserDetailResponseData) GetName() string {
	if u == nil {
		return ""
	}
	return u.Name
}

func (u *UserDetailResponseData) GetTraits() map[string]interface{} {
	if u == nil {
		return nil
	}
	return u.Traits
}

func (u *UserDetailResponseData) GetUpdatedAt() time.Time {
	if u == nil {
		return time.Time{}
	}
	return u.UpdatedAt
}

func (u *UserDetailResponseData) GetExtraProperties() map[string]interface{} {
	return u.extraProperties
}

func (u *UserDetailResponseData) UnmarshalJSON(data []byte) error {
	type embed UserDetailResponseData
	var unmarshaler = struct {
		embed
		CreatedAt  *internal.DateTime `json:"created_at"`
		LastSeenAt *internal.DateTime `json:"last_seen_at,omitempty"`
		UpdatedAt  *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*u),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*u = UserDetailResponseData(unmarshaler.embed)
	u.CreatedAt = unmarshaler.CreatedAt.Time()
	u.LastSeenAt = unmarshaler.LastSeenAt.TimePtr()
	u.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *u)
	if err != nil {
		return err
	}
	u.extraProperties = extraProperties
	u.rawJSON = json.RawMessage(data)
	return nil
}

func (u *UserDetailResponseData) MarshalJSON() ([]byte, error) {
	type embed UserDetailResponseData
	var marshaler = struct {
		embed
		CreatedAt  *internal.DateTime `json:"created_at"`
		LastSeenAt *internal.DateTime `json:"last_seen_at,omitempty"`
		UpdatedAt  *internal.DateTime `json:"updated_at"`
	}{
		embed:      embed(*u),
		CreatedAt:  internal.NewDateTime(u.CreatedAt),
		LastSeenAt: internal.NewOptionalDateTime(u.LastSeenAt),
		UpdatedAt:  internal.NewDateTime(u.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type UserResponseData struct {
	CreatedAt     time.Time  `json:"created_at" url:"created_at"`
	EnvironmentID string     `json:"environment_id" url:"environment_id"`
	ID            string     `json:"id" url:"id"`
	LastSeenAt    *time.Time `json:"last_seen_at,omitempty" url:"last_seen_at,omitempty"`
	Name          string     `json:"name" url:"name"`
	UpdatedAt     time.Time  `json:"updated_at" url:"updated_at"`

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

func (u *UserResponseData) GetCreatedAt() time.Time {
	if u == nil {
		return time.Time{}
	}
	return u.CreatedAt
}

func (u *UserResponseData) GetEnvironmentID() string {
	if u == nil {
		return ""
	}
	return u.EnvironmentID
}

func (u *UserResponseData) GetID() string {
	if u == nil {
		return ""
	}
	return u.ID
}

func (u *UserResponseData) GetLastSeenAt() *time.Time {
	if u == nil {
		return nil
	}
	return u.LastSeenAt
}

func (u *UserResponseData) GetName() string {
	if u == nil {
		return ""
	}
	return u.Name
}

func (u *UserResponseData) GetUpdatedAt() time.Time {
	if u == nil {
		return time.Time{}
	}
	return u.UpdatedAt
}

func (u *UserResponseData) GetExtraProperties() map[string]interface{} {
	return u.extraProperties
}

func (u *UserResponseData) UnmarshalJSON(data []byte) error {
	type embed UserResponseData
	var unmarshaler = struct {
		embed
		CreatedAt  *internal.DateTime `json:"created_at"`
		LastSeenAt *internal.DateTime `json:"last_seen_at,omitempty"`
		UpdatedAt  *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*u),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*u = UserResponseData(unmarshaler.embed)
	u.CreatedAt = unmarshaler.CreatedAt.Time()
	u.LastSeenAt = unmarshaler.LastSeenAt.TimePtr()
	u.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *u)
	if err != nil {
		return err
	}
	u.extraProperties = extraProperties
	u.rawJSON = json.RawMessage(data)
	return nil
}

func (u *UserResponseData) MarshalJSON() ([]byte, error) {
	type embed UserResponseData
	var marshaler = struct {
		embed
		CreatedAt  *internal.DateTime `json:"created_at"`
		LastSeenAt *internal.DateTime `json:"last_seen_at,omitempty"`
		UpdatedAt  *internal.DateTime `json:"updated_at"`
	}{
		embed:      embed(*u),
		CreatedAt:  internal.NewDateTime(u.CreatedAt),
		LastSeenAt: internal.NewOptionalDateTime(u.LastSeenAt),
		UpdatedAt:  internal.NewDateTime(u.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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

type WebhookEventResponseData struct {
	CreatedAt    time.Time  `json:"created_at" url:"created_at"`
	ID           string     `json:"id" url:"id"`
	Payload      *string    `json:"payload,omitempty" url:"payload,omitempty"`
	RequestType  string     `json:"request_type" url:"request_type"`
	ResponseCode *int       `json:"response_code,omitempty" url:"response_code,omitempty"`
	SentAt       *time.Time `json:"sent_at,omitempty" url:"sent_at,omitempty"`
	Status       string     `json:"status" url:"status"`
	UpdatedAt    time.Time  `json:"updated_at" url:"updated_at"`
	WebhookID    string     `json:"webhook_id" url:"webhook_id"`

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

func (w *WebhookEventResponseData) GetCreatedAt() time.Time {
	if w == nil {
		return time.Time{}
	}
	return w.CreatedAt
}

func (w *WebhookEventResponseData) GetID() string {
	if w == nil {
		return ""
	}
	return w.ID
}

func (w *WebhookEventResponseData) GetPayload() *string {
	if w == nil {
		return nil
	}
	return w.Payload
}

func (w *WebhookEventResponseData) GetRequestType() string {
	if w == nil {
		return ""
	}
	return w.RequestType
}

func (w *WebhookEventResponseData) GetResponseCode() *int {
	if w == nil {
		return nil
	}
	return w.ResponseCode
}

func (w *WebhookEventResponseData) GetSentAt() *time.Time {
	if w == nil {
		return nil
	}
	return w.SentAt
}

func (w *WebhookEventResponseData) GetStatus() string {
	if w == nil {
		return ""
	}
	return w.Status
}

func (w *WebhookEventResponseData) GetUpdatedAt() time.Time {
	if w == nil {
		return time.Time{}
	}
	return w.UpdatedAt
}

func (w *WebhookEventResponseData) GetWebhookID() string {
	if w == nil {
		return ""
	}
	return w.WebhookID
}

func (w *WebhookEventResponseData) GetExtraProperties() map[string]interface{} {
	return w.extraProperties
}

func (w *WebhookEventResponseData) UnmarshalJSON(data []byte) error {
	type embed WebhookEventResponseData
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		SentAt    *internal.DateTime `json:"sent_at,omitempty"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed: embed(*w),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*w = WebhookEventResponseData(unmarshaler.embed)
	w.CreatedAt = unmarshaler.CreatedAt.Time()
	w.SentAt = unmarshaler.SentAt.TimePtr()
	w.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *w)
	if err != nil {
		return err
	}
	w.extraProperties = extraProperties
	w.rawJSON = json.RawMessage(data)
	return nil
}

func (w *WebhookEventResponseData) MarshalJSON() ([]byte, error) {
	type embed WebhookEventResponseData
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"created_at"`
		SentAt    *internal.DateTime `json:"sent_at,omitempty"`
		UpdatedAt *internal.DateTime `json:"updated_at"`
	}{
		embed:     embed(*w),
		CreatedAt: internal.NewDateTime(w.CreatedAt),
		SentAt:    internal.NewOptionalDateTime(w.SentAt),
		UpdatedAt: internal.NewDateTime(w.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

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