types.go

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

package polytomic

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

type ActivateSyncEnvelope struct {
	Data *ActivateSyncOutput `json:"data,omitempty" url:"data,omitempty"`

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

func (a *ActivateSyncEnvelope) GetData() *ActivateSyncOutput {
	if a == nil {
		return nil
	}
	return a.Data
}

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

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

func (a *ActivateSyncEnvelope) 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 ActivateSyncInput struct {
	Active bool `json:"active" url:"active"`

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

func (a *ActivateSyncInput) GetActive() bool {
	if a == nil {
		return false
	}
	return a.Active
}

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

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

func (a *ActivateSyncInput) 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 ActivateSyncOutput struct {
	Active *bool   `json:"active,omitempty" url:"active,omitempty"`
	Id     *string `json:"id,omitempty" url:"id,omitempty"`

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

func (a *ActivateSyncOutput) GetActive() *bool {
	if a == nil {
		return nil
	}
	return a.Active
}

func (a *ActivateSyncOutput) GetId() *string {
	if a == nil {
		return nil
	}
	return a.Id
}

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

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

func (a *ActivateSyncOutput) 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 ApiError struct {
	Key      *string                `json:"key,omitempty" url:"key,omitempty"`
	Message  *string                `json:"message,omitempty" url:"message,omitempty"`
	Metadata map[string]interface{} `json:"metadata,omitempty" url:"metadata,omitempty"`
	Status   *int                   `json:"status,omitempty" url:"status,omitempty"`

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

func (a *ApiError) GetKey() *string {
	if a == nil {
		return nil
	}
	return a.Key
}

func (a *ApiError) GetMessage() *string {
	if a == nil {
		return nil
	}
	return a.Message
}

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

func (a *ApiError) GetStatus() *int {
	if a == nil {
		return nil
	}
	return a.Status
}

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 BulkBulkSyncSchedule struct {
	CreatedAt     *time.Time            `json:"createdAt,omitempty" url:"createdAt,omitempty"`
	CreatedBy     *string               `json:"createdBy,omitempty" url:"createdBy,omitempty"`
	DayOfMonth    *string               `json:"dayOfMonth,omitempty" url:"dayOfMonth,omitempty"`
	DayOfWeek     *string               `json:"dayOfWeek,omitempty" url:"dayOfWeek,omitempty"`
	DeletedAt     *time.Time            `json:"deletedAt,omitempty" url:"deletedAt,omitempty"`
	DeletedBy     *string               `json:"deletedBy,omitempty" url:"deletedBy,omitempty"`
	Frequency     ScheduleFrequency     `json:"frequency" url:"frequency"`
	Hour          *string               `json:"hour,omitempty" url:"hour,omitempty"`
	IsDefault     *bool                 `json:"isDefault,omitempty" url:"isDefault,omitempty"`
	Minute        *string               `json:"minute,omitempty" url:"minute,omitempty"`
	Month         *string               `json:"month,omitempty" url:"month,omitempty"`
	Schemas       []string              `json:"schemas,omitempty" url:"schemas,omitempty"`
	SelectiveMode *BulkSelectiveMode    `json:"selectiveMode,omitempty" url:"selectiveMode,omitempty"`
	SyncId        *string               `json:"syncId,omitempty" url:"syncId,omitempty"`
	SyncMode      *BulkScheduleSyncMode `json:"syncMode,omitempty" url:"syncMode,omitempty"`
	UpdatedAt     *time.Time            `json:"updatedAt,omitempty" url:"updatedAt,omitempty"`
	UpdatedBy     *string               `json:"updatedBy,omitempty" url:"updatedBy,omitempty"`

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

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

func (b *BulkBulkSyncSchedule) GetCreatedBy() *string {
	if b == nil {
		return nil
	}
	return b.CreatedBy
}

func (b *BulkBulkSyncSchedule) GetDayOfMonth() *string {
	if b == nil {
		return nil
	}
	return b.DayOfMonth
}

func (b *BulkBulkSyncSchedule) GetDayOfWeek() *string {
	if b == nil {
		return nil
	}
	return b.DayOfWeek
}

func (b *BulkBulkSyncSchedule) GetDeletedAt() *time.Time {
	if b == nil {
		return nil
	}
	return b.DeletedAt
}

func (b *BulkBulkSyncSchedule) GetDeletedBy() *string {
	if b == nil {
		return nil
	}
	return b.DeletedBy
}

func (b *BulkBulkSyncSchedule) GetFrequency() ScheduleFrequency {
	if b == nil {
		return ""
	}
	return b.Frequency
}

func (b *BulkBulkSyncSchedule) GetHour() *string {
	if b == nil {
		return nil
	}
	return b.Hour
}

func (b *BulkBulkSyncSchedule) GetIsDefault() *bool {
	if b == nil {
		return nil
	}
	return b.IsDefault
}

func (b *BulkBulkSyncSchedule) GetMinute() *string {
	if b == nil {
		return nil
	}
	return b.Minute
}

func (b *BulkBulkSyncSchedule) GetMonth() *string {
	if b == nil {
		return nil
	}
	return b.Month
}

func (b *BulkBulkSyncSchedule) GetSchemas() []string {
	if b == nil {
		return nil
	}
	return b.Schemas
}

func (b *BulkBulkSyncSchedule) GetSelectiveMode() *BulkSelectiveMode {
	if b == nil {
		return nil
	}
	return b.SelectiveMode
}

func (b *BulkBulkSyncSchedule) GetSyncId() *string {
	if b == nil {
		return nil
	}
	return b.SyncId
}

func (b *BulkBulkSyncSchedule) GetSyncMode() *BulkScheduleSyncMode {
	if b == nil {
		return nil
	}
	return b.SyncMode
}

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

func (b *BulkBulkSyncSchedule) GetUpdatedBy() *string {
	if b == nil {
		return nil
	}
	return b.UpdatedBy
}

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

func (b *BulkBulkSyncSchedule) UnmarshalJSON(data []byte) error {
	type embed BulkBulkSyncSchedule
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"createdAt,omitempty"`
		DeletedAt *internal.DateTime `json:"deletedAt,omitempty"`
		UpdatedAt *internal.DateTime `json:"updatedAt,omitempty"`
	}{
		embed: embed(*b),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*b = BulkBulkSyncSchedule(unmarshaler.embed)
	b.CreatedAt = unmarshaler.CreatedAt.TimePtr()
	b.DeletedAt = unmarshaler.DeletedAt.TimePtr()
	b.UpdatedAt = unmarshaler.UpdatedAt.TimePtr()
	extraProperties, err := internal.ExtractExtraProperties(data, *b)
	if err != nil {
		return err
	}
	b.extraProperties = extraProperties
	b.rawJSON = json.RawMessage(data)
	return nil
}

func (b *BulkBulkSyncSchedule) MarshalJSON() ([]byte, error) {
	type embed BulkBulkSyncSchedule
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"createdAt,omitempty"`
		DeletedAt *internal.DateTime `json:"deletedAt,omitempty"`
		UpdatedAt *internal.DateTime `json:"updatedAt,omitempty"`
	}{
		embed:     embed(*b),
		CreatedAt: internal.NewOptionalDateTime(b.CreatedAt),
		DeletedAt: internal.NewOptionalDateTime(b.DeletedAt),
		UpdatedAt: internal.NewOptionalDateTime(b.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

func (b *BulkBulkSyncSchedule) 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 BulkExecutionStatus string

const (
	BulkExecutionStatusCreated     BulkExecutionStatus = "created"
	BulkExecutionStatusScheduled   BulkExecutionStatus = "scheduled"
	BulkExecutionStatusRunning     BulkExecutionStatus = "running"
	BulkExecutionStatusExporting   BulkExecutionStatus = "exporting"
	BulkExecutionStatusCanceling   BulkExecutionStatus = "canceling"
	BulkExecutionStatusCanceled    BulkExecutionStatus = "canceled"
	BulkExecutionStatusCompleted   BulkExecutionStatus = "completed"
	BulkExecutionStatusFailed      BulkExecutionStatus = "failed"
	BulkExecutionStatusProcessing  BulkExecutionStatus = "processing"
	BulkExecutionStatusErrors      BulkExecutionStatus = "errors"
	BulkExecutionStatusInterrupted BulkExecutionStatus = "interrupted"
)

func NewBulkExecutionStatusFromString(s string) (BulkExecutionStatus, error) {
	switch s {
	case "created":
		return BulkExecutionStatusCreated, nil
	case "scheduled":
		return BulkExecutionStatusScheduled, nil
	case "running":
		return BulkExecutionStatusRunning, nil
	case "exporting":
		return BulkExecutionStatusExporting, nil
	case "canceling":
		return BulkExecutionStatusCanceling, nil
	case "canceled":
		return BulkExecutionStatusCanceled, nil
	case "completed":
		return BulkExecutionStatusCompleted, nil
	case "failed":
		return BulkExecutionStatusFailed, nil
	case "processing":
		return BulkExecutionStatusProcessing, nil
	case "errors":
		return BulkExecutionStatusErrors, nil
	case "interrupted":
		return BulkExecutionStatusInterrupted, nil
	}
	var t BulkExecutionStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (b BulkExecutionStatus) Ptr() *BulkExecutionStatus {
	return &b
}

// How the data is fetched. 'none' is normal operation for Polytomic. 'incremental' and 'full' apply to syncs from Salesforce. 'incremental' indicates the data is synced incrementally using record modification time. 'full' is necessary to catch up to the latest values for formula fields and rollup fields whose updates don't show up in incremental runs due to limitations in Salesforce.
type BulkFetchMode string

const (
	BulkFetchModeNone        BulkFetchMode = "none"
	BulkFetchModeIncremental BulkFetchMode = "incremental"
	BulkFetchModeFull        BulkFetchMode = "full"
)

func NewBulkFetchModeFromString(s string) (BulkFetchMode, error) {
	switch s {
	case "none":
		return BulkFetchModeNone, nil
	case "incremental":
		return BulkFetchModeIncremental, nil
	case "full":
		return BulkFetchModeFull, nil
	}
	var t BulkFetchMode
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (b BulkFetchMode) Ptr() *BulkFetchMode {
	return &b
}

type BulkField struct {
	Enabled        *bool   `json:"enabled,omitempty" url:"enabled,omitempty"`
	Id             *string `json:"id,omitempty" url:"id,omitempty"`
	Obfuscated     *bool   `json:"obfuscated,omitempty" url:"obfuscated,omitempty"`
	OutputName     *string `json:"output_name,omitempty" url:"output_name,omitempty"`
	UserOutputName *string `json:"user_output_name,omitempty" url:"user_output_name,omitempty"`

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

func (b *BulkField) GetEnabled() *bool {
	if b == nil {
		return nil
	}
	return b.Enabled
}

func (b *BulkField) GetId() *string {
	if b == nil {
		return nil
	}
	return b.Id
}

func (b *BulkField) GetObfuscated() *bool {
	if b == nil {
		return nil
	}
	return b.Obfuscated
}

func (b *BulkField) GetOutputName() *string {
	if b == nil {
		return nil
	}
	return b.OutputName
}

func (b *BulkField) GetUserOutputName() *string {
	if b == nil {
		return nil
	}
	return b.UserOutputName
}

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

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

func (b *BulkField) 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 BulkFilter struct {
	// Schema field ID to filter on.
	FieldId  *string        `json:"field_id,omitempty" url:"field_id,omitempty"`
	Function FilterFunction `json:"function" url:"function"`
	Value    interface{}    `json:"value,omitempty" url:"value,omitempty"`

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

func (b *BulkFilter) GetFieldId() *string {
	if b == nil {
		return nil
	}
	return b.FieldId
}

func (b *BulkFilter) GetFunction() FilterFunction {
	if b == nil {
		return ""
	}
	return b.Function
}

func (b *BulkFilter) GetValue() interface{} {
	if b == nil {
		return nil
	}
	return b.Value
}

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

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

func (b *BulkFilter) 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 BulkOutputDisposition string

const (
	BulkOutputDispositionRetain   BulkOutputDisposition = "retain"
	BulkOutputDispositionTruncate BulkOutputDisposition = "truncate"
	BulkOutputDispositionRebuild  BulkOutputDisposition = "rebuild"
)

func NewBulkOutputDispositionFromString(s string) (BulkOutputDisposition, error) {
	switch s {
	case "retain":
		return BulkOutputDispositionRetain, nil
	case "truncate":
		return BulkOutputDispositionTruncate, nil
	case "rebuild":
		return BulkOutputDispositionRebuild, nil
	}
	var t BulkOutputDisposition
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (b BulkOutputDisposition) Ptr() *BulkOutputDisposition {
	return &b
}

type BulkScheduleSyncMode string

const (
	BulkScheduleSyncModeNormal  BulkScheduleSyncMode = "normal"
	BulkScheduleSyncModeRefetch BulkScheduleSyncMode = "refetch"
	BulkScheduleSyncModeResync  BulkScheduleSyncMode = "resync"
	BulkScheduleSyncModeRebuild BulkScheduleSyncMode = "rebuild"
)

func NewBulkScheduleSyncModeFromString(s string) (BulkScheduleSyncMode, error) {
	switch s {
	case "normal":
		return BulkScheduleSyncModeNormal, nil
	case "refetch":
		return BulkScheduleSyncModeRefetch, nil
	case "resync":
		return BulkScheduleSyncModeResync, nil
	case "rebuild":
		return BulkScheduleSyncModeRebuild, nil
	}
	var t BulkScheduleSyncMode
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (b BulkScheduleSyncMode) Ptr() *BulkScheduleSyncMode {
	return &b
}

type BulkSchema struct {
	DataCutoffTimestamp *time.Time `json:"data_cutoff_timestamp,omitempty" url:"data_cutoff_timestamp,omitempty"`
	DisableDataCutoff   *bool      `json:"disable_data_cutoff,omitempty" url:"disable_data_cutoff,omitempty"`
	Enabled             *bool      `json:"enabled,omitempty" url:"enabled,omitempty"`
	// fields is not populated on the list endpoint and will be removed in a future version; retrieve individual schemas for fields.
	Fields []*BulkField `json:"fields,omitempty" url:"fields,omitempty"`
	// filters is not populated on the list endpoint and will be removed in a future version; retrieve individual schemas for filters.
	Filters        []*BulkFilter `json:"filters,omitempty" url:"filters,omitempty"`
	Id             *string       `json:"id,omitempty" url:"id,omitempty"`
	OutputName     *string       `json:"output_name,omitempty" url:"output_name,omitempty"`
	PartitionKey   *string       `json:"partition_key,omitempty" url:"partition_key,omitempty"`
	TrackingField  *string       `json:"tracking_field,omitempty" url:"tracking_field,omitempty"`
	UserOutputName *string       `json:"user_output_name,omitempty" url:"user_output_name,omitempty"`

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

func (b *BulkSchema) GetDataCutoffTimestamp() *time.Time {
	if b == nil {
		return nil
	}
	return b.DataCutoffTimestamp
}

func (b *BulkSchema) GetDisableDataCutoff() *bool {
	if b == nil {
		return nil
	}
	return b.DisableDataCutoff
}

func (b *BulkSchema) GetEnabled() *bool {
	if b == nil {
		return nil
	}
	return b.Enabled
}

func (b *BulkSchema) GetFields() []*BulkField {
	if b == nil {
		return nil
	}
	return b.Fields
}

func (b *BulkSchema) GetFilters() []*BulkFilter {
	if b == nil {
		return nil
	}
	return b.Filters
}

func (b *BulkSchema) GetId() *string {
	if b == nil {
		return nil
	}
	return b.Id
}

func (b *BulkSchema) GetOutputName() *string {
	if b == nil {
		return nil
	}
	return b.OutputName
}

func (b *BulkSchema) GetPartitionKey() *string {
	if b == nil {
		return nil
	}
	return b.PartitionKey
}

func (b *BulkSchema) GetTrackingField() *string {
	if b == nil {
		return nil
	}
	return b.TrackingField
}

func (b *BulkSchema) GetUserOutputName() *string {
	if b == nil {
		return nil
	}
	return b.UserOutputName
}

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

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

func (b *BulkSchema) MarshalJSON() ([]byte, error) {
	type embed BulkSchema
	var marshaler = struct {
		embed
		DataCutoffTimestamp *internal.DateTime `json:"data_cutoff_timestamp,omitempty"`
	}{
		embed:               embed(*b),
		DataCutoffTimestamp: internal.NewOptionalDateTime(b.DataCutoffTimestamp),
	}
	return json.Marshal(marshaler)
}

func (b *BulkSchema) 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 BulkSchemaEnvelope struct {
	Data *BulkSchema `json:"data,omitempty" url:"data,omitempty"`

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

func (b *BulkSchemaEnvelope) GetData() *BulkSchema {
	if b == nil {
		return nil
	}
	return b.Data
}

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

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

func (b *BulkSchemaEnvelope) 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 BulkSchemaExecutionStatus string

const (
	BulkSchemaExecutionStatusCreated     BulkSchemaExecutionStatus = "created"
	BulkSchemaExecutionStatusScheduled   BulkSchemaExecutionStatus = "scheduled"
	BulkSchemaExecutionStatusRunning     BulkSchemaExecutionStatus = "running"
	BulkSchemaExecutionStatusExporting   BulkSchemaExecutionStatus = "exporting"
	BulkSchemaExecutionStatusCanceled    BulkSchemaExecutionStatus = "canceled"
	BulkSchemaExecutionStatusCompleted   BulkSchemaExecutionStatus = "completed"
	BulkSchemaExecutionStatusFailed      BulkSchemaExecutionStatus = "failed"
	BulkSchemaExecutionStatusInterrupted BulkSchemaExecutionStatus = "interrupted"
	BulkSchemaExecutionStatusProcessing  BulkSchemaExecutionStatus = "processing"
)

func NewBulkSchemaExecutionStatusFromString(s string) (BulkSchemaExecutionStatus, error) {
	switch s {
	case "created":
		return BulkSchemaExecutionStatusCreated, nil
	case "scheduled":
		return BulkSchemaExecutionStatusScheduled, nil
	case "running":
		return BulkSchemaExecutionStatusRunning, nil
	case "exporting":
		return BulkSchemaExecutionStatusExporting, nil
	case "canceled":
		return BulkSchemaExecutionStatusCanceled, nil
	case "completed":
		return BulkSchemaExecutionStatusCompleted, nil
	case "failed":
		return BulkSchemaExecutionStatusFailed, nil
	case "interrupted":
		return BulkSchemaExecutionStatusInterrupted, nil
	case "processing":
		return BulkSchemaExecutionStatusProcessing, nil
	}
	var t BulkSchemaExecutionStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (b BulkSchemaExecutionStatus) Ptr() *BulkSchemaExecutionStatus {
	return &b
}

type BulkSelectiveMode string

const (
	BulkSelectiveModeNone                 BulkSelectiveMode = "none"
	BulkSelectiveModeIncrementalFields    BulkSelectiveMode = "incrementalFields"
	BulkSelectiveModeNonincrementalFields BulkSelectiveMode = "nonincrementalFields"
)

func NewBulkSelectiveModeFromString(s string) (BulkSelectiveMode, error) {
	switch s {
	case "none":
		return BulkSelectiveModeNone, nil
	case "incrementalFields":
		return BulkSelectiveModeIncrementalFields, nil
	case "nonincrementalFields":
		return BulkSelectiveModeNonincrementalFields, nil
	}
	var t BulkSelectiveMode
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (b BulkSelectiveMode) Ptr() *BulkSelectiveMode {
	return &b
}

type BulkSyncExecution struct {
	CompletedAt       *time.Time                 `json:"completed_at,omitempty" url:"completed_at,omitempty"`
	CreatedAt         *time.Time                 `json:"created_at,omitempty" url:"created_at,omitempty"`
	ErrorCount        *int                       `json:"error_count,omitempty" url:"error_count,omitempty"`
	FetchMode         *BulkFetchMode             `json:"fetch_mode,omitempty" url:"fetch_mode,omitempty"`
	Id                *string                    `json:"id,omitempty" url:"id,omitempty"`
	IsPartial         *bool                      `json:"is_partial,omitempty" url:"is_partial,omitempty"`
	IsResync          *bool                      `json:"is_resync,omitempty" url:"is_resync,omitempty"`
	IsTest            *bool                      `json:"is_test,omitempty" url:"is_test,omitempty"`
	OutputDisposition *BulkOutputDisposition     `json:"output_disposition,omitempty" url:"output_disposition,omitempty"`
	RecordCount       *int                       `json:"record_count,omitempty" url:"record_count,omitempty"`
	Schemas           []*BulkSyncSchemaExecution `json:"schemas,omitempty" url:"schemas,omitempty"`
	StartedAt         *time.Time                 `json:"started_at,omitempty" url:"started_at,omitempty"`
	Status            *BulkExecutionStatus       `json:"status,omitempty" url:"status,omitempty"`
	StatusMessage     *string                    `json:"status_message,omitempty" url:"status_message,omitempty"`
	Type              *string                    `json:"type,omitempty" url:"type,omitempty"`
	UpdatedAt         *time.Time                 `json:"updated_at,omitempty" url:"updated_at,omitempty"`
	WarningCount      *int                       `json:"warning_count,omitempty" url:"warning_count,omitempty"`

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

func (b *BulkSyncExecution) GetCompletedAt() *time.Time {
	if b == nil {
		return nil
	}
	return b.CompletedAt
}

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

func (b *BulkSyncExecution) GetErrorCount() *int {
	if b == nil {
		return nil
	}
	return b.ErrorCount
}

func (b *BulkSyncExecution) GetFetchMode() *BulkFetchMode {
	if b == nil {
		return nil
	}
	return b.FetchMode
}

func (b *BulkSyncExecution) GetId() *string {
	if b == nil {
		return nil
	}
	return b.Id
}

func (b *BulkSyncExecution) GetIsPartial() *bool {
	if b == nil {
		return nil
	}
	return b.IsPartial
}

func (b *BulkSyncExecution) GetIsResync() *bool {
	if b == nil {
		return nil
	}
	return b.IsResync
}

func (b *BulkSyncExecution) GetIsTest() *bool {
	if b == nil {
		return nil
	}
	return b.IsTest
}

func (b *BulkSyncExecution) GetOutputDisposition() *BulkOutputDisposition {
	if b == nil {
		return nil
	}
	return b.OutputDisposition
}

func (b *BulkSyncExecution) GetRecordCount() *int {
	if b == nil {
		return nil
	}
	return b.RecordCount
}

func (b *BulkSyncExecution) GetSchemas() []*BulkSyncSchemaExecution {
	if b == nil {
		return nil
	}
	return b.Schemas
}

func (b *BulkSyncExecution) GetStartedAt() *time.Time {
	if b == nil {
		return nil
	}
	return b.StartedAt
}

func (b *BulkSyncExecution) GetStatus() *BulkExecutionStatus {
	if b == nil {
		return nil
	}
	return b.Status
}

func (b *BulkSyncExecution) GetStatusMessage() *string {
	if b == nil {
		return nil
	}
	return b.StatusMessage
}

func (b *BulkSyncExecution) GetType() *string {
	if b == nil {
		return nil
	}
	return b.Type
}

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

func (b *BulkSyncExecution) GetWarningCount() *int {
	if b == nil {
		return nil
	}
	return b.WarningCount
}

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

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

func (b *BulkSyncExecution) MarshalJSON() ([]byte, error) {
	type embed BulkSyncExecution
	var marshaler = struct {
		embed
		CompletedAt *internal.DateTime `json:"completed_at,omitempty"`
		CreatedAt   *internal.DateTime `json:"created_at,omitempty"`
		StartedAt   *internal.DateTime `json:"started_at,omitempty"`
		UpdatedAt   *internal.DateTime `json:"updated_at,omitempty"`
	}{
		embed:       embed(*b),
		CompletedAt: internal.NewOptionalDateTime(b.CompletedAt),
		CreatedAt:   internal.NewOptionalDateTime(b.CreatedAt),
		StartedAt:   internal.NewOptionalDateTime(b.StartedAt),
		UpdatedAt:   internal.NewOptionalDateTime(b.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

func (b *BulkSyncExecution) 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 BulkSyncExecutionEnvelope struct {
	Data *BulkSyncExecution `json:"data,omitempty" url:"data,omitempty"`

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

func (b *BulkSyncExecutionEnvelope) GetData() *BulkSyncExecution {
	if b == nil {
		return nil
	}
	return b.Data
}

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

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

func (b *BulkSyncExecutionEnvelope) 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 BulkSyncExecutionStatus struct {
	// Next scheduled execution time, if the sync has a schedule configured.
	NextExecutionTime *time.Time `json:"nextExecutionTime,omitempty" url:"nextExecutionTime,omitempty"`
	// Most recent execution status for each enabled schema in the sync.
	Schemas []*BulkSyncSchemaExecutionStatus `json:"schemas,omitempty" url:"schemas,omitempty"`
	Status  *BulkExecutionStatus             `json:"status,omitempty" url:"status,omitempty"`
	// Unique identifier of the bulk sync.
	SyncId *string `json:"sync_id,omitempty" url:"sync_id,omitempty"`

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

func (b *BulkSyncExecutionStatus) GetNextExecutionTime() *time.Time {
	if b == nil {
		return nil
	}
	return b.NextExecutionTime
}

func (b *BulkSyncExecutionStatus) GetSchemas() []*BulkSyncSchemaExecutionStatus {
	if b == nil {
		return nil
	}
	return b.Schemas
}

func (b *BulkSyncExecutionStatus) GetStatus() *BulkExecutionStatus {
	if b == nil {
		return nil
	}
	return b.Status
}

func (b *BulkSyncExecutionStatus) GetSyncId() *string {
	if b == nil {
		return nil
	}
	return b.SyncId
}

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

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

func (b *BulkSyncExecutionStatus) MarshalJSON() ([]byte, error) {
	type embed BulkSyncExecutionStatus
	var marshaler = struct {
		embed
		NextExecutionTime *internal.DateTime `json:"nextExecutionTime,omitempty"`
	}{
		embed:             embed(*b),
		NextExecutionTime: internal.NewOptionalDateTime(b.NextExecutionTime),
	}
	return json.Marshal(marshaler)
}

func (b *BulkSyncExecutionStatus) 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 BulkSyncSchemaExecution struct {
	CompletedAt   *time.Time                 `json:"completed_at,omitempty" url:"completed_at,omitempty"`
	CreatedAt     *time.Time                 `json:"created_at,omitempty" url:"created_at,omitempty"`
	ErrorCount    *int                       `json:"error_count,omitempty" url:"error_count,omitempty"`
	OutputName    *string                    `json:"output_name,omitempty" url:"output_name,omitempty"`
	RecordCount   *int                       `json:"record_count,omitempty" url:"record_count,omitempty"`
	Schema        *string                    `json:"schema,omitempty" url:"schema,omitempty"`
	StartedAt     *time.Time                 `json:"started_at,omitempty" url:"started_at,omitempty"`
	Status        *BulkSchemaExecutionStatus `json:"status,omitempty" url:"status,omitempty"`
	StatusMessage *string                    `json:"status_message,omitempty" url:"status_message,omitempty"`
	UpdatedAt     *time.Time                 `json:"updated_at,omitempty" url:"updated_at,omitempty"`
	WarningCount  *int                       `json:"warning_count,omitempty" url:"warning_count,omitempty"`

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

func (b *BulkSyncSchemaExecution) GetCompletedAt() *time.Time {
	if b == nil {
		return nil
	}
	return b.CompletedAt
}

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

func (b *BulkSyncSchemaExecution) GetErrorCount() *int {
	if b == nil {
		return nil
	}
	return b.ErrorCount
}

func (b *BulkSyncSchemaExecution) GetOutputName() *string {
	if b == nil {
		return nil
	}
	return b.OutputName
}

func (b *BulkSyncSchemaExecution) GetRecordCount() *int {
	if b == nil {
		return nil
	}
	return b.RecordCount
}

func (b *BulkSyncSchemaExecution) GetSchema() *string {
	if b == nil {
		return nil
	}
	return b.Schema
}

func (b *BulkSyncSchemaExecution) GetStartedAt() *time.Time {
	if b == nil {
		return nil
	}
	return b.StartedAt
}

func (b *BulkSyncSchemaExecution) GetStatus() *BulkSchemaExecutionStatus {
	if b == nil {
		return nil
	}
	return b.Status
}

func (b *BulkSyncSchemaExecution) GetStatusMessage() *string {
	if b == nil {
		return nil
	}
	return b.StatusMessage
}

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

func (b *BulkSyncSchemaExecution) GetWarningCount() *int {
	if b == nil {
		return nil
	}
	return b.WarningCount
}

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

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

func (b *BulkSyncSchemaExecution) MarshalJSON() ([]byte, error) {
	type embed BulkSyncSchemaExecution
	var marshaler = struct {
		embed
		CompletedAt *internal.DateTime `json:"completed_at,omitempty"`
		CreatedAt   *internal.DateTime `json:"created_at,omitempty"`
		StartedAt   *internal.DateTime `json:"started_at,omitempty"`
		UpdatedAt   *internal.DateTime `json:"updated_at,omitempty"`
	}{
		embed:       embed(*b),
		CompletedAt: internal.NewOptionalDateTime(b.CompletedAt),
		CreatedAt:   internal.NewOptionalDateTime(b.CreatedAt),
		StartedAt:   internal.NewOptionalDateTime(b.StartedAt),
		UpdatedAt:   internal.NewOptionalDateTime(b.UpdatedAt),
	}
	return json.Marshal(marshaler)
}

func (b *BulkSyncSchemaExecution) 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 BulkSyncSchemaExecutionStatus struct {
	// Timestamp when the most recent execution finished. Null while the execution is still running.
	CompletedAt *time.Time `json:"completed_at,omitempty" url:"completed_at,omitempty"`
	// Number of errors emitted during the most recent execution.
	ErrorCount *int `json:"error_count,omitempty" url:"error_count,omitempty"`
	// ID of the most recent execution for the schema.
	ExecutionId *string `json:"execution_id,omitempty" url:"execution_id,omitempty"`
	// Number of records processed in the most recent execution.
	RecordCount *int `json:"record_count,omitempty" url:"record_count,omitempty"`
	// Schema (table or object) identifier.
	Schema *string `json:"schema,omitempty" url:"schema,omitempty"`
	// Timestamp when the most recent execution started.
	StartedAt *time.Time                 `json:"started_at,omitempty" url:"started_at,omitempty"`
	Status    *BulkSchemaExecutionStatus `json:"status,omitempty" url:"status,omitempty"`
	// Human-readable detail for the current status (e.g. an error message when status is failed).
	StatusMessage *string `json:"status_message,omitempty" url:"status_message,omitempty"`
	// Number of warnings emitted during the most recent execution.
	WarningCount *int `json:"warning_count,omitempty" url:"warning_count,omitempty"`

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

func (b *BulkSyncSchemaExecutionStatus) GetCompletedAt() *time.Time {
	if b == nil {
		return nil
	}
	return b.CompletedAt
}

func (b *BulkSyncSchemaExecutionStatus) GetErrorCount() *int {
	if b == nil {
		return nil
	}
	return b.ErrorCount
}

func (b *BulkSyncSchemaExecutionStatus) GetExecutionId() *string {
	if b == nil {
		return nil
	}
	return b.ExecutionId
}

func (b *BulkSyncSchemaExecutionStatus) GetRecordCount() *int {
	if b == nil {
		return nil
	}
	return b.RecordCount
}

func (b *BulkSyncSchemaExecutionStatus) GetSchema() *string {
	if b == nil {
		return nil
	}
	return b.Schema
}

func (b *BulkSyncSchemaExecutionStatus) GetStartedAt() *time.Time {
	if b == nil {
		return nil
	}
	return b.StartedAt
}

func (b *BulkSyncSchemaExecutionStatus) GetStatus() *BulkSchemaExecutionStatus {
	if b == nil {
		return nil
	}
	return b.Status
}

func (b *BulkSyncSchemaExecutionStatus) GetStatusMessage() *string {
	if b == nil {
		return nil
	}
	return b.StatusMessage
}

func (b *BulkSyncSchemaExecutionStatus) GetWarningCount() *int {
	if b == nil {
		return nil
	}
	return b.WarningCount
}

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

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

func (b *BulkSyncSchemaExecutionStatus) MarshalJSON() ([]byte, error) {
	type embed BulkSyncSchemaExecutionStatus
	var marshaler = struct {
		embed
		CompletedAt *internal.DateTime `json:"completed_at,omitempty"`
		StartedAt   *internal.DateTime `json:"started_at,omitempty"`
	}{
		embed:       embed(*b),
		CompletedAt: internal.NewOptionalDateTime(b.CompletedAt),
		StartedAt:   internal.NewOptionalDateTime(b.StartedAt),
	}
	return json.Marshal(marshaler)
}

func (b *BulkSyncSchemaExecutionStatus) 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 CancelBulkSyncResponse struct {
	Message *string `json:"message,omitempty" url:"message,omitempty"`

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

func (c *CancelBulkSyncResponse) GetMessage() *string {
	if c == nil {
		return nil
	}
	return c.Message
}

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

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

func (c *CancelBulkSyncResponse) 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 CancelBulkSyncResponseEnvelope struct {
	Data *CancelBulkSyncResponse `json:"data,omitempty" url:"data,omitempty"`

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

func (c *CancelBulkSyncResponseEnvelope) GetData() *CancelBulkSyncResponse {
	if c == nil {
		return nil
	}
	return c.Data
}

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

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

func (c *CancelBulkSyncResponseEnvelope) 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 ConfigurationValue struct {
	Items []interface{} `json:"items,omitempty" url:"items,omitempty"`
	Type  *string       `json:"type,omitempty" url:"type,omitempty"`

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

func (c *ConfigurationValue) GetItems() []interface{} {
	if c == nil {
		return nil
	}
	return c.Items
}

func (c *ConfigurationValue) GetType() *string {
	if c == nil {
		return nil
	}
	return c.Type
}

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

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

func (c *ConfigurationValue) 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 ConnectionMeta struct {
	HasItems      *bool         `json:"has_items,omitempty" url:"has_items,omitempty"`
	Items         []interface{} `json:"items,omitempty" url:"items,omitempty"`
	RequiresOneOf []string      `json:"requires_one_of,omitempty" url:"requires_one_of,omitempty"`

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

func (c *ConnectionMeta) GetHasItems() *bool {
	if c == nil {
		return nil
	}
	return c.HasItems
}

func (c *ConnectionMeta) GetItems() []interface{} {
	if c == nil {
		return nil
	}
	return c.Items
}

func (c *ConnectionMeta) GetRequiresOneOf() []string {
	if c == nil {
		return nil
	}
	return c.RequiresOneOf
}

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

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

func (c *ConnectionMeta) 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 ConnectionMetaResponse struct {
	Configuration map[string]*ConfigurationValue `json:"configuration,omitempty" url:"configuration,omitempty"`
	Items         map[string]*ConnectionMeta     `json:"items,omitempty" url:"items,omitempty"`
	RequiresOneOf []string                       `json:"requires_one_of,omitempty" url:"requires_one_of,omitempty"`

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

func (c *ConnectionMetaResponse) GetConfiguration() map[string]*ConfigurationValue {
	if c == nil {
		return nil
	}
	return c.Configuration
}

func (c *ConnectionMetaResponse) GetItems() map[string]*ConnectionMeta {
	if c == nil {
		return nil
	}
	return c.Items
}

func (c *ConnectionMetaResponse) GetRequiresOneOf() []string {
	if c == nil {
		return nil
	}
	return c.RequiresOneOf
}

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

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

func (c *ConnectionMetaResponse) 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 ExecutionCounts struct {
	Delete   *int `json:"delete,omitempty" url:"delete,omitempty"`
	Error    *int `json:"error,omitempty" url:"error,omitempty"`
	Insert   *int `json:"insert,omitempty" url:"insert,omitempty"`
	Total    *int `json:"total,omitempty" url:"total,omitempty"`
	Update   *int `json:"update,omitempty" url:"update,omitempty"`
	Upserts  *int `json:"upserts,omitempty" url:"upserts,omitempty"`
	Warnings *int `json:"warnings,omitempty" url:"warnings,omitempty"`

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

func (e *ExecutionCounts) GetDelete() *int {
	if e == nil {
		return nil
	}
	return e.Delete
}

func (e *ExecutionCounts) GetError() *int {
	if e == nil {
		return nil
	}
	return e.Error
}

func (e *ExecutionCounts) GetInsert() *int {
	if e == nil {
		return nil
	}
	return e.Insert
}

func (e *ExecutionCounts) GetTotal() *int {
	if e == nil {
		return nil
	}
	return e.Total
}

func (e *ExecutionCounts) GetUpdate() *int {
	if e == nil {
		return nil
	}
	return e.Update
}

func (e *ExecutionCounts) GetUpserts() *int {
	if e == nil {
		return nil
	}
	return e.Upserts
}

func (e *ExecutionCounts) GetWarnings() *int {
	if e == nil {
		return nil
	}
	return e.Warnings
}

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

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

func (e *ExecutionCounts) 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 ExecutionLogResponse struct {
	Expires *time.Time `json:"expires,omitempty" url:"expires,omitempty"`
	Urls    []string   `json:"urls,omitempty" url:"urls,omitempty"`

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

func (e *ExecutionLogResponse) GetExpires() *time.Time {
	if e == nil {
		return nil
	}
	return e.Expires
}

func (e *ExecutionLogResponse) GetUrls() []string {
	if e == nil {
		return nil
	}
	return e.Urls
}

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

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

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

func (e *ExecutionLogResponse) 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 ExecutionLogsResponseEnvelope struct {
	Data *ExecutionLogResponse `json:"data,omitempty" url:"data,omitempty"`

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

func (e *ExecutionLogsResponseEnvelope) GetData() *ExecutionLogResponse {
	if e == nil {
		return nil
	}
	return e.Data
}

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

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

func (e *ExecutionLogsResponseEnvelope) 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 ExecutionStatus string

const (
	ExecutionStatusCreated     ExecutionStatus = "created"
	ExecutionStatusScheduled   ExecutionStatus = "scheduled"
	ExecutionStatusQueued      ExecutionStatus = "queued"
	ExecutionStatusWaiting     ExecutionStatus = "waiting"
	ExecutionStatusRunning     ExecutionStatus = "running"
	ExecutionStatusProcessing  ExecutionStatus = "processing"
	ExecutionStatusCanceling   ExecutionStatus = "canceling"
	ExecutionStatusCanceled    ExecutionStatus = "canceled"
	ExecutionStatusCompleted   ExecutionStatus = "completed"
	ExecutionStatusFailed      ExecutionStatus = "failed"
	ExecutionStatusInterrupted ExecutionStatus = "interrupted"
)

func NewExecutionStatusFromString(s string) (ExecutionStatus, error) {
	switch s {
	case "created":
		return ExecutionStatusCreated, nil
	case "scheduled":
		return ExecutionStatusScheduled, nil
	case "queued":
		return ExecutionStatusQueued, nil
	case "waiting":
		return ExecutionStatusWaiting, nil
	case "running":
		return ExecutionStatusRunning, nil
	case "processing":
		return ExecutionStatusProcessing, nil
	case "canceling":
		return ExecutionStatusCanceling, nil
	case "canceled":
		return ExecutionStatusCanceled, nil
	case "completed":
		return ExecutionStatusCompleted, nil
	case "failed":
		return ExecutionStatusFailed, nil
	case "interrupted":
		return ExecutionStatusInterrupted, nil
	}
	var t ExecutionStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (e ExecutionStatus) Ptr() *ExecutionStatus {
	return &e
}

type FilterFunction string

const (
	FilterFunctionEquality               FilterFunction = "Equality"
	FilterFunctionInequality             FilterFunction = "Inequality"
	FilterFunctionIsNull                 FilterFunction = "IsNull"
	FilterFunctionIsNotNull              FilterFunction = "IsNotNull"
	FilterFunctionTrue                   FilterFunction = "True"
	FilterFunctionFalse                  FilterFunction = "False"
	FilterFunctionOnOrAfter              FilterFunction = "OnOrAfter"
	FilterFunctionOnOrBefore             FilterFunction = "OnOrBefore"
	FilterFunctionGreaterThan            FilterFunction = "GreaterThan"
	FilterFunctionGreaterThanEqual       FilterFunction = "GreaterThanEqual"
	FilterFunctionLessThan               FilterFunction = "LessThan"
	FilterFunctionLessThanEqual          FilterFunction = "LessThanEqual"
	FilterFunctionStringContains         FilterFunction = "StringContains"
	FilterFunctionStringStartsWith       FilterFunction = "StringStartsWith"
	FilterFunctionStringEndsWith         FilterFunction = "StringEndsWith"
	FilterFunctionStringDoesNotContain   FilterFunction = "StringDoesNotContain"
	FilterFunctionStringDoesNotStartWith FilterFunction = "StringDoesNotStartWith"
	FilterFunctionStringDoesNotEndWith   FilterFunction = "StringDoesNotEndWith"
	FilterFunctionStringOneOf            FilterFunction = "StringOneOf"
	FilterFunctionStringNotOneOf         FilterFunction = "StringNotOneOf"
	FilterFunctionBetween                FilterFunction = "Between"
	FilterFunctionArrayContains          FilterFunction = "ArrayContains"
	FilterFunctionArrayDoesNotContain    FilterFunction = "ArrayDoesNotContain"
	FilterFunctionInTheLast              FilterFunction = "InTheLast"
	FilterFunctionRelativeOnOrBefore     FilterFunction = "RelativeOnOrBefore"
	FilterFunctionRelativeOnOrAfter      FilterFunction = "RelativeOnOrAfter"
	FilterFunctionStringLike             FilterFunction = "StringLike"
	FilterFunctionStringNotLike          FilterFunction = "StringNotLike"
	FilterFunctionStringMatchesTrimmed   FilterFunction = "StringMatchesTrimmed"
)

func NewFilterFunctionFromString(s string) (FilterFunction, error) {
	switch s {
	case "Equality":
		return FilterFunctionEquality, nil
	case "Inequality":
		return FilterFunctionInequality, nil
	case "IsNull":
		return FilterFunctionIsNull, nil
	case "IsNotNull":
		return FilterFunctionIsNotNull, nil
	case "True":
		return FilterFunctionTrue, nil
	case "False":
		return FilterFunctionFalse, nil
	case "OnOrAfter":
		return FilterFunctionOnOrAfter, nil
	case "OnOrBefore":
		return FilterFunctionOnOrBefore, nil
	case "GreaterThan":
		return FilterFunctionGreaterThan, nil
	case "GreaterThanEqual":
		return FilterFunctionGreaterThanEqual, nil
	case "LessThan":
		return FilterFunctionLessThan, nil
	case "LessThanEqual":
		return FilterFunctionLessThanEqual, nil
	case "StringContains":
		return FilterFunctionStringContains, nil
	case "StringStartsWith":
		return FilterFunctionStringStartsWith, nil
	case "StringEndsWith":
		return FilterFunctionStringEndsWith, nil
	case "StringDoesNotContain":
		return FilterFunctionStringDoesNotContain, nil
	case "StringDoesNotStartWith":
		return FilterFunctionStringDoesNotStartWith, nil
	case "StringDoesNotEndWith":
		return FilterFunctionStringDoesNotEndWith, nil
	case "StringOneOf":
		return FilterFunctionStringOneOf, nil
	case "StringNotOneOf":
		return FilterFunctionStringNotOneOf, nil
	case "Between":
		return FilterFunctionBetween, nil
	case "ArrayContains":
		return FilterFunctionArrayContains, nil
	case "ArrayDoesNotContain":
		return FilterFunctionArrayDoesNotContain, nil
	case "InTheLast":
		return FilterFunctionInTheLast, nil
	case "RelativeOnOrBefore":
		return FilterFunctionRelativeOnOrBefore, nil
	case "RelativeOnOrAfter":
		return FilterFunctionRelativeOnOrAfter, nil
	case "StringLike":
		return FilterFunctionStringLike, nil
	case "StringNotLike":
		return FilterFunctionStringNotLike, nil
	case "StringMatchesTrimmed":
		return FilterFunctionStringMatchesTrimmed, nil
	}
	var t FilterFunction
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type GetConnectionMetaEnvelope struct {
	Data *ConnectionMetaResponse `json:"data,omitempty" url:"data,omitempty"`

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

func (g *GetConnectionMetaEnvelope) GetData() *ConnectionMetaResponse {
	if g == nil {
		return nil
	}
	return g.Data
}

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

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

func (g *GetConnectionMetaEnvelope) 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 GetExecutionResponseEnvelope struct {
	Data *GetExecutionResponseSchema `json:"data,omitempty" url:"data,omitempty"`

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

func (g *GetExecutionResponseEnvelope) GetData() *GetExecutionResponseSchema {
	if g == nil {
		return nil
	}
	return g.Data
}

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

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

func (g *GetExecutionResponseEnvelope) 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 GetExecutionResponseSchema struct {
	CompletedAt *time.Time       `json:"completed_at,omitempty" url:"completed_at,omitempty"`
	Counts      *ExecutionCounts `json:"counts,omitempty" url:"counts,omitempty"`
	CreatedAt   *time.Time       `json:"created_at,omitempty" url:"created_at,omitempty"`
	Errors      []string         `json:"errors,omitempty" url:"errors,omitempty"`
	Id          *string          `json:"id,omitempty" url:"id,omitempty"`
	StartedAt   *time.Time       `json:"started_at,omitempty" url:"started_at,omitempty"`
	Status      *ExecutionStatus `json:"status,omitempty" url:"status,omitempty"`
	Type        *string          `json:"type,omitempty" url:"type,omitempty"`

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

func (g *GetExecutionResponseSchema) GetCompletedAt() *time.Time {
	if g == nil {
		return nil
	}
	return g.CompletedAt
}

func (g *GetExecutionResponseSchema) GetCounts() *ExecutionCounts {
	if g == nil {
		return nil
	}
	return g.Counts
}

func (g *GetExecutionResponseSchema) GetCreatedAt() *time.Time {
	if g == nil {
		return nil
	}
	return g.CreatedAt
}

func (g *GetExecutionResponseSchema) GetErrors() []string {
	if g == nil {
		return nil
	}
	return g.Errors
}

func (g *GetExecutionResponseSchema) GetId() *string {
	if g == nil {
		return nil
	}
	return g.Id
}

func (g *GetExecutionResponseSchema) GetStartedAt() *time.Time {
	if g == nil {
		return nil
	}
	return g.StartedAt
}

func (g *GetExecutionResponseSchema) GetStatus() *ExecutionStatus {
	if g == nil {
		return nil
	}
	return g.Status
}

func (g *GetExecutionResponseSchema) GetType() *string {
	if g == nil {
		return nil
	}
	return g.Type
}

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

func (g *GetExecutionResponseSchema) UnmarshalJSON(data []byte) error {
	type embed GetExecutionResponseSchema
	var unmarshaler = struct {
		embed
		CompletedAt *internal.DateTime `json:"completed_at,omitempty"`
		CreatedAt   *internal.DateTime `json:"created_at,omitempty"`
		StartedAt   *internal.DateTime `json:"started_at,omitempty"`
	}{
		embed: embed(*g),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*g = GetExecutionResponseSchema(unmarshaler.embed)
	g.CompletedAt = unmarshaler.CompletedAt.TimePtr()
	g.CreatedAt = unmarshaler.CreatedAt.TimePtr()
	g.StartedAt = unmarshaler.StartedAt.TimePtr()
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GetExecutionResponseSchema) MarshalJSON() ([]byte, error) {
	type embed GetExecutionResponseSchema
	var marshaler = struct {
		embed
		CompletedAt *internal.DateTime `json:"completed_at,omitempty"`
		CreatedAt   *internal.DateTime `json:"created_at,omitempty"`
		StartedAt   *internal.DateTime `json:"started_at,omitempty"`
	}{
		embed:       embed(*g),
		CompletedAt: internal.NewOptionalDateTime(g.CompletedAt),
		CreatedAt:   internal.NewOptionalDateTime(g.CreatedAt),
		StartedAt:   internal.NewOptionalDateTime(g.StartedAt),
	}
	return json.Marshal(marshaler)
}

func (g *GetExecutionResponseSchema) 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 GetModelSyncSourceMetaEnvelope struct {
	Data *ModelSyncSourceMetaResponse `json:"data,omitempty" url:"data,omitempty"`

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

func (g *GetModelSyncSourceMetaEnvelope) GetData() *ModelSyncSourceMetaResponse {
	if g == nil {
		return nil
	}
	return g.Data
}

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

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

func (g *GetModelSyncSourceMetaEnvelope) 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 IdentityFunction struct {
	Id    *string `json:"id,omitempty" url:"id,omitempty"`
	Label *string `json:"label,omitempty" url:"label,omitempty"`

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

func (i *IdentityFunction) GetId() *string {
	if i == nil {
		return nil
	}
	return i.Id
}

func (i *IdentityFunction) GetLabel() *string {
	if i == nil {
		return nil
	}
	return i.Label
}

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

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

func (i *IdentityFunction) 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 JobResponse struct {
	// Error message if the job failed.
	Error *string `json:"error,omitempty" url:"error,omitempty"`
	// Identifier of the job.
	JobId *string `json:"job_id,omitempty" url:"job_id,omitempty"`
	// Job result. Shape depends on the job type; only populated once status is done.
	Result interface{}     `json:"result,omitempty" url:"result,omitempty"`
	Status *WorkTaskStatus `json:"status,omitempty" url:"status,omitempty"`
	// Job type. Matches the type used to fetch the job.
	Type *string `json:"type,omitempty" url:"type,omitempty"`

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

func (j *JobResponse) GetError() *string {
	if j == nil {
		return nil
	}
	return j.Error
}

func (j *JobResponse) GetJobId() *string {
	if j == nil {
		return nil
	}
	return j.JobId
}

func (j *JobResponse) GetResult() interface{} {
	if j == nil {
		return nil
	}
	return j.Result
}

func (j *JobResponse) GetStatus() *WorkTaskStatus {
	if j == nil {
		return nil
	}
	return j.Status
}

func (j *JobResponse) GetType() *string {
	if j == nil {
		return nil
	}
	return j.Type
}

func (j *JobResponse) GetExtraProperties() map[string]interface{} {
	return j.extraProperties
}

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

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

type ListBulkSchema struct {
	Data []*BulkSchema `json:"data,omitempty" url:"data,omitempty"`

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

func (l *ListBulkSchema) GetData() []*BulkSchema {
	if l == nil {
		return nil
	}
	return l.Data
}

func (l *ListBulkSchema) GetExtraProperties() map[string]interface{} {
	return l.extraProperties
}

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

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

type ListBulkSyncExecutionStatusEnvelope struct {
	Data []*BulkSyncExecutionStatus `json:"data,omitempty" url:"data,omitempty"`

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

func (l *ListBulkSyncExecutionStatusEnvelope) GetData() []*BulkSyncExecutionStatus {
	if l == nil {
		return nil
	}
	return l.Data
}

func (l *ListBulkSyncExecutionStatusEnvelope) GetExtraProperties() map[string]interface{} {
	return l.extraProperties
}

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

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

type ListBulkSyncExecutionsEnvelope struct {
	Data       []*BulkSyncExecution `json:"data,omitempty" url:"data,omitempty"`
	Pagination *PaginationDetails   `json:"pagination,omitempty" url:"pagination,omitempty"`

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

func (l *ListBulkSyncExecutionsEnvelope) GetData() []*BulkSyncExecution {
	if l == nil {
		return nil
	}
	return l.Data
}

func (l *ListBulkSyncExecutionsEnvelope) GetPagination() *PaginationDetails {
	if l == nil {
		return nil
	}
	return l.Pagination
}

func (l *ListBulkSyncExecutionsEnvelope) GetExtraProperties() map[string]interface{} {
	return l.extraProperties
}

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

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

type ListExecutionResponseEnvelope struct {
	Data       []*GetExecutionResponseSchema `json:"data,omitempty" url:"data,omitempty"`
	Pagination *PaginationDetails            `json:"pagination,omitempty" url:"pagination,omitempty"`

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

func (l *ListExecutionResponseEnvelope) GetData() []*GetExecutionResponseSchema {
	if l == nil {
		return nil
	}
	return l.Data
}

func (l *ListExecutionResponseEnvelope) GetPagination() *PaginationDetails {
	if l == nil {
		return nil
	}
	return l.Pagination
}

func (l *ListExecutionResponseEnvelope) GetExtraProperties() map[string]interface{} {
	return l.extraProperties
}

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

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

type ListPoliciesResponseEnvelope struct {
	Data []*PolicyResponse `json:"data,omitempty" url:"data,omitempty"`

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

func (l *ListPoliciesResponseEnvelope) GetData() []*PolicyResponse {
	if l == nil {
		return nil
	}
	return l.Data
}

func (l *ListPoliciesResponseEnvelope) GetExtraProperties() map[string]interface{} {
	return l.extraProperties
}

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

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

type Mode struct {
	Description           *string `json:"description,omitempty" url:"description,omitempty"`
	Label                 *string `json:"label,omitempty" url:"label,omitempty"`
	Mode                  *string `json:"mode,omitempty" url:"mode,omitempty"`
	RequiresIdentity      *bool   `json:"requires_identity,omitempty" url:"requires_identity,omitempty"`
	SupportsFieldSyncMode *bool   `json:"supports_field_sync_mode,omitempty" url:"supports_field_sync_mode,omitempty"`
	SupportsTargetFilters *bool   `json:"supports_target_filters,omitempty" url:"supports_target_filters,omitempty"`

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

func (m *Mode) GetDescription() *string {
	if m == nil {
		return nil
	}
	return m.Description
}

func (m *Mode) GetLabel() *string {
	if m == nil {
		return nil
	}
	return m.Label
}

func (m *Mode) GetMode() *string {
	if m == nil {
		return nil
	}
	return m.Mode
}

func (m *Mode) GetRequiresIdentity() *bool {
	if m == nil {
		return nil
	}
	return m.RequiresIdentity
}

func (m *Mode) GetSupportsFieldSyncMode() *bool {
	if m == nil {
		return nil
	}
	return m.SupportsFieldSyncMode
}

func (m *Mode) GetSupportsTargetFilters() *bool {
	if m == nil {
		return nil
	}
	return m.SupportsTargetFilters
}

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

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

func (m *Mode) 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 ModelField struct {
	CreatedAt   *time.Time   `json:"created_at,omitempty" url:"created_at,omitempty"`
	CreatedBy   *OutputActor `json:"created_by,omitempty" url:"created_by,omitempty"`
	Description *string      `json:"description,omitempty" url:"description,omitempty"`
	Example     interface{}  `json:"example,omitempty" url:"example,omitempty"`
	Id          *string      `json:"id,omitempty" url:"id,omitempty"`
	Label       *string      `json:"label,omitempty" url:"label,omitempty"`
	Name        *string      `json:"name,omitempty" url:"name,omitempty"`
	RemoteType  *string      `json:"remote_type,omitempty" url:"remote_type,omitempty"`
	Type        *string      `json:"type,omitempty" url:"type,omitempty"`
	Unique      *bool        `json:"unique,omitempty" url:"unique,omitempty"`
	UpdatedAt   *time.Time   `json:"updated_at,omitempty" url:"updated_at,omitempty"`
	UserAdded   *bool        `json:"user_added,omitempty" url:"user_added,omitempty"`

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

func (m *ModelField) GetCreatedAt() *time.Time {
	if m == nil {
		return nil
	}
	return m.CreatedAt
}

func (m *ModelField) GetCreatedBy() *OutputActor {
	if m == nil {
		return nil
	}
	return m.CreatedBy
}

func (m *ModelField) GetDescription() *string {
	if m == nil {
		return nil
	}
	return m.Description
}

func (m *ModelField) GetExample() interface{} {
	if m == nil {
		return nil
	}
	return m.Example
}

func (m *ModelField) GetId() *string {
	if m == nil {
		return nil
	}
	return m.Id
}

func (m *ModelField) GetLabel() *string {
	if m == nil {
		return nil
	}
	return m.Label
}

func (m *ModelField) GetName() *string {
	if m == nil {
		return nil
	}
	return m.Name
}

func (m *ModelField) GetRemoteType() *string {
	if m == nil {
		return nil
	}
	return m.RemoteType
}

func (m *ModelField) GetType() *string {
	if m == nil {
		return nil
	}
	return m.Type
}

func (m *ModelField) GetUnique() *bool {
	if m == nil {
		return nil
	}
	return m.Unique
}

func (m *ModelField) GetUpdatedAt() *time.Time {
	if m == nil {
		return nil
	}
	return m.UpdatedAt
}

func (m *ModelField) GetUserAdded() *bool {
	if m == nil {
		return nil
	}
	return m.UserAdded
}

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

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

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

func (m *ModelField) 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 ModelSyncMode string

const (
	ModelSyncModeCreate         ModelSyncMode = "create"
	ModelSyncModeUpdate         ModelSyncMode = "update"
	ModelSyncModeUpdateOrCreate ModelSyncMode = "updateOrCreate"
	ModelSyncModeReplace        ModelSyncMode = "replace"
	ModelSyncModeAppend         ModelSyncMode = "append"
	ModelSyncModeRemove         ModelSyncMode = "remove"
	ModelSyncModeSnapshot       ModelSyncMode = "snapshot"
)

func NewModelSyncModeFromString(s string) (ModelSyncMode, error) {
	switch s {
	case "create":
		return ModelSyncModeCreate, nil
	case "update":
		return ModelSyncModeUpdate, nil
	case "updateOrCreate":
		return ModelSyncModeUpdateOrCreate, nil
	case "replace":
		return ModelSyncModeReplace, nil
	case "append":
		return ModelSyncModeAppend, nil
	case "remove":
		return ModelSyncModeRemove, nil
	case "snapshot":
		return ModelSyncModeSnapshot, nil
	}
	var t ModelSyncMode
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (m ModelSyncMode) Ptr() *ModelSyncMode {
	return &m
}

type ModelSyncSourceMetaResponse struct {
	// Additional configuration fields available for this source, keyed by field name.
	Configuration map[string]*ConfigurationValue `json:"configuration,omitempty" url:"configuration,omitempty"`
	// Map of configuration item name to its metadata (available values, required-one-of groups).
	Items map[string]*SourceMeta `json:"items,omitempty" url:"items,omitempty"`
	// Configuration items where exactly one must be selected by the caller.
	RequiresOneOf []string `json:"requires_one_of,omitempty" url:"requires_one_of,omitempty"`

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

func (m *ModelSyncSourceMetaResponse) GetConfiguration() map[string]*ConfigurationValue {
	if m == nil {
		return nil
	}
	return m.Configuration
}

func (m *ModelSyncSourceMetaResponse) GetItems() map[string]*SourceMeta {
	if m == nil {
		return nil
	}
	return m.Items
}

func (m *ModelSyncSourceMetaResponse) GetRequiresOneOf() []string {
	if m == nil {
		return nil
	}
	return m.RequiresOneOf
}

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

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

func (m *ModelSyncSourceMetaResponse) 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 OutputActor struct {
	Id   *string `json:"id,omitempty" url:"id,omitempty"`
	Name *string `json:"name,omitempty" url:"name,omitempty"`
	Type *string `json:"type,omitempty" url:"type,omitempty"`

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

func (o *OutputActor) GetId() *string {
	if o == nil {
		return nil
	}
	return o.Id
}

func (o *OutputActor) GetName() *string {
	if o == nil {
		return nil
	}
	return o.Name
}

func (o *OutputActor) GetType() *string {
	if o == nil {
		return nil
	}
	return o.Type
}

func (o *OutputActor) GetExtraProperties() map[string]interface{} {
	return o.extraProperties
}

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

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

type PaginationDetails struct {
	NextPageToken *string `json:"next_page_token,omitempty" url:"next_page_token,omitempty"`

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

func (p *PaginationDetails) GetNextPageToken() *string {
	if p == nil {
		return nil
	}
	return p.NextPageToken
}

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

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

func (p *PaginationDetails) 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 PickValue struct {
	Label *string `json:"label,omitempty" url:"label,omitempty"`
	Value *string `json:"value,omitempty" url:"value,omitempty"`

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

func (p *PickValue) GetLabel() *string {
	if p == nil {
		return nil
	}
	return p.Label
}

func (p *PickValue) GetValue() *string {
	if p == nil {
		return nil
	}
	return p.Value
}

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

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

func (p *PickValue) 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 PolicyAction struct {
	Action  string   `json:"action" url:"action"`
	RoleIds []string `json:"role_ids,omitempty" url:"role_ids,omitempty"`

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

func (p *PolicyAction) GetAction() string {
	if p == nil {
		return ""
	}
	return p.Action
}

func (p *PolicyAction) GetRoleIds() []string {
	if p == nil {
		return nil
	}
	return p.RoleIds
}

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

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

func (p *PolicyAction) 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 PolicyResponse struct {
	Id             *string         `json:"id,omitempty" url:"id,omitempty"`
	Name           *string         `json:"name,omitempty" url:"name,omitempty"`
	OrganizationId *string         `json:"organization_id,omitempty" url:"organization_id,omitempty"`
	PolicyActions  []*PolicyAction `json:"policy_actions,omitempty" url:"policy_actions,omitempty"`
	System         *bool           `json:"system,omitempty" url:"system,omitempty"`

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

func (p *PolicyResponse) GetId() *string {
	if p == nil {
		return nil
	}
	return p.Id
}

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

func (p *PolicyResponse) GetOrganizationId() *string {
	if p == nil {
		return nil
	}
	return p.OrganizationId
}

func (p *PolicyResponse) GetPolicyActions() []*PolicyAction {
	if p == nil {
		return nil
	}
	return p.PolicyActions
}

func (p *PolicyResponse) GetSystem() *bool {
	if p == nil {
		return nil
	}
	return p.System
}

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

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

func (p *PolicyResponse) 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 PolicyResponseEnvelope struct {
	Data *PolicyResponse `json:"data,omitempty" url:"data,omitempty"`

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

func (p *PolicyResponseEnvelope) GetData() *PolicyResponse {
	if p == nil {
		return nil
	}
	return p.Data
}

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

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

func (p *PolicyResponseEnvelope) 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 RestErrResponse struct {
	// Application-specific error code.
	Code *int `json:"code,omitempty" url:"code,omitempty"`
	// Application context.
	Context map[string]interface{} `json:"context,omitempty" url:"context,omitempty"`
	// Error message.
	Error *string `json:"error,omitempty" url:"error,omitempty"`
	// Status text.
	Status *string `json:"status,omitempty" url:"status,omitempty"`

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

func (r *RestErrResponse) GetCode() *int {
	if r == nil {
		return nil
	}
	return r.Code
}

func (r *RestErrResponse) GetContext() map[string]interface{} {
	if r == nil {
		return nil
	}
	return r.Context
}

func (r *RestErrResponse) GetError() *string {
	if r == nil {
		return nil
	}
	return r.Error
}

func (r *RestErrResponse) GetStatus() *string {
	if r == nil {
		return nil
	}
	return r.Status
}

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

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

func (r *RestErrResponse) 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 RoleListResponseEnvelope struct {
	Data []*RoleResponse `json:"data,omitempty" url:"data,omitempty"`

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

func (r *RoleListResponseEnvelope) GetData() []*RoleResponse {
	if r == nil {
		return nil
	}
	return r.Data
}

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

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

func (r *RoleListResponseEnvelope) 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 RoleResponse struct {
	Id             *string `json:"id,omitempty" url:"id,omitempty"`
	Name           *string `json:"name,omitempty" url:"name,omitempty"`
	OrganizationId *string `json:"organization_id,omitempty" url:"organization_id,omitempty"`
	System         *bool   `json:"system,omitempty" url:"system,omitempty"`

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

func (r *RoleResponse) GetId() *string {
	if r == nil {
		return nil
	}
	return r.Id
}

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

func (r *RoleResponse) GetOrganizationId() *string {
	if r == nil {
		return nil
	}
	return r.OrganizationId
}

func (r *RoleResponse) GetSystem() *bool {
	if r == nil {
		return nil
	}
	return r.System
}

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

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

func (r *RoleResponse) 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 RoleResponseEnvelope struct {
	Data *RoleResponse `json:"data,omitempty" url:"data,omitempty"`

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

func (r *RoleResponseEnvelope) GetData() *RoleResponse {
	if r == nil {
		return nil
	}
	return r.Data
}

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

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

func (r *RoleResponseEnvelope) 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 ScheduleEnvelope struct {
	Data *BulkBulkSyncSchedule `json:"data,omitempty" url:"data,omitempty"`

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

func (s *ScheduleEnvelope) GetData() *BulkBulkSyncSchedule {
	if s == nil {
		return nil
	}
	return s.Data
}

func (s *ScheduleEnvelope) GetExtraProperties() map[string]interface{} {
	return s.extraProperties
}

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

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

type ScheduleFrequency string

const (
	ScheduleFrequencyManual     ScheduleFrequency = "manual"
	ScheduleFrequencyContinuous ScheduleFrequency = "continuous"
	ScheduleFrequencyHourly     ScheduleFrequency = "hourly"
	ScheduleFrequencyDaily      ScheduleFrequency = "daily"
	ScheduleFrequencyWeekly     ScheduleFrequency = "weekly"
	ScheduleFrequencyCustom     ScheduleFrequency = "custom"
	ScheduleFrequencyBuilder    ScheduleFrequency = "builder"
	ScheduleFrequencyRunafter   ScheduleFrequency = "runafter"
	ScheduleFrequencyMulti      ScheduleFrequency = "multi"
	ScheduleFrequencyDbtcloud   ScheduleFrequency = "dbtcloud"
)

func NewScheduleFrequencyFromString(s string) (ScheduleFrequency, error) {
	switch s {
	case "manual":
		return ScheduleFrequencyManual, nil
	case "continuous":
		return ScheduleFrequencyContinuous, nil
	case "hourly":
		return ScheduleFrequencyHourly, nil
	case "daily":
		return ScheduleFrequencyDaily, nil
	case "weekly":
		return ScheduleFrequencyWeekly, nil
	case "custom":
		return ScheduleFrequencyCustom, nil
	case "builder":
		return ScheduleFrequencyBuilder, nil
	case "runafter":
		return ScheduleFrequencyRunafter, nil
	case "multi":
		return ScheduleFrequencyMulti, nil
	case "dbtcloud":
		return ScheduleFrequencyDbtcloud, nil
	}
	var t ScheduleFrequency
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (s ScheduleFrequency) Ptr() *ScheduleFrequency {
	return &s
}

type SchedulesEnvelope struct {
	Data []*BulkBulkSyncSchedule `json:"data,omitempty" url:"data,omitempty"`

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

func (s *SchedulesEnvelope) GetData() []*BulkBulkSyncSchedule {
	if s == nil {
		return nil
	}
	return s.Data
}

func (s *SchedulesEnvelope) GetExtraProperties() map[string]interface{} {
	return s.extraProperties
}

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

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

type Schema struct {
	Fields []*SchemaField `json:"fields,omitempty" url:"fields,omitempty"`
	Id     *string        `json:"id,omitempty" url:"id,omitempty"`
	Name   *string        `json:"name,omitempty" url:"name,omitempty"`

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

func (s *Schema) GetFields() []*SchemaField {
	if s == nil {
		return nil
	}
	return s.Fields
}

func (s *Schema) GetId() *string {
	if s == nil {
		return nil
	}
	return s.Id
}

func (s *Schema) GetName() *string {
	if s == nil {
		return nil
	}
	return s.Name
}

func (s *Schema) GetExtraProperties() map[string]interface{} {
	return s.extraProperties
}

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

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

type SchemaAssociation struct {
	Id              *string  `json:"id,omitempty" url:"id,omitempty"`
	Name            *string  `json:"name,omitempty" url:"name,omitempty"`
	ReferenceTo     []string `json:"reference_to,omitempty" url:"reference_to,omitempty"`
	ReferencedField *string  `json:"referenced_field,omitempty" url:"referenced_field,omitempty"`

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

func (s *SchemaAssociation) GetId() *string {
	if s == nil {
		return nil
	}
	return s.Id
}

func (s *SchemaAssociation) GetName() *string {
	if s == nil {
		return nil
	}
	return s.Name
}

func (s *SchemaAssociation) GetReferenceTo() []string {
	if s == nil {
		return nil
	}
	return s.ReferenceTo
}

func (s *SchemaAssociation) GetReferencedField() *string {
	if s == nil {
		return nil
	}
	return s.ReferencedField
}

func (s *SchemaAssociation) GetExtraProperties() map[string]interface{} {
	return s.extraProperties
}

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

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

type SchemaField struct {
	Association *SchemaAssociation `json:"association,omitempty" url:"association,omitempty"`
	Id          *string            `json:"id,omitempty" url:"id,omitempty"`
	// Whether this field is part of the schema's primary key.
	IsPrimaryKey *bool   `json:"is_primary_key,omitempty" url:"is_primary_key,omitempty"`
	Name         *string `json:"name,omitempty" url:"name,omitempty"`
	// The type of the field from the remote system.
	RemoteType *string        `json:"remote_type,omitempty" url:"remote_type,omitempty"`
	Type       *UtilFieldType `json:"type,omitempty" url:"type,omitempty"`
	TypeSpec   *TypesType     `json:"type_spec,omitempty" url:"type_spec,omitempty"`
	Values     []*PickValue   `json:"values,omitempty" url:"values,omitempty"`

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

func (s *SchemaField) GetAssociation() *SchemaAssociation {
	if s == nil {
		return nil
	}
	return s.Association
}

func (s *SchemaField) GetId() *string {
	if s == nil {
		return nil
	}
	return s.Id
}

func (s *SchemaField) GetIsPrimaryKey() *bool {
	if s == nil {
		return nil
	}
	return s.IsPrimaryKey
}

func (s *SchemaField) GetName() *string {
	if s == nil {
		return nil
	}
	return s.Name
}

func (s *SchemaField) GetRemoteType() *string {
	if s == nil {
		return nil
	}
	return s.RemoteType
}

func (s *SchemaField) GetType() *UtilFieldType {
	if s == nil {
		return nil
	}
	return s.Type
}

func (s *SchemaField) GetTypeSpec() *TypesType {
	if s == nil {
		return nil
	}
	return s.TypeSpec
}

func (s *SchemaField) GetValues() []*PickValue {
	if s == nil {
		return nil
	}
	return s.Values
}

func (s *SchemaField) GetExtraProperties() map[string]interface{} {
	return s.extraProperties
}

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

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

type SourceMeta struct {
	// True when items is non-empty. Callers should present the values as a picker.
	HasItems *bool `json:"has_items,omitempty" url:"has_items,omitempty"`
	// Valid values the caller may choose for this configuration item.
	Items []interface{} `json:"items,omitempty" url:"items,omitempty"`
	// Other configuration items this item depends on; exactly one of the listed items must also be selected.
	RequiresOneOf []string `json:"requires_one_of,omitempty" url:"requires_one_of,omitempty"`

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

func (s *SourceMeta) GetHasItems() *bool {
	if s == nil {
		return nil
	}
	return s.HasItems
}

func (s *SourceMeta) GetItems() []interface{} {
	if s == nil {
		return nil
	}
	return s.Items
}

func (s *SourceMeta) GetRequiresOneOf() []string {
	if s == nil {
		return nil
	}
	return s.RequiresOneOf
}

func (s *SourceMeta) GetExtraProperties() map[string]interface{} {
	return s.extraProperties
}

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

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

type SupportedMode struct {
	Id *ModelSyncMode `json:"id,omitempty" url:"id,omitempty"`
	// True if the sync mode requires an identity field mapping.
	RequiresIdentity *bool `json:"requires_identity,omitempty" url:"requires_identity,omitempty"`
	// True if the target supports per-field sync modes.
	SupportsPerFieldMode *bool `json:"supports_per_field_mode,omitempty" url:"supports_per_field_mode,omitempty"`
	// True if the sync mode supports target filters.
	SupportsTargetFilters *bool `json:"supports_target_filters,omitempty" url:"supports_target_filters,omitempty"`

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

func (s *SupportedMode) GetId() *ModelSyncMode {
	if s == nil {
		return nil
	}
	return s.Id
}

func (s *SupportedMode) GetRequiresIdentity() *bool {
	if s == nil {
		return nil
	}
	return s.RequiresIdentity
}

func (s *SupportedMode) GetSupportsPerFieldMode() *bool {
	if s == nil {
		return nil
	}
	return s.SupportsPerFieldMode
}

func (s *SupportedMode) GetSupportsTargetFilters() *bool {
	if s == nil {
		return nil
	}
	return s.SupportsTargetFilters
}

func (s *SupportedMode) GetExtraProperties() map[string]interface{} {
	return s.extraProperties
}

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

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

type SyncDestinationProperties struct {
	DoesNotReportOperationCounts  *bool   `json:"does_not_report_operation_counts,omitempty" url:"does_not_report_operation_counts,omitempty"`
	MappingsNotRequired           *bool   `json:"mappings_not_required,omitempty" url:"mappings_not_required,omitempty"`
	NewTargetLabel                *string `json:"new_target_label,omitempty" url:"new_target_label,omitempty"`
	OptionalTargetMappings        *bool   `json:"optional_target_mappings,omitempty" url:"optional_target_mappings,omitempty"`
	PrimaryMetadataObject         *string `json:"primary_metadata_object,omitempty" url:"primary_metadata_object,omitempty"`
	RequiresConfiguration         *bool   `json:"requires_configuration,omitempty" url:"requires_configuration,omitempty"`
	SupportsFieldCreation         *bool   `json:"supports_field_creation,omitempty" url:"supports_field_creation,omitempty"`
	SupportsFieldEncryption       *bool   `json:"supports_field_encryption,omitempty" url:"supports_field_encryption,omitempty"`
	SupportsFieldTypeSelection    *bool   `json:"supports_field_type_selection,omitempty" url:"supports_field_type_selection,omitempty"`
	SupportsIdentityFieldCreation *bool   `json:"supports_identity_field_creation,omitempty" url:"supports_identity_field_creation,omitempty"`
	SupportsTargetFilters         *bool   `json:"supports_target_filters,omitempty" url:"supports_target_filters,omitempty"`
	TargetCreator                 *bool   `json:"target_creator,omitempty" url:"target_creator,omitempty"`
	UseFieldNamesAsLabels         *bool   `json:"use_field_names_as_labels,omitempty" url:"use_field_names_as_labels,omitempty"`

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

func (s *SyncDestinationProperties) GetDoesNotReportOperationCounts() *bool {
	if s == nil {
		return nil
	}
	return s.DoesNotReportOperationCounts
}

func (s *SyncDestinationProperties) GetMappingsNotRequired() *bool {
	if s == nil {
		return nil
	}
	return s.MappingsNotRequired
}

func (s *SyncDestinationProperties) GetNewTargetLabel() *string {
	if s == nil {
		return nil
	}
	return s.NewTargetLabel
}

func (s *SyncDestinationProperties) GetOptionalTargetMappings() *bool {
	if s == nil {
		return nil
	}
	return s.OptionalTargetMappings
}

func (s *SyncDestinationProperties) GetPrimaryMetadataObject() *string {
	if s == nil {
		return nil
	}
	return s.PrimaryMetadataObject
}

func (s *SyncDestinationProperties) GetRequiresConfiguration() *bool {
	if s == nil {
		return nil
	}
	return s.RequiresConfiguration
}

func (s *SyncDestinationProperties) GetSupportsFieldCreation() *bool {
	if s == nil {
		return nil
	}
	return s.SupportsFieldCreation
}

func (s *SyncDestinationProperties) GetSupportsFieldEncryption() *bool {
	if s == nil {
		return nil
	}
	return s.SupportsFieldEncryption
}

func (s *SyncDestinationProperties) GetSupportsFieldTypeSelection() *bool {
	if s == nil {
		return nil
	}
	return s.SupportsFieldTypeSelection
}

func (s *SyncDestinationProperties) GetSupportsIdentityFieldCreation() *bool {
	if s == nil {
		return nil
	}
	return s.SupportsIdentityFieldCreation
}

func (s *SyncDestinationProperties) GetSupportsTargetFilters() *bool {
	if s == nil {
		return nil
	}
	return s.SupportsTargetFilters
}

func (s *SyncDestinationProperties) GetTargetCreator() *bool {
	if s == nil {
		return nil
	}
	return s.TargetCreator
}

func (s *SyncDestinationProperties) GetUseFieldNamesAsLabels() *bool {
	if s == nil {
		return nil
	}
	return s.UseFieldNamesAsLabels
}

func (s *SyncDestinationProperties) GetExtraProperties() map[string]interface{} {
	return s.extraProperties
}

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

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

type TargetCreateInput struct {
	// True if the property is an enum.
	Enum *bool `json:"enum,omitempty" url:"enum,omitempty"`
	// The identifier of the target property.
	Id *string `json:"id,omitempty" url:"id,omitempty"`
	// A human readable title for the target property.
	Title *string `json:"title,omitempty" url:"title,omitempty"`

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

func (t *TargetCreateInput) GetEnum() *bool {
	if t == nil {
		return nil
	}
	return t.Enum
}

func (t *TargetCreateInput) GetId() *string {
	if t == nil {
		return nil
	}
	return t.Id
}

func (t *TargetCreateInput) GetTitle() *string {
	if t == nil {
		return nil
	}
	return t.Title
}

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

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

func (t *TargetCreateInput) 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 TargetField struct {
	Association       *bool               `json:"association,omitempty" url:"association,omitempty"`
	Createable        *bool               `json:"createable,omitempty" url:"createable,omitempty"`
	Description       *string             `json:"description,omitempty" url:"description,omitempty"`
	Encryptable       *bool               `json:"encryptable,omitempty" url:"encryptable,omitempty"`
	Filterable        *bool               `json:"filterable,omitempty" url:"filterable,omitempty"`
	Id                *string             `json:"id,omitempty" url:"id,omitempty"`
	IdentityFunctions []*IdentityFunction `json:"identity_functions,omitempty" url:"identity_functions,omitempty"`
	Name              *string             `json:"name,omitempty" url:"name,omitempty"`
	Required          *bool               `json:"required,omitempty" url:"required,omitempty"`
	SourceType        *string             `json:"source_type,omitempty" url:"source_type,omitempty"`
	SupportsIdentity  *bool               `json:"supports_identity,omitempty" url:"supports_identity,omitempty"`
	Type              *string             `json:"type,omitempty" url:"type,omitempty"`
	Updateable        *bool               `json:"updateable,omitempty" url:"updateable,omitempty"`

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

func (t *TargetField) GetAssociation() *bool {
	if t == nil {
		return nil
	}
	return t.Association
}

func (t *TargetField) GetCreateable() *bool {
	if t == nil {
		return nil
	}
	return t.Createable
}

func (t *TargetField) GetDescription() *string {
	if t == nil {
		return nil
	}
	return t.Description
}

func (t *TargetField) GetEncryptable() *bool {
	if t == nil {
		return nil
	}
	return t.Encryptable
}

func (t *TargetField) GetFilterable() *bool {
	if t == nil {
		return nil
	}
	return t.Filterable
}

func (t *TargetField) GetId() *string {
	if t == nil {
		return nil
	}
	return t.Id
}

func (t *TargetField) GetIdentityFunctions() []*IdentityFunction {
	if t == nil {
		return nil
	}
	return t.IdentityFunctions
}

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

func (t *TargetField) GetRequired() *bool {
	if t == nil {
		return nil
	}
	return t.Required
}

func (t *TargetField) GetSourceType() *string {
	if t == nil {
		return nil
	}
	return t.SourceType
}

func (t *TargetField) GetSupportsIdentity() *bool {
	if t == nil {
		return nil
	}
	return t.SupportsIdentity
}

func (t *TargetField) GetType() *string {
	if t == nil {
		return nil
	}
	return t.Type
}

func (t *TargetField) GetUpdateable() *bool {
	if t == nil {
		return nil
	}
	return t.Updateable
}

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

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

func (t *TargetField) 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 TargetObject struct {
	// The identifier of the target object.
	Id *string `json:"id,omitempty" url:"id,omitempty"`
	// The supported sync modes and their properties for the target object.
	Modes []*SupportedMode `json:"modes,omitempty" url:"modes,omitempty"`
	// The name of the target object.
	Name *string `json:"name,omitempty" url:"name,omitempty"`

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

func (t *TargetObject) GetId() *string {
	if t == nil {
		return nil
	}
	return t.Id
}

func (t *TargetObject) GetModes() []*SupportedMode {
	if t == nil {
		return nil
	}
	return t.Modes
}

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

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

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

func (t *TargetObject) 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 TargetResponse struct {
	Fields      []*TargetField             `json:"fields,omitempty" url:"fields,omitempty"`
	Id          *string                    `json:"id,omitempty" url:"id,omitempty"`
	Modes       []*Mode                    `json:"modes,omitempty" url:"modes,omitempty"`
	Name        *string                    `json:"name,omitempty" url:"name,omitempty"`
	Properties  *SyncDestinationProperties `json:"properties,omitempty" url:"properties,omitempty"`
	RefreshedAt *time.Time                 `json:"refreshed_at,omitempty" url:"refreshed_at,omitempty"`

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

func (t *TargetResponse) GetFields() []*TargetField {
	if t == nil {
		return nil
	}
	return t.Fields
}

func (t *TargetResponse) GetId() *string {
	if t == nil {
		return nil
	}
	return t.Id
}

func (t *TargetResponse) GetModes() []*Mode {
	if t == nil {
		return nil
	}
	return t.Modes
}

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

func (t *TargetResponse) GetProperties() *SyncDestinationProperties {
	if t == nil {
		return nil
	}
	return t.Properties
}

func (t *TargetResponse) GetRefreshedAt() *time.Time {
	if t == nil {
		return nil
	}
	return t.RefreshedAt
}

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

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

func (t *TargetResponse) MarshalJSON() ([]byte, error) {
	type embed TargetResponse
	var marshaler = struct {
		embed
		RefreshedAt *internal.DateTime `json:"refreshed_at,omitempty"`
	}{
		embed:       embed(*t),
		RefreshedAt: internal.NewOptionalDateTime(t.RefreshedAt),
	}
	return json.Marshal(marshaler)
}

func (t *TargetResponse) 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 TargetResponseEnvelope struct {
	Data *TargetResponse `json:"data,omitempty" url:"data,omitempty"`

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

func (t *TargetResponseEnvelope) GetData() *TargetResponse {
	if t == nil {
		return nil
	}
	return t.Data
}

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

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

func (t *TargetResponseEnvelope) 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 TypesType = interface{}

type UpdateBulkField struct {
	Enabled        *bool   `json:"enabled,omitempty" url:"enabled,omitempty"`
	Id             *string `json:"id,omitempty" url:"id,omitempty"`
	Obfuscated     *bool   `json:"obfuscated,omitempty" url:"obfuscated,omitempty"`
	UserOutputName *string `json:"user_output_name,omitempty" url:"user_output_name,omitempty"`

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

func (u *UpdateBulkField) GetEnabled() *bool {
	if u == nil {
		return nil
	}
	return u.Enabled
}

func (u *UpdateBulkField) GetId() *string {
	if u == nil {
		return nil
	}
	return u.Id
}

func (u *UpdateBulkField) GetObfuscated() *bool {
	if u == nil {
		return nil
	}
	return u.Obfuscated
}

func (u *UpdateBulkField) GetUserOutputName() *string {
	if u == nil {
		return nil
	}
	return u.UserOutputName
}

func (u *UpdateBulkField) GetExtraProperties() map[string]interface{} {
	return u.extraProperties
}

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

func (u *UpdateBulkField) 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 UtilEnumValue struct {
	Label *string `json:"label,omitempty" url:"label,omitempty"`
	Value *string `json:"value,omitempty" url:"value,omitempty"`

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

func (u *UtilEnumValue) GetLabel() *string {
	if u == nil {
		return nil
	}
	return u.Label
}

func (u *UtilEnumValue) GetValue() *string {
	if u == nil {
		return nil
	}
	return u.Value
}

func (u *UtilEnumValue) GetExtraProperties() map[string]interface{} {
	return u.extraProperties
}

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

func (u *UtilEnumValue) 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 UtilFieldType string

const (
	UtilFieldTypeUnknown  UtilFieldType = "unknown"
	UtilFieldTypeString   UtilFieldType = "string"
	UtilFieldTypeNumber   UtilFieldType = "number"
	UtilFieldTypeBoolean  UtilFieldType = "boolean"
	UtilFieldTypeDatetime UtilFieldType = "datetime"
	UtilFieldTypeArray    UtilFieldType = "array"
	UtilFieldTypeObject   UtilFieldType = "object"
	UtilFieldTypeBinary   UtilFieldType = "binary"
)

func NewUtilFieldTypeFromString(s string) (UtilFieldType, error) {
	switch s {
	case "unknown":
		return UtilFieldTypeUnknown, nil
	case "string":
		return UtilFieldTypeString, nil
	case "number":
		return UtilFieldTypeNumber, nil
	case "boolean":
		return UtilFieldTypeBoolean, nil
	case "datetime":
		return UtilFieldTypeDatetime, nil
	case "array":
		return UtilFieldTypeArray, nil
	case "object":
		return UtilFieldTypeObject, nil
	case "binary":
		return UtilFieldTypeBinary, nil
	}
	var t UtilFieldType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (u UtilFieldType) Ptr() *UtilFieldType {
	return &u
}

type V2ExecutionLogType string

const (
	V2ExecutionLogTypeRecords  V2ExecutionLogType = "records"
	V2ExecutionLogTypeErrors   V2ExecutionLogType = "errors"
	V2ExecutionLogTypeWarnings V2ExecutionLogType = "warnings"
	V2ExecutionLogTypeInserts  V2ExecutionLogType = "inserts"
	V2ExecutionLogTypeUpdates  V2ExecutionLogType = "updates"
	V2ExecutionLogTypeDeletes  V2ExecutionLogType = "deletes"
)

func NewV2ExecutionLogTypeFromString(s string) (V2ExecutionLogType, error) {
	switch s {
	case "records":
		return V2ExecutionLogTypeRecords, nil
	case "errors":
		return V2ExecutionLogTypeErrors, nil
	case "warnings":
		return V2ExecutionLogTypeWarnings, nil
	case "inserts":
		return V2ExecutionLogTypeInserts, nil
	case "updates":
		return V2ExecutionLogTypeUpdates, nil
	case "deletes":
		return V2ExecutionLogTypeDeletes, nil
	}
	var t V2ExecutionLogType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (v V2ExecutionLogType) Ptr() *V2ExecutionLogType {
	return &v
}

type V4BulkSyncExecutionLogs struct {
	// Timestamp at which the signed URLs in URLs stop working.
	Expires *time.Time `json:"Expires,omitempty" url:"Expires,omitempty"`
	// Signed URLs that download the execution's log files. These URLs expire at the Expires timestamp.
	UrLs []string `json:"URLs,omitempty" url:"URLs,omitempty"`

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

func (v *V4BulkSyncExecutionLogs) GetExpires() *time.Time {
	if v == nil {
		return nil
	}
	return v.Expires
}

func (v *V4BulkSyncExecutionLogs) GetUrLs() []string {
	if v == nil {
		return nil
	}
	return v.UrLs
}

func (v *V4BulkSyncExecutionLogs) GetExtraProperties() map[string]interface{} {
	return v.extraProperties
}

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

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

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

type V4BulkSyncExecutionLogsEnvelope struct {
	Data *V4BulkSyncExecutionLogs `json:"data,omitempty" url:"data,omitempty"`

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

func (v *V4BulkSyncExecutionLogsEnvelope) GetData() *V4BulkSyncExecutionLogs {
	if v == nil {
		return nil
	}
	return v.Data
}

func (v *V4BulkSyncExecutionLogsEnvelope) GetExtraProperties() map[string]interface{} {
	return v.extraProperties
}

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

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

type V4BulkSyncScheduleApi struct {
	// Day of the month (1-31) for monthly schedules.
	DayOfMonth *string `json:"dayOfMonth,omitempty" url:"dayOfMonth,omitempty"`
	// Day of the week for weekly schedules.
	DayOfWeek *string           `json:"dayOfWeek,omitempty" url:"dayOfWeek,omitempty"`
	Frequency ScheduleFrequency `json:"frequency" url:"frequency"`
	// Hour of the day (0-23, in UTC) the schedule fires.
	Hour *string `json:"hour,omitempty" url:"hour,omitempty"`
	// Minute of the hour (0-59) the schedule fires.
	Minute *string `json:"minute,omitempty" url:"minute,omitempty"`
	// Month of the year (1-12) for yearly schedules.
	Month         *string            `json:"month,omitempty" url:"month,omitempty"`
	SelectiveMode *BulkSelectiveMode `json:"selectiveMode,omitempty" url:"selectiveMode,omitempty"`

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

func (v *V4BulkSyncScheduleApi) GetDayOfMonth() *string {
	if v == nil {
		return nil
	}
	return v.DayOfMonth
}

func (v *V4BulkSyncScheduleApi) GetDayOfWeek() *string {
	if v == nil {
		return nil
	}
	return v.DayOfWeek
}

func (v *V4BulkSyncScheduleApi) GetFrequency() ScheduleFrequency {
	if v == nil {
		return ""
	}
	return v.Frequency
}

func (v *V4BulkSyncScheduleApi) GetHour() *string {
	if v == nil {
		return nil
	}
	return v.Hour
}

func (v *V4BulkSyncScheduleApi) GetMinute() *string {
	if v == nil {
		return nil
	}
	return v.Minute
}

func (v *V4BulkSyncScheduleApi) GetMonth() *string {
	if v == nil {
		return nil
	}
	return v.Month
}

func (v *V4BulkSyncScheduleApi) GetSelectiveMode() *BulkSelectiveMode {
	if v == nil {
		return nil
	}
	return v.SelectiveMode
}

func (v *V4BulkSyncScheduleApi) GetExtraProperties() map[string]interface{} {
	return v.extraProperties
}

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

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

type V4ExportSyncLogsEnvelope struct {
	Data *V4ExportSyncLogsResponse `json:"data,omitempty" url:"data,omitempty"`
	Job  *JobResponse              `json:"job,omitempty" url:"job,omitempty"`

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

func (v *V4ExportSyncLogsEnvelope) GetData() *V4ExportSyncLogsResponse {
	if v == nil {
		return nil
	}
	return v.Data
}

func (v *V4ExportSyncLogsEnvelope) GetJob() *JobResponse {
	if v == nil {
		return nil
	}
	return v.Job
}

func (v *V4ExportSyncLogsEnvelope) GetExtraProperties() map[string]interface{} {
	return v.extraProperties
}

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

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

type V4ExportSyncLogsResponse struct {
	// Signed URL to download the exported log archive.
	Url *string `json:"url,omitempty" url:"url,omitempty"`

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

func (v *V4ExportSyncLogsResponse) GetUrl() *string {
	if v == nil {
		return nil
	}
	return v.Url
}

func (v *V4ExportSyncLogsResponse) GetExtraProperties() map[string]interface{} {
	return v.extraProperties
}

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

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

type V4TargetCreator struct {
	// The properties that are required for target creation.
	Properties []*TargetCreateInput `json:"properties,omitempty" url:"properties,omitempty"`
	// True if the connection supports target creation.
	Supported *bool `json:"supported,omitempty" url:"supported,omitempty"`

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

func (v *V4TargetCreator) GetProperties() []*TargetCreateInput {
	if v == nil {
		return nil
	}
	return v.Properties
}

func (v *V4TargetCreator) GetSupported() *bool {
	if v == nil {
		return nil
	}
	return v.Supported
}

func (v *V4TargetCreator) GetExtraProperties() map[string]interface{} {
	return v.extraProperties
}

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

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

type V4TargetObjectsResponseEnvelope struct {
	Data           []*TargetObject  `json:"data,omitempty" url:"data,omitempty"`
	TargetCreation *V4TargetCreator `json:"target_creation,omitempty" url:"target_creation,omitempty"`

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

func (v *V4TargetObjectsResponseEnvelope) GetData() []*TargetObject {
	if v == nil {
		return nil
	}
	return v.Data
}

func (v *V4TargetObjectsResponseEnvelope) GetTargetCreation() *V4TargetCreator {
	if v == nil {
		return nil
	}
	return v.TargetCreation
}

func (v *V4TargetObjectsResponseEnvelope) GetExtraProperties() map[string]interface{} {
	return v.extraProperties
}

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

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

type V4TargetPropertyValues struct {
	// True if the property is an enum.
	Enum *bool `json:"enum,omitempty" url:"enum,omitempty"`
	// The identifier of the target property.
	Id *string `json:"id,omitempty" url:"id,omitempty"`
	// A human readable title for the target property.
	Title *string `json:"title,omitempty" url:"title,omitempty"`
	// Valid values for the target property.
	Values []*UtilEnumValue `json:"values,omitempty" url:"values,omitempty"`

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

func (v *V4TargetPropertyValues) GetEnum() *bool {
	if v == nil {
		return nil
	}
	return v.Enum
}

func (v *V4TargetPropertyValues) GetId() *string {
	if v == nil {
		return nil
	}
	return v.Id
}

func (v *V4TargetPropertyValues) GetTitle() *string {
	if v == nil {
		return nil
	}
	return v.Title
}

func (v *V4TargetPropertyValues) GetValues() []*UtilEnumValue {
	if v == nil {
		return nil
	}
	return v.Values
}

func (v *V4TargetPropertyValues) GetExtraProperties() map[string]interface{} {
	return v.extraProperties
}

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

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

type V4TargetPropertyValuesEnvelope struct {
	Data *V4TargetPropertyValues `json:"data,omitempty" url:"data,omitempty"`

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

func (v *V4TargetPropertyValuesEnvelope) GetData() *V4TargetPropertyValues {
	if v == nil {
		return nil
	}
	return v.Data
}

func (v *V4TargetPropertyValuesEnvelope) GetExtraProperties() map[string]interface{} {
	return v.extraProperties
}

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

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

type WorkTaskStatus string

const (
	WorkTaskStatusCreated WorkTaskStatus = "created"
	WorkTaskStatusRunning WorkTaskStatus = "running"
	WorkTaskStatusDone    WorkTaskStatus = "done"
	WorkTaskStatusFailed  WorkTaskStatus = "failed"
)

func NewWorkTaskStatusFromString(s string) (WorkTaskStatus, error) {
	switch s {
	case "created":
		return WorkTaskStatusCreated, nil
	case "running":
		return WorkTaskStatusRunning, nil
	case "done":
		return WorkTaskStatusDone, nil
	case "failed":
		return WorkTaskStatusFailed, nil
	}
	var t WorkTaskStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (w WorkTaskStatus) Ptr() *WorkTaskStatus {
	return &w
}