types.go

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

package api

import (
	json "encoding/json"
	fmt "fmt"
	core "github.com/seamapi/go/core"
	time "time"
)

type AccessCode struct {
	// Unique identifier for a group of access codes that share the same code.
	CommonCodeKey *string `json:"common_code_key,omitempty" url:"common_code_key,omitempty"`
	// Indicates whether the code is set on the device according to a preconfigured schedule.
	IsScheduledOnDevice *bool `json:"is_scheduled_on_device,omitempty" url:"is_scheduled_on_device,omitempty"`
	// Nature of the access code. Values are "ongoing" for access codes that are active continuously until deactivated manually or "time_bound" for access codes that have a specific duration.
	Type AccessCodeType `json:"type,omitempty" url:"type,omitempty"`
	// Indicates whether the access code is waiting for a code assignment.
	IsWaitingForCodeAssignment *bool `json:"is_waiting_for_code_assignment,omitempty" url:"is_waiting_for_code_assignment,omitempty"`
	// Unique identifier for the access code.
	AccessCodeId string `json:"access_code_id" url:"access_code_id"`
	// Unique identifier for the device associated with the access code.
	DeviceId string `json:"device_id" url:"device_id"`
	// Name of the access code. Enables administrators and users to identify the access code easily, especially when there are numerous access codes.
	Name *string `json:"name,omitempty" url:"name,omitempty"`
	// Code used for access. Typically, a numeric or alphanumeric string.
	Code *string `json:"code,omitempty" url:"code,omitempty"`
	// Date and time at which the access code was created.
	CreatedAt time.Time   `json:"created_at" url:"created_at"`
	Errors    interface{} `json:"errors,omitempty" url:"errors,omitempty"`
	Warnings  interface{} `json:"warnings,omitempty" url:"warnings,omitempty"`
	// Indicates whether Seam manages the access code.
	IsManaged bool `json:"is_managed" url:"is_managed"`
	// Date and time at which the time-bound access code becomes active.
	StartsAt *time.Time `json:"starts_at,omitempty" url:"starts_at,omitempty"`
	// Date and time after which the time-bound access code becomes inactive.
	EndsAt *time.Time `json:"ends_at,omitempty" url:"ends_at,omitempty"`
	// Current status of the access code within the operational lifecycle. Values are "setting," a transitional phase that indicates that the code is being configured or activated; "set", which indicates that the code is active and operational; "unset," which indicates a deactivated or unused state, either before activation or after deliberate deactivation; "removing," which indicates a transitional period in which the code is being deleted or made inactive; and "unknown," which indicates an indeterminate state, due to reasons such as system errors or incomplete data, that highlights a potential need for system review or troubleshooting.
	Status AccessCodeStatus `json:"status,omitempty" url:"status,omitempty"`
	// Indicates whether a backup access code is available for use if the primary access code is lost or compromised.
	IsBackupAccessCodeAvailable bool `json:"is_backup_access_code_available" url:"is_backup_access_code_available"`
	// Indicates whether the access code is a backup code.
	IsBackup *bool `json:"is_backup,omitempty" url:"is_backup,omitempty"`
	// Identifier of the pulled backup access code. Used to associate the pulled backup access code with the original access code.
	PulledBackupAccessCodeId *string `json:"pulled_backup_access_code_id,omitempty" url:"pulled_backup_access_code_id,omitempty"`
	// Indicates whether changes to the access code from external sources are permitted.
	IsExternalModificationAllowed bool `json:"is_external_modification_allowed" url:"is_external_modification_allowed"`
	// Indicates whether the access code can only be used once. If "true," the code becomes invalid after the first use.
	IsOneTimeUse bool `json:"is_one_time_use" url:"is_one_time_use"`
	// Indicates whether the access code is intended for use in offline scenarios. If "true," this code can be created on a device without a network connection.
	IsOfflineAccessCode bool `json:"is_offline_access_code" url:"is_offline_access_code"`

	_rawJSON json.RawMessage
}

func (a *AccessCode) UnmarshalJSON(data []byte) error {
	type embed AccessCode
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
		StartsAt  *core.DateTime `json:"starts_at,omitempty"`
		EndsAt    *core.DateTime `json:"ends_at,omitempty"`
	}{
		embed: embed(*a),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*a = AccessCode(unmarshaler.embed)
	a.CreatedAt = unmarshaler.CreatedAt.Time()
	a.StartsAt = unmarshaler.StartsAt.TimePtr()
	a.EndsAt = unmarshaler.EndsAt.TimePtr()
	a._rawJSON = json.RawMessage(data)
	return nil
}

func (a *AccessCode) MarshalJSON() ([]byte, error) {
	type embed AccessCode
	var marshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
		StartsAt  *core.DateTime `json:"starts_at,omitempty"`
		EndsAt    *core.DateTime `json:"ends_at,omitempty"`
	}{
		embed:     embed(*a),
		CreatedAt: core.NewDateTime(a.CreatedAt),
		StartsAt:  core.NewOptionalDateTime(a.StartsAt),
		EndsAt:    core.NewOptionalDateTime(a.EndsAt),
	}
	return json.Marshal(marshaler)
}

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

// Current status of the access code within the operational lifecycle. Values are "setting," a transitional phase that indicates that the code is being configured or activated; "set", which indicates that the code is active and operational; "unset," which indicates a deactivated or unused state, either before activation or after deliberate deactivation; "removing," which indicates a transitional period in which the code is being deleted or made inactive; and "unknown," which indicates an indeterminate state, due to reasons such as system errors or incomplete data, that highlights a potential need for system review or troubleshooting.
type AccessCodeStatus string

const (
	AccessCodeStatusSetting  AccessCodeStatus = "setting"
	AccessCodeStatusSet      AccessCodeStatus = "set"
	AccessCodeStatusUnset    AccessCodeStatus = "unset"
	AccessCodeStatusRemoving AccessCodeStatus = "removing"
	AccessCodeStatusUnknown  AccessCodeStatus = "unknown"
)

func NewAccessCodeStatusFromString(s string) (AccessCodeStatus, error) {
	switch s {
	case "setting":
		return AccessCodeStatusSetting, nil
	case "set":
		return AccessCodeStatusSet, nil
	case "unset":
		return AccessCodeStatusUnset, nil
	case "removing":
		return AccessCodeStatusRemoving, nil
	case "unknown":
		return AccessCodeStatusUnknown, nil
	}
	var t AccessCodeStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AccessCodeStatus) Ptr() *AccessCodeStatus {
	return &a
}

// Nature of the access code. Values are "ongoing" for access codes that are active continuously until deactivated manually or "time_bound" for access codes that have a specific duration.
type AccessCodeType string

const (
	AccessCodeTypeTimeBound AccessCodeType = "time_bound"
	AccessCodeTypeOngoing   AccessCodeType = "ongoing"
)

func NewAccessCodeTypeFromString(s string) (AccessCodeType, error) {
	switch s {
	case "time_bound":
		return AccessCodeTypeTimeBound, nil
	case "ongoing":
		return AccessCodeTypeOngoing, nil
	}
	var t AccessCodeType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AccessCodeType) Ptr() *AccessCodeType {
	return &a
}

type AcsAccessGroup struct {
	AcsAccessGroupId string `json:"acs_access_group_id" url:"acs_access_group_id"`
	AcsSystemId      string `json:"acs_system_id" url:"acs_system_id"`
	WorkspaceId      string `json:"workspace_id" url:"workspace_id"`
	Name             string `json:"name" url:"name"`
	// ---
	// deprecated: use external_type
	// ---
	AccessGroupType AcsAccessGroupAccessGroupType `json:"access_group_type,omitempty" url:"access_group_type,omitempty"`
	// ---
	// deprecated: use external_type_display_name
	// ---
	AccessGroupTypeDisplayName string                     `json:"access_group_type_display_name" url:"access_group_type_display_name"`
	ExternalType               AcsAccessGroupExternalType `json:"external_type,omitempty" url:"external_type,omitempty"`
	ExternalTypeDisplayName    string                     `json:"external_type_display_name" url:"external_type_display_name"`
	CreatedAt                  time.Time                  `json:"created_at" url:"created_at"`

	_rawJSON json.RawMessage
}

func (a *AcsAccessGroup) UnmarshalJSON(data []byte) error {
	type embed AcsAccessGroup
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*a),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*a = AcsAccessGroup(unmarshaler.embed)
	a.CreatedAt = unmarshaler.CreatedAt.Time()
	a._rawJSON = json.RawMessage(data)
	return nil
}

func (a *AcsAccessGroup) MarshalJSON() ([]byte, error) {
	type embed AcsAccessGroup
	var marshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed:     embed(*a),
		CreatedAt: core.NewDateTime(a.CreatedAt),
	}
	return json.Marshal(marshaler)
}

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

// ---
// deprecated: use external_type
// ---
type AcsAccessGroupAccessGroupType string

const (
	AcsAccessGroupAccessGroupTypePtiUnit          AcsAccessGroupAccessGroupType = "pti_unit"
	AcsAccessGroupAccessGroupTypePtiAccessLevel   AcsAccessGroupAccessGroupType = "pti_access_level"
	AcsAccessGroupAccessGroupTypeSaltoAccessGroup AcsAccessGroupAccessGroupType = "salto_access_group"
	AcsAccessGroupAccessGroupTypeBrivoGroup       AcsAccessGroupAccessGroupType = "brivo_group"
)

func NewAcsAccessGroupAccessGroupTypeFromString(s string) (AcsAccessGroupAccessGroupType, error) {
	switch s {
	case "pti_unit":
		return AcsAccessGroupAccessGroupTypePtiUnit, nil
	case "pti_access_level":
		return AcsAccessGroupAccessGroupTypePtiAccessLevel, nil
	case "salto_access_group":
		return AcsAccessGroupAccessGroupTypeSaltoAccessGroup, nil
	case "brivo_group":
		return AcsAccessGroupAccessGroupTypeBrivoGroup, nil
	}
	var t AcsAccessGroupAccessGroupType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AcsAccessGroupAccessGroupType) Ptr() *AcsAccessGroupAccessGroupType {
	return &a
}

type AcsAccessGroupExternalType string

const (
	AcsAccessGroupExternalTypePtiUnit          AcsAccessGroupExternalType = "pti_unit"
	AcsAccessGroupExternalTypePtiAccessLevel   AcsAccessGroupExternalType = "pti_access_level"
	AcsAccessGroupExternalTypeSaltoAccessGroup AcsAccessGroupExternalType = "salto_access_group"
	AcsAccessGroupExternalTypeBrivoGroup       AcsAccessGroupExternalType = "brivo_group"
)

func NewAcsAccessGroupExternalTypeFromString(s string) (AcsAccessGroupExternalType, error) {
	switch s {
	case "pti_unit":
		return AcsAccessGroupExternalTypePtiUnit, nil
	case "pti_access_level":
		return AcsAccessGroupExternalTypePtiAccessLevel, nil
	case "salto_access_group":
		return AcsAccessGroupExternalTypeSaltoAccessGroup, nil
	case "brivo_group":
		return AcsAccessGroupExternalTypeBrivoGroup, nil
	}
	var t AcsAccessGroupExternalType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AcsAccessGroupExternalType) Ptr() *AcsAccessGroupExternalType {
	return &a
}

type AcsCredential struct {
	AcsCredentialId            string                           `json:"acs_credential_id" url:"acs_credential_id"`
	AcsUserId                  *string                          `json:"acs_user_id,omitempty" url:"acs_user_id,omitempty"`
	AcsCredentialPoolId        *string                          `json:"acs_credential_pool_id,omitempty" url:"acs_credential_pool_id,omitempty"`
	AcsSystemId                string                           `json:"acs_system_id" url:"acs_system_id"`
	ParentAcsCredentialId      *string                          `json:"parent_acs_credential_id,omitempty" url:"parent_acs_credential_id,omitempty"`
	DisplayName                string                           `json:"display_name" url:"display_name"`
	Code                       *string                          `json:"code,omitempty" url:"code,omitempty"`
	AccessMethod               AcsCredentialAccessMethod        `json:"access_method,omitempty" url:"access_method,omitempty"`
	ExternalType               *AcsCredentialExternalType       `json:"external_type,omitempty" url:"external_type,omitempty"`
	ExternalTypeDisplayName    *string                          `json:"external_type_display_name,omitempty" url:"external_type_display_name,omitempty"`
	CreatedAt                  time.Time                        `json:"created_at" url:"created_at"`
	WorkspaceId                string                           `json:"workspace_id" url:"workspace_id"`
	StartsAt                   *string                          `json:"starts_at,omitempty" url:"starts_at,omitempty"`
	EndsAt                     *string                          `json:"ends_at,omitempty" url:"ends_at,omitempty"`
	Errors                     []*AcsCredentialErrorsItem       `json:"errors,omitempty" url:"errors,omitempty"`
	Warnings                   []*AcsCredentialWarningsItem     `json:"warnings,omitempty" url:"warnings,omitempty"`
	IsMultiPhoneSyncCredential *bool                            `json:"is_multi_phone_sync_credential,omitempty" url:"is_multi_phone_sync_credential,omitempty"`
	VisionlineMetadata         *AcsCredentialVisionlineMetadata `json:"visionline_metadata,omitempty" url:"visionline_metadata,omitempty"`

	_rawJSON json.RawMessage
}

func (a *AcsCredential) UnmarshalJSON(data []byte) error {
	type embed AcsCredential
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*a),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*a = AcsCredential(unmarshaler.embed)
	a.CreatedAt = unmarshaler.CreatedAt.Time()
	a._rawJSON = json.RawMessage(data)
	return nil
}

func (a *AcsCredential) MarshalJSON() ([]byte, error) {
	type embed AcsCredential
	var marshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed:     embed(*a),
		CreatedAt: core.NewDateTime(a.CreatedAt),
	}
	return json.Marshal(marshaler)
}

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

type AcsCredentialAccessMethod string

const (
	AcsCredentialAccessMethodCode      AcsCredentialAccessMethod = "code"
	AcsCredentialAccessMethodCard      AcsCredentialAccessMethod = "card"
	AcsCredentialAccessMethodMobileKey AcsCredentialAccessMethod = "mobile_key"
)

func NewAcsCredentialAccessMethodFromString(s string) (AcsCredentialAccessMethod, error) {
	switch s {
	case "code":
		return AcsCredentialAccessMethodCode, nil
	case "card":
		return AcsCredentialAccessMethodCard, nil
	case "mobile_key":
		return AcsCredentialAccessMethodMobileKey, nil
	}
	var t AcsCredentialAccessMethod
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AcsCredentialAccessMethod) Ptr() *AcsCredentialAccessMethod {
	return &a
}

type AcsCredentialErrorsItem struct {
	ErrorCode string `json:"error_code" url:"error_code"`
	Message   string `json:"message" url:"message"`

	_rawJSON json.RawMessage
}

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

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

type AcsCredentialExternalType string

const (
	AcsCredentialExternalTypePtiCard         AcsCredentialExternalType = "pti_card"
	AcsCredentialExternalTypeBrivoCredential AcsCredentialExternalType = "brivo_credential"
	AcsCredentialExternalTypeHidCredential   AcsCredentialExternalType = "hid_credential"
	AcsCredentialExternalTypeVisionlineCard  AcsCredentialExternalType = "visionline_card"
)

func NewAcsCredentialExternalTypeFromString(s string) (AcsCredentialExternalType, error) {
	switch s {
	case "pti_card":
		return AcsCredentialExternalTypePtiCard, nil
	case "brivo_credential":
		return AcsCredentialExternalTypeBrivoCredential, nil
	case "hid_credential":
		return AcsCredentialExternalTypeHidCredential, nil
	case "visionline_card":
		return AcsCredentialExternalTypeVisionlineCard, nil
	}
	var t AcsCredentialExternalType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AcsCredentialExternalType) Ptr() *AcsCredentialExternalType {
	return &a
}

type AcsCredentialPool struct {
	AcsCredentialPoolId     string    `json:"acs_credential_pool_id" url:"acs_credential_pool_id"`
	AcsSystemId             string    `json:"acs_system_id" url:"acs_system_id"`
	DisplayName             string    `json:"display_name" url:"display_name"`
	ExternalTypeDisplayName string    `json:"external_type_display_name" url:"external_type_display_name"`
	CreatedAt               time.Time `json:"created_at" url:"created_at"`
	WorkspaceId             string    `json:"workspace_id" url:"workspace_id"`
	externalType            string

	_rawJSON json.RawMessage
}

func (a *AcsCredentialPool) ExternalType() string {
	return a.externalType
}

func (a *AcsCredentialPool) UnmarshalJSON(data []byte) error {
	type embed AcsCredentialPool
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*a),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*a = AcsCredentialPool(unmarshaler.embed)
	a.CreatedAt = unmarshaler.CreatedAt.Time()
	a.externalType = "hid_part_number"
	a._rawJSON = json.RawMessage(data)
	return nil
}

func (a *AcsCredentialPool) MarshalJSON() ([]byte, error) {
	type embed AcsCredentialPool
	var marshaler = struct {
		embed
		CreatedAt    *core.DateTime `json:"created_at"`
		ExternalType string         `json:"external_type"`
	}{
		embed:        embed(*a),
		CreatedAt:    core.NewDateTime(a.CreatedAt),
		ExternalType: "hid_part_number",
	}
	return json.Marshal(marshaler)
}

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

type AcsCredentialProvisioningAutomation struct {
	AcsCredentialProvisioningAutomationId string    `json:"acs_credential_provisioning_automation_id" url:"acs_credential_provisioning_automation_id"`
	CredentialManagerAcsSystemId          string    `json:"credential_manager_acs_system_id" url:"credential_manager_acs_system_id"`
	UserIdentityId                        string    `json:"user_identity_id" url:"user_identity_id"`
	CreatedAt                             time.Time `json:"created_at" url:"created_at"`
	WorkspaceId                           string    `json:"workspace_id" url:"workspace_id"`

	_rawJSON json.RawMessage
}

func (a *AcsCredentialProvisioningAutomation) UnmarshalJSON(data []byte) error {
	type embed AcsCredentialProvisioningAutomation
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*a),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*a = AcsCredentialProvisioningAutomation(unmarshaler.embed)
	a.CreatedAt = unmarshaler.CreatedAt.Time()
	a._rawJSON = json.RawMessage(data)
	return nil
}

func (a *AcsCredentialProvisioningAutomation) MarshalJSON() ([]byte, error) {
	type embed AcsCredentialProvisioningAutomation
	var marshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed:     embed(*a),
		CreatedAt: core.NewDateTime(a.CreatedAt),
	}
	return json.Marshal(marshaler)
}

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

type AcsCredentialVisionlineMetadata struct {
	CardFunctionType       AcsCredentialVisionlineMetadataCardFunctionType `json:"card_function_type,omitempty" url:"card_function_type,omitempty"`
	JoinerAcsCredentialIds []string                                        `json:"joiner_acs_credential_ids,omitempty" url:"joiner_acs_credential_ids,omitempty"`
	GuestAcsEntranceIds    []string                                        `json:"guest_acs_entrance_ids,omitempty" url:"guest_acs_entrance_ids,omitempty"`
	CommonAcsEntranceIds   []string                                        `json:"common_acs_entrance_ids,omitempty" url:"common_acs_entrance_ids,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type AcsCredentialVisionlineMetadataCardFunctionType string

const (
	AcsCredentialVisionlineMetadataCardFunctionTypeGuest AcsCredentialVisionlineMetadataCardFunctionType = "guest"
	AcsCredentialVisionlineMetadataCardFunctionTypeStaff AcsCredentialVisionlineMetadataCardFunctionType = "staff"
)

func NewAcsCredentialVisionlineMetadataCardFunctionTypeFromString(s string) (AcsCredentialVisionlineMetadataCardFunctionType, error) {
	switch s {
	case "guest":
		return AcsCredentialVisionlineMetadataCardFunctionTypeGuest, nil
	case "staff":
		return AcsCredentialVisionlineMetadataCardFunctionTypeStaff, nil
	}
	var t AcsCredentialVisionlineMetadataCardFunctionType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AcsCredentialVisionlineMetadataCardFunctionType) Ptr() *AcsCredentialVisionlineMetadataCardFunctionType {
	return &a
}

type AcsCredentialWarningsItem struct {
	WarningCode string `json:"warning_code" url:"warning_code"`
	Message     string `json:"message" url:"message"`

	_rawJSON json.RawMessage
}

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

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

type AcsEntrance struct {
	AcsEntranceId      string                         `json:"acs_entrance_id" url:"acs_entrance_id"`
	DisplayName        string                         `json:"display_name" url:"display_name"`
	AcsSystemId        string                         `json:"acs_system_id" url:"acs_system_id"`
	CreatedAt          time.Time                      `json:"created_at" url:"created_at"`
	LatchMetadata      *AcsEntranceLatchMetadata      `json:"latch_metadata,omitempty" url:"latch_metadata,omitempty"`
	Errors             []*AcsEntranceErrorsItem       `json:"errors,omitempty" url:"errors,omitempty"`
	VisionlineMetadata *AcsEntranceVisionlineMetadata `json:"visionline_metadata,omitempty" url:"visionline_metadata,omitempty"`

	_rawJSON json.RawMessage
}

func (a *AcsEntrance) UnmarshalJSON(data []byte) error {
	type embed AcsEntrance
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*a),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*a = AcsEntrance(unmarshaler.embed)
	a.CreatedAt = unmarshaler.CreatedAt.Time()
	a._rawJSON = json.RawMessage(data)
	return nil
}

func (a *AcsEntrance) MarshalJSON() ([]byte, error) {
	type embed AcsEntrance
	var marshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed:     embed(*a),
		CreatedAt: core.NewDateTime(a.CreatedAt),
	}
	return json.Marshal(marshaler)
}

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

type AcsEntranceErrorsItem struct {
	ErrorCode string `json:"error_code" url:"error_code"`
	Message   string `json:"message" url:"message"`

	_rawJSON json.RawMessage
}

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

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

type AcsEntranceLatchMetadata struct {
	AccessibilityType string `json:"accessibility_type" url:"accessibility_type"`
	DoorName          string `json:"door_name" url:"door_name"`
	DoorType          string `json:"door_type" url:"door_type"`
	IsConnected       bool   `json:"is_connected" url:"is_connected"`

	_rawJSON json.RawMessage
}

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

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

type AcsEntranceVisionlineMetadata struct {
	DoorName     string                                       `json:"door_name" url:"door_name"`
	DoorCategory AcsEntranceVisionlineMetadataDoorCategory    `json:"door_category,omitempty" url:"door_category,omitempty"`
	Profiles     []*AcsEntranceVisionlineMetadataProfilesItem `json:"profiles,omitempty" url:"profiles,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type AcsEntranceVisionlineMetadataDoorCategory string

const (
	AcsEntranceVisionlineMetadataDoorCategoryEntrance       AcsEntranceVisionlineMetadataDoorCategory = "entrance"
	AcsEntranceVisionlineMetadataDoorCategoryGuest          AcsEntranceVisionlineMetadataDoorCategory = "guest"
	AcsEntranceVisionlineMetadataDoorCategoryElevatorReader AcsEntranceVisionlineMetadataDoorCategory = "elevator reader"
	AcsEntranceVisionlineMetadataDoorCategoryCommon         AcsEntranceVisionlineMetadataDoorCategory = "common"
	AcsEntranceVisionlineMetadataDoorCategoryCommonPms      AcsEntranceVisionlineMetadataDoorCategory = "common (PMS)"
)

func NewAcsEntranceVisionlineMetadataDoorCategoryFromString(s string) (AcsEntranceVisionlineMetadataDoorCategory, error) {
	switch s {
	case "entrance":
		return AcsEntranceVisionlineMetadataDoorCategoryEntrance, nil
	case "guest":
		return AcsEntranceVisionlineMetadataDoorCategoryGuest, nil
	case "elevator reader":
		return AcsEntranceVisionlineMetadataDoorCategoryElevatorReader, nil
	case "common":
		return AcsEntranceVisionlineMetadataDoorCategoryCommon, nil
	case "common (PMS)":
		return AcsEntranceVisionlineMetadataDoorCategoryCommonPms, nil
	}
	var t AcsEntranceVisionlineMetadataDoorCategory
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AcsEntranceVisionlineMetadataDoorCategory) Ptr() *AcsEntranceVisionlineMetadataDoorCategory {
	return &a
}

type AcsEntranceVisionlineMetadataProfilesItem struct {
	VisionlineDoorProfileId   string                                                             `json:"visionline_door_profile_id" url:"visionline_door_profile_id"`
	VisionlineDoorProfileType AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileType `json:"visionline_door_profile_type,omitempty" url:"visionline_door_profile_type,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileType string

const (
	AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileTypeBle        AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileType = "BLE"
	AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileTypeCommonDoor AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileType = "commonDoor"
	AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileTypeTouch      AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileType = "touch"
)

func NewAcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileTypeFromString(s string) (AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileType, error) {
	switch s {
	case "BLE":
		return AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileTypeBle, nil
	case "commonDoor":
		return AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileTypeCommonDoor, nil
	case "touch":
		return AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileTypeTouch, nil
	}
	var t AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileType) Ptr() *AcsEntranceVisionlineMetadataProfilesItemVisionlineDoorProfileType {
	return &a
}

type AcsSystem struct {
	AcsSystemId             string                 `json:"acs_system_id" url:"acs_system_id"`
	ExternalType            *AcsSystemExternalType `json:"external_type,omitempty" url:"external_type,omitempty"`
	ExternalTypeDisplayName *string                `json:"external_type_display_name,omitempty" url:"external_type_display_name,omitempty"`
	// ---
	// deprecated: use external_type
	// ---
	SystemType *AcsSystemSystemType `json:"system_type,omitempty" url:"system_type,omitempty"`
	// ---
	// deprecated: use external_type_display_name
	// ---
	SystemTypeDisplayName                *string   `json:"system_type_display_name,omitempty" url:"system_type_display_name,omitempty"`
	Name                                 string    `json:"name" url:"name"`
	CreatedAt                            time.Time `json:"created_at" url:"created_at"`
	WorkspaceId                          string    `json:"workspace_id" url:"workspace_id"`
	ConnectedAccountIds                  []string  `json:"connected_account_ids,omitempty" url:"connected_account_ids,omitempty"`
	ImageUrl                             string    `json:"image_url" url:"image_url"`
	ImageAltText                         string    `json:"image_alt_text" url:"image_alt_text"`
	CanAutomateEnrollment                *bool     `json:"can_automate_enrollment,omitempty" url:"can_automate_enrollment,omitempty"`
	CanCreateAcsAccessGroups             *bool     `json:"can_create_acs_access_groups,omitempty" url:"can_create_acs_access_groups,omitempty"`
	CanRemoveAcsUsersFromAcsAccessGroups *bool     `json:"can_remove_acs_users_from_acs_access_groups,omitempty" url:"can_remove_acs_users_from_acs_access_groups,omitempty"`
	CanAddAcsUsersToAcsAccessGroups      *bool     `json:"can_add_acs_users_to_acs_access_groups,omitempty" url:"can_add_acs_users_to_acs_access_groups,omitempty"`

	_rawJSON json.RawMessage
}

func (a *AcsSystem) UnmarshalJSON(data []byte) error {
	type embed AcsSystem
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*a),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*a = AcsSystem(unmarshaler.embed)
	a.CreatedAt = unmarshaler.CreatedAt.Time()
	a._rawJSON = json.RawMessage(data)
	return nil
}

func (a *AcsSystem) MarshalJSON() ([]byte, error) {
	type embed AcsSystem
	var marshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed:     embed(*a),
		CreatedAt: core.NewDateTime(a.CreatedAt),
	}
	return json.Marshal(marshaler)
}

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

type AcsSystemExternalType string

const (
	AcsSystemExternalTypePtiSite                          AcsSystemExternalType = "pti_site"
	AcsSystemExternalTypeAltaOrg                          AcsSystemExternalType = "alta_org"
	AcsSystemExternalTypeSaltoSite                        AcsSystemExternalType = "salto_site"
	AcsSystemExternalTypeBrivoAccount                     AcsSystemExternalType = "brivo_account"
	AcsSystemExternalTypeHidCredentialManagerOrganization AcsSystemExternalType = "hid_credential_manager_organization"
	AcsSystemExternalTypeVisionlineSystem                 AcsSystemExternalType = "visionline_system"
	AcsSystemExternalTypeAssaAbloyCredentialService       AcsSystemExternalType = "assa_abloy_credential_service"
	AcsSystemExternalTypeLatchBuilding                    AcsSystemExternalType = "latch_building"
)

func NewAcsSystemExternalTypeFromString(s string) (AcsSystemExternalType, error) {
	switch s {
	case "pti_site":
		return AcsSystemExternalTypePtiSite, nil
	case "alta_org":
		return AcsSystemExternalTypeAltaOrg, nil
	case "salto_site":
		return AcsSystemExternalTypeSaltoSite, nil
	case "brivo_account":
		return AcsSystemExternalTypeBrivoAccount, nil
	case "hid_credential_manager_organization":
		return AcsSystemExternalTypeHidCredentialManagerOrganization, nil
	case "visionline_system":
		return AcsSystemExternalTypeVisionlineSystem, nil
	case "assa_abloy_credential_service":
		return AcsSystemExternalTypeAssaAbloyCredentialService, nil
	case "latch_building":
		return AcsSystemExternalTypeLatchBuilding, nil
	}
	var t AcsSystemExternalType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AcsSystemExternalType) Ptr() *AcsSystemExternalType {
	return &a
}

// ---
// deprecated: use external_type
// ---
type AcsSystemSystemType string

const (
	AcsSystemSystemTypePtiSite                          AcsSystemSystemType = "pti_site"
	AcsSystemSystemTypeAltaOrg                          AcsSystemSystemType = "alta_org"
	AcsSystemSystemTypeSaltoSite                        AcsSystemSystemType = "salto_site"
	AcsSystemSystemTypeBrivoAccount                     AcsSystemSystemType = "brivo_account"
	AcsSystemSystemTypeHidCredentialManagerOrganization AcsSystemSystemType = "hid_credential_manager_organization"
	AcsSystemSystemTypeVisionlineSystem                 AcsSystemSystemType = "visionline_system"
	AcsSystemSystemTypeAssaAbloyCredentialService       AcsSystemSystemType = "assa_abloy_credential_service"
	AcsSystemSystemTypeLatchBuilding                    AcsSystemSystemType = "latch_building"
)

func NewAcsSystemSystemTypeFromString(s string) (AcsSystemSystemType, error) {
	switch s {
	case "pti_site":
		return AcsSystemSystemTypePtiSite, nil
	case "alta_org":
		return AcsSystemSystemTypeAltaOrg, nil
	case "salto_site":
		return AcsSystemSystemTypeSaltoSite, nil
	case "brivo_account":
		return AcsSystemSystemTypeBrivoAccount, nil
	case "hid_credential_manager_organization":
		return AcsSystemSystemTypeHidCredentialManagerOrganization, nil
	case "visionline_system":
		return AcsSystemSystemTypeVisionlineSystem, nil
	case "assa_abloy_credential_service":
		return AcsSystemSystemTypeAssaAbloyCredentialService, nil
	case "latch_building":
		return AcsSystemSystemTypeLatchBuilding, nil
	}
	var t AcsSystemSystemType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AcsSystemSystemType) Ptr() *AcsSystemSystemType {
	return &a
}

type AcsUser struct {
	AcsUserId                string                 `json:"acs_user_id" url:"acs_user_id"`
	AcsSystemId              string                 `json:"acs_system_id" url:"acs_system_id"`
	HidAcsSystemId           *string                `json:"hid_acs_system_id,omitempty" url:"hid_acs_system_id,omitempty"`
	WorkspaceId              string                 `json:"workspace_id" url:"workspace_id"`
	CreatedAt                time.Time              `json:"created_at" url:"created_at"`
	DisplayName              string                 `json:"display_name" url:"display_name"`
	ExternalType             *AcsUserExternalType   `json:"external_type,omitempty" url:"external_type,omitempty"`
	ExternalTypeDisplayName  *string                `json:"external_type_display_name,omitempty" url:"external_type_display_name,omitempty"`
	IsSuspended              bool                   `json:"is_suspended" url:"is_suspended"`
	AccessSchedule           *AcsUserAccessSchedule `json:"access_schedule,omitempty" url:"access_schedule,omitempty"`
	UserIdentityId           *string                `json:"user_identity_id,omitempty" url:"user_identity_id,omitempty"`
	UserIdentityFullName     *string                `json:"user_identity_full_name,omitempty" url:"user_identity_full_name,omitempty"`
	UserIdentityEmailAddress *string                `json:"user_identity_email_address,omitempty" url:"user_identity_email_address,omitempty"`
	UserIdentityPhoneNumber  *string                `json:"user_identity_phone_number,omitempty" url:"user_identity_phone_number,omitempty"`
	FullName                 *string                `json:"full_name,omitempty" url:"full_name,omitempty"`
	// ---
	// deprecated: use email_address.
	// ---
	Email        *string `json:"email,omitempty" url:"email,omitempty"`
	EmailAddress *string `json:"email_address,omitempty" url:"email_address,omitempty"`
	PhoneNumber  *string `json:"phone_number,omitempty" url:"phone_number,omitempty"`

	_rawJSON json.RawMessage
}

func (a *AcsUser) UnmarshalJSON(data []byte) error {
	type embed AcsUser
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*a),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*a = AcsUser(unmarshaler.embed)
	a.CreatedAt = unmarshaler.CreatedAt.Time()
	a._rawJSON = json.RawMessage(data)
	return nil
}

func (a *AcsUser) MarshalJSON() ([]byte, error) {
	type embed AcsUser
	var marshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed:     embed(*a),
		CreatedAt: core.NewDateTime(a.CreatedAt),
	}
	return json.Marshal(marshaler)
}

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

type AcsUserAccessSchedule struct {
	StartsAt time.Time `json:"starts_at" url:"starts_at"`
	EndsAt   time.Time `json:"ends_at" url:"ends_at"`

	_rawJSON json.RawMessage
}

func (a *AcsUserAccessSchedule) UnmarshalJSON(data []byte) error {
	type embed AcsUserAccessSchedule
	var unmarshaler = struct {
		embed
		StartsAt *core.DateTime `json:"starts_at"`
		EndsAt   *core.DateTime `json:"ends_at"`
	}{
		embed: embed(*a),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*a = AcsUserAccessSchedule(unmarshaler.embed)
	a.StartsAt = unmarshaler.StartsAt.Time()
	a.EndsAt = unmarshaler.EndsAt.Time()
	a._rawJSON = json.RawMessage(data)
	return nil
}

func (a *AcsUserAccessSchedule) MarshalJSON() ([]byte, error) {
	type embed AcsUserAccessSchedule
	var marshaler = struct {
		embed
		StartsAt *core.DateTime `json:"starts_at"`
		EndsAt   *core.DateTime `json:"ends_at"`
	}{
		embed:    embed(*a),
		StartsAt: core.NewDateTime(a.StartsAt),
		EndsAt:   core.NewDateTime(a.EndsAt),
	}
	return json.Marshal(marshaler)
}

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

type AcsUserExternalType string

const (
	AcsUserExternalTypePtiUser                  AcsUserExternalType = "pti_user"
	AcsUserExternalTypeBrivoUser                AcsUserExternalType = "brivo_user"
	AcsUserExternalTypeHidCredentialManagerUser AcsUserExternalType = "hid_credential_manager_user"
	AcsUserExternalTypeSaltoSiteUser            AcsUserExternalType = "salto_site_user"
	AcsUserExternalTypeLatchUser                AcsUserExternalType = "latch_user"
)

func NewAcsUserExternalTypeFromString(s string) (AcsUserExternalType, error) {
	switch s {
	case "pti_user":
		return AcsUserExternalTypePtiUser, nil
	case "brivo_user":
		return AcsUserExternalTypeBrivoUser, nil
	case "hid_credential_manager_user":
		return AcsUserExternalTypeHidCredentialManagerUser, nil
	case "salto_site_user":
		return AcsUserExternalTypeSaltoSiteUser, nil
	case "latch_user":
		return AcsUserExternalTypeLatchUser, nil
	}
	var t AcsUserExternalType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AcsUserExternalType) Ptr() *AcsUserExternalType {
	return &a
}

type ActionAttempt struct {
	Status  string
	Success *ActionAttemptSuccess
	Pending *ActionAttemptPending
	Error   *ActionAttemptError
}

func NewActionAttemptFromSuccess(value *ActionAttemptSuccess) *ActionAttempt {
	return &ActionAttempt{Status: "success", Success: value}
}

func NewActionAttemptFromPending(value *ActionAttemptPending) *ActionAttempt {
	return &ActionAttempt{Status: "pending", Pending: value}
}

func NewActionAttemptFromError(value *ActionAttemptError) *ActionAttempt {
	return &ActionAttempt{Status: "error", Error: value}
}

func (a *ActionAttempt) UnmarshalJSON(data []byte) error {
	var unmarshaler struct {
		Status string `json:"status"`
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	a.Status = unmarshaler.Status
	switch unmarshaler.Status {
	case "success":
		value := new(ActionAttemptSuccess)
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		a.Success = value
	case "pending":
		value := new(ActionAttemptPending)
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		a.Pending = value
	case "error":
		value := new(ActionAttemptError)
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		a.Error = value
	}
	return nil
}

func (a ActionAttempt) MarshalJSON() ([]byte, error) {
	switch a.Status {
	default:
		return nil, fmt.Errorf("invalid type %s in %T", a.Status, a)
	case "success":
		var marshaler = struct {
			Status string `json:"status"`
			*ActionAttemptSuccess
		}{
			Status:               a.Status,
			ActionAttemptSuccess: a.Success,
		}
		return json.Marshal(marshaler)
	case "pending":
		var marshaler = struct {
			Status string `json:"status"`
			*ActionAttemptPending
		}{
			Status:               a.Status,
			ActionAttemptPending: a.Pending,
		}
		return json.Marshal(marshaler)
	case "error":
		var marshaler = struct {
			Status string `json:"status"`
			*ActionAttemptError
		}{
			Status:             a.Status,
			ActionAttemptError: a.Error,
		}
		return json.Marshal(marshaler)
	}
}

type ActionAttemptVisitor interface {
	VisitSuccess(*ActionAttemptSuccess) error
	VisitPending(*ActionAttemptPending) error
	VisitError(*ActionAttemptError) error
}

func (a *ActionAttempt) Accept(visitor ActionAttemptVisitor) error {
	switch a.Status {
	default:
		return fmt.Errorf("invalid type %s in %T", a.Status, a)
	case "success":
		return visitor.VisitSuccess(a.Success)
	case "pending":
		return visitor.VisitPending(a.Pending)
	case "error":
		return visitor.VisitError(a.Error)
	}
}

type ActionAttemptError struct {
	ActionType      string                   `json:"action_type" url:"action_type"`
	ActionAttemptId string                   `json:"action_attempt_id" url:"action_attempt_id"`
	Result          *string                  `json:"result,omitempty" url:"result,omitempty"`
	Error           *ActionAttemptErrorError `json:"error,omitempty" url:"error,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type ActionAttemptErrorError struct {
	Type    string `json:"type" url:"type"`
	Message string `json:"message" url:"message"`

	_rawJSON json.RawMessage
}

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

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

type ActionAttemptPending struct {
	ActionType      string  `json:"action_type" url:"action_type"`
	ActionAttemptId string  `json:"action_attempt_id" url:"action_attempt_id"`
	Result          *string `json:"result,omitempty" url:"result,omitempty"`
	Error           *string `json:"error,omitempty" url:"error,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type ActionAttemptSuccess struct {
	ActionType      string      `json:"action_type" url:"action_type"`
	ActionAttemptId string      `json:"action_attempt_id" url:"action_attempt_id"`
	Result          interface{} `json:"result,omitempty" url:"result,omitempty"`
	Error           *string     `json:"error,omitempty" url:"error,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type ClientSession struct {
	ClientSessionId     string    `json:"client_session_id" url:"client_session_id"`
	UserIdentifierKey   *string   `json:"user_identifier_key,omitempty" url:"user_identifier_key,omitempty"`
	CreatedAt           time.Time `json:"created_at" url:"created_at"`
	Token               string    `json:"token" url:"token"`
	DeviceCount         float64   `json:"device_count" url:"device_count"`
	ConnectedAccountIds []string  `json:"connected_account_ids,omitempty" url:"connected_account_ids,omitempty"`
	ConnectWebviewIds   []string  `json:"connect_webview_ids,omitempty" url:"connect_webview_ids,omitempty"`
	UserIdentityIds     []string  `json:"user_identity_ids,omitempty" url:"user_identity_ids,omitempty"`
	WorkspaceId         string    `json:"workspace_id" url:"workspace_id"`

	_rawJSON json.RawMessage
}

func (c *ClientSession) UnmarshalJSON(data []byte) error {
	type embed ClientSession
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*c),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*c = ClientSession(unmarshaler.embed)
	c.CreatedAt = unmarshaler.CreatedAt.Time()
	c._rawJSON = json.RawMessage(data)
	return nil
}

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

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

type ClimateSettingSchedule struct {
	ClimateSettingScheduleId  string                                 `json:"climate_setting_schedule_id" url:"climate_setting_schedule_id"`
	DeviceId                  string                                 `json:"device_id" url:"device_id"`
	Name                      *string                                `json:"name,omitempty" url:"name,omitempty"`
	ScheduleStartsAt          string                                 `json:"schedule_starts_at" url:"schedule_starts_at"`
	ScheduleEndsAt            string                                 `json:"schedule_ends_at" url:"schedule_ends_at"`
	CreatedAt                 time.Time                              `json:"created_at" url:"created_at"`
	Errors                    interface{}                            `json:"errors,omitempty" url:"errors,omitempty"`
	AutomaticHeatingEnabled   *bool                                  `json:"automatic_heating_enabled,omitempty" url:"automatic_heating_enabled,omitempty"`
	AutomaticCoolingEnabled   *bool                                  `json:"automatic_cooling_enabled,omitempty" url:"automatic_cooling_enabled,omitempty"`
	HvacModeSetting           *ClimateSettingScheduleHvacModeSetting `json:"hvac_mode_setting,omitempty" url:"hvac_mode_setting,omitempty"`
	CoolingSetPointCelsius    *float64                               `json:"cooling_set_point_celsius,omitempty" url:"cooling_set_point_celsius,omitempty"`
	HeatingSetPointCelsius    *float64                               `json:"heating_set_point_celsius,omitempty" url:"heating_set_point_celsius,omitempty"`
	CoolingSetPointFahrenheit *float64                               `json:"cooling_set_point_fahrenheit,omitempty" url:"cooling_set_point_fahrenheit,omitempty"`
	HeatingSetPointFahrenheit *float64                               `json:"heating_set_point_fahrenheit,omitempty" url:"heating_set_point_fahrenheit,omitempty"`
	ManualOverrideAllowed     *bool                                  `json:"manual_override_allowed,omitempty" url:"manual_override_allowed,omitempty"`
	scheduleType              string

	_rawJSON json.RawMessage
}

func (c *ClimateSettingSchedule) ScheduleType() string {
	return c.scheduleType
}

func (c *ClimateSettingSchedule) UnmarshalJSON(data []byte) error {
	type embed ClimateSettingSchedule
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*c),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*c = ClimateSettingSchedule(unmarshaler.embed)
	c.CreatedAt = unmarshaler.CreatedAt.Time()
	c.scheduleType = "time_bound"
	c._rawJSON = json.RawMessage(data)
	return nil
}

func (c *ClimateSettingSchedule) MarshalJSON() ([]byte, error) {
	type embed ClimateSettingSchedule
	var marshaler = struct {
		embed
		CreatedAt    *core.DateTime `json:"created_at"`
		ScheduleType string         `json:"schedule_type"`
	}{
		embed:        embed(*c),
		CreatedAt:    core.NewDateTime(c.CreatedAt),
		ScheduleType: "time_bound",
	}
	return json.Marshal(marshaler)
}

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

type ClimateSettingScheduleHvacModeSetting string

const (
	ClimateSettingScheduleHvacModeSettingOff      ClimateSettingScheduleHvacModeSetting = "off"
	ClimateSettingScheduleHvacModeSettingHeat     ClimateSettingScheduleHvacModeSetting = "heat"
	ClimateSettingScheduleHvacModeSettingCool     ClimateSettingScheduleHvacModeSetting = "cool"
	ClimateSettingScheduleHvacModeSettingHeatCool ClimateSettingScheduleHvacModeSetting = "heat_cool"
)

func NewClimateSettingScheduleHvacModeSettingFromString(s string) (ClimateSettingScheduleHvacModeSetting, error) {
	switch s {
	case "off":
		return ClimateSettingScheduleHvacModeSettingOff, nil
	case "heat":
		return ClimateSettingScheduleHvacModeSettingHeat, nil
	case "cool":
		return ClimateSettingScheduleHvacModeSettingCool, nil
	case "heat_cool":
		return ClimateSettingScheduleHvacModeSettingHeatCool, nil
	}
	var t ClimateSettingScheduleHvacModeSetting
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type ConnectWebview struct {
	ConnectWebviewId    string        `json:"connect_webview_id" url:"connect_webview_id"`
	WorkspaceId         string        `json:"workspace_id" url:"workspace_id"`
	CreatedAt           time.Time     `json:"created_at" url:"created_at"`
	ConnectedAccountId  *string       `json:"connected_account_id,omitempty" url:"connected_account_id,omitempty"`
	Url                 string        `json:"url" url:"url"`
	DeviceSelectionMode SelectionMode `json:"device_selection_mode,omitempty" url:"device_selection_mode,omitempty"`
	AcceptedProviders   []string      `json:"accepted_providers,omitempty" url:"accepted_providers,omitempty"`
	// ---
	// deprecated: Unused. Will be removed.
	// ---
	AcceptedDevices []string `json:"accepted_devices,omitempty" url:"accepted_devices,omitempty"`
	// ---
	// deprecated: Unused. Will be removed.
	// ---
	AnyDeviceAllowed              bool                                          `json:"any_device_allowed" url:"any_device_allowed"`
	AnyProviderAllowed            bool                                          `json:"any_provider_allowed" url:"any_provider_allowed"`
	LoginSuccessful               bool                                          `json:"login_successful" url:"login_successful"`
	Status                        ConnectWebviewStatus                          `json:"status,omitempty" url:"status,omitempty"`
	CustomRedirectUrl             *string                                       `json:"custom_redirect_url,omitempty" url:"custom_redirect_url,omitempty"`
	CustomRedirectFailureUrl      *string                                       `json:"custom_redirect_failure_url,omitempty" url:"custom_redirect_failure_url,omitempty"`
	CustomMetadata                map[string]*ConnectWebviewCustomMetadataValue `json:"custom_metadata,omitempty" url:"custom_metadata,omitempty"`
	AutomaticallyManageNewDevices bool                                          `json:"automatically_manage_new_devices" url:"automatically_manage_new_devices"`
	WaitForDeviceCreation         bool                                          `json:"wait_for_device_creation" url:"wait_for_device_creation"`
	AuthorizedAt                  *time.Time                                    `json:"authorized_at,omitempty" url:"authorized_at,omitempty"`
	SelectedProvider              *string                                       `json:"selected_provider,omitempty" url:"selected_provider,omitempty"`

	_rawJSON json.RawMessage
}

func (c *ConnectWebview) UnmarshalJSON(data []byte) error {
	type embed ConnectWebview
	var unmarshaler = struct {
		embed
		CreatedAt    *core.DateTime `json:"created_at"`
		AuthorizedAt *core.DateTime `json:"authorized_at,omitempty"`
	}{
		embed: embed(*c),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*c = ConnectWebview(unmarshaler.embed)
	c.CreatedAt = unmarshaler.CreatedAt.Time()
	c.AuthorizedAt = unmarshaler.AuthorizedAt.TimePtr()
	c._rawJSON = json.RawMessage(data)
	return nil
}

func (c *ConnectWebview) MarshalJSON() ([]byte, error) {
	type embed ConnectWebview
	var marshaler = struct {
		embed
		CreatedAt    *core.DateTime `json:"created_at"`
		AuthorizedAt *core.DateTime `json:"authorized_at,omitempty"`
	}{
		embed:        embed(*c),
		CreatedAt:    core.NewDateTime(c.CreatedAt),
		AuthorizedAt: core.NewOptionalDateTime(c.AuthorizedAt),
	}
	return json.Marshal(marshaler)
}

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

type ConnectWebviewCustomMetadataValue struct {
	typeName string
	String   string
	Boolean  bool
}

func NewConnectWebviewCustomMetadataValueFromString(value string) *ConnectWebviewCustomMetadataValue {
	return &ConnectWebviewCustomMetadataValue{typeName: "string", String: value}
}

func NewConnectWebviewCustomMetadataValueFromBoolean(value bool) *ConnectWebviewCustomMetadataValue {
	return &ConnectWebviewCustomMetadataValue{typeName: "boolean", Boolean: value}
}

func (c *ConnectWebviewCustomMetadataValue) UnmarshalJSON(data []byte) error {
	var valueString string
	if err := json.Unmarshal(data, &valueString); err == nil {
		c.typeName = "string"
		c.String = valueString
		return nil
	}
	var valueBoolean bool
	if err := json.Unmarshal(data, &valueBoolean); err == nil {
		c.typeName = "boolean"
		c.Boolean = valueBoolean
		return nil
	}
	return fmt.Errorf("%s cannot be deserialized as a %T", data, c)
}

func (c ConnectWebviewCustomMetadataValue) MarshalJSON() ([]byte, error) {
	switch c.typeName {
	default:
		return nil, fmt.Errorf("invalid type %s in %T", c.typeName, c)
	case "string":
		return json.Marshal(c.String)
	case "boolean":
		return json.Marshal(c.Boolean)
	}
}

type ConnectWebviewCustomMetadataValueVisitor interface {
	VisitString(string) error
	VisitBoolean(bool) error
}

func (c *ConnectWebviewCustomMetadataValue) Accept(visitor ConnectWebviewCustomMetadataValueVisitor) error {
	switch c.typeName {
	default:
		return fmt.Errorf("invalid type %s in %T", c.typeName, c)
	case "string":
		return visitor.VisitString(c.String)
	case "boolean":
		return visitor.VisitBoolean(c.Boolean)
	}
}

type ConnectWebviewStatus string

const (
	ConnectWebviewStatusPending    ConnectWebviewStatus = "pending"
	ConnectWebviewStatusFailed     ConnectWebviewStatus = "failed"
	ConnectWebviewStatusAuthorized ConnectWebviewStatus = "authorized"
)

func NewConnectWebviewStatusFromString(s string) (ConnectWebviewStatus, error) {
	switch s {
	case "pending":
		return ConnectWebviewStatusPending, nil
	case "failed":
		return ConnectWebviewStatusFailed, nil
	case "authorized":
		return ConnectWebviewStatusAuthorized, nil
	}
	var t ConnectWebviewStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type ConnectedAccount struct {
	ConnectedAccountId            *string                                         `json:"connected_account_id,omitempty" url:"connected_account_id,omitempty"`
	CreatedAt                     *time.Time                                      `json:"created_at,omitempty" url:"created_at,omitempty"`
	UserIdentifier                *ConnectedAccountUserIdentifier                 `json:"user_identifier,omitempty" url:"user_identifier,omitempty"`
	AccountType                   *string                                         `json:"account_type,omitempty" url:"account_type,omitempty"`
	AccountTypeDisplayName        string                                          `json:"account_type_display_name" url:"account_type_display_name"`
	Errors                        interface{}                                     `json:"errors,omitempty" url:"errors,omitempty"`
	Warnings                      interface{}                                     `json:"warnings,omitempty" url:"warnings,omitempty"`
	CustomMetadata                map[string]*ConnectedAccountCustomMetadataValue `json:"custom_metadata,omitempty" url:"custom_metadata,omitempty"`
	AutomaticallyManageNewDevices bool                                            `json:"automatically_manage_new_devices" url:"automatically_manage_new_devices"`

	_rawJSON json.RawMessage
}

func (c *ConnectedAccount) UnmarshalJSON(data []byte) error {
	type embed ConnectedAccount
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at,omitempty"`
	}{
		embed: embed(*c),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*c = ConnectedAccount(unmarshaler.embed)
	c.CreatedAt = unmarshaler.CreatedAt.TimePtr()
	c._rawJSON = json.RawMessage(data)
	return nil
}

func (c *ConnectedAccount) MarshalJSON() ([]byte, error) {
	type embed ConnectedAccount
	var marshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at,omitempty"`
	}{
		embed:     embed(*c),
		CreatedAt: core.NewOptionalDateTime(c.CreatedAt),
	}
	return json.Marshal(marshaler)
}

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

type ConnectedAccountCustomMetadataValue struct {
	typeName string
	String   string
	Boolean  bool
}

func NewConnectedAccountCustomMetadataValueFromString(value string) *ConnectedAccountCustomMetadataValue {
	return &ConnectedAccountCustomMetadataValue{typeName: "string", String: value}
}

func NewConnectedAccountCustomMetadataValueFromBoolean(value bool) *ConnectedAccountCustomMetadataValue {
	return &ConnectedAccountCustomMetadataValue{typeName: "boolean", Boolean: value}
}

func (c *ConnectedAccountCustomMetadataValue) UnmarshalJSON(data []byte) error {
	var valueString string
	if err := json.Unmarshal(data, &valueString); err == nil {
		c.typeName = "string"
		c.String = valueString
		return nil
	}
	var valueBoolean bool
	if err := json.Unmarshal(data, &valueBoolean); err == nil {
		c.typeName = "boolean"
		c.Boolean = valueBoolean
		return nil
	}
	return fmt.Errorf("%s cannot be deserialized as a %T", data, c)
}

func (c ConnectedAccountCustomMetadataValue) MarshalJSON() ([]byte, error) {
	switch c.typeName {
	default:
		return nil, fmt.Errorf("invalid type %s in %T", c.typeName, c)
	case "string":
		return json.Marshal(c.String)
	case "boolean":
		return json.Marshal(c.Boolean)
	}
}

type ConnectedAccountCustomMetadataValueVisitor interface {
	VisitString(string) error
	VisitBoolean(bool) error
}

func (c *ConnectedAccountCustomMetadataValue) Accept(visitor ConnectedAccountCustomMetadataValueVisitor) error {
	switch c.typeName {
	default:
		return fmt.Errorf("invalid type %s in %T", c.typeName, c)
	case "string":
		return visitor.VisitString(c.String)
	case "boolean":
		return visitor.VisitBoolean(c.Boolean)
	}
}

type ConnectedAccountUserIdentifier struct {
	Username  *string `json:"username,omitempty" url:"username,omitempty"`
	ApiUrl    *string `json:"api_url,omitempty" url:"api_url,omitempty"`
	Email     *string `json:"email,omitempty" url:"email,omitempty"`
	Phone     *string `json:"phone,omitempty" url:"phone,omitempty"`
	Exclusive *bool   `json:"exclusive,omitempty" url:"exclusive,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type Device struct {
	// Unique identifier for the device.
	DeviceId string `json:"device_id" url:"device_id"`
	// Type of the device.
	DeviceType DeviceType `json:"device_type,omitempty" url:"device_type,omitempty"`
	// Optional nickname to describe the device, settable through Seam
	Nickname *string `json:"nickname,omitempty" url:"nickname,omitempty"`
	// Display name of the device, defaults to nickname (if it is set) or properties.appearance.name otherwise. Enables administrators and users to identify the device easily, especially when there are numerous devices.
	DisplayName string `json:"display_name" url:"display_name"`
	// Collection of capabilities that the device supports when connected to Seam. Values are "access_code," which indicates that the device can manage and utilize digital PIN codes for secure access; "lock," which indicates that the device controls a door locking mechanism, enabling the remote opening and closing of doors and other entry points; "noise_detection," which indicates that the device supports monitoring and responding to ambient noise levels; "thermostat," which indicates that the device can regulate and adjust indoor temperatures; and "battery," which indicates that the device can manage battery life and health.
	CapabilitiesSupported []DeviceCapabilitiesSupportedItem `json:"capabilities_supported,omitempty" url:"capabilities_supported,omitempty"`
	// Properties of the device.
	Properties *DeviceProperties `json:"properties,omitempty" url:"properties,omitempty"`
	// Location information for the device.
	Location *DeviceLocation `json:"location,omitempty" url:"location,omitempty"`
	// Unique identifier for the account associated with the device.
	ConnectedAccountId string `json:"connected_account_id" url:"connected_account_id"`
	// Unique identifier for the Seam workspace associated with the device.
	WorkspaceId string `json:"workspace_id" url:"workspace_id"`
	// Array of errors associated with the device. Each error object within the array contains two fields: "error_code" and "message." "error_code" is a string that uniquely identifies the type of error, enabling quick recognition and categorization of the issue. "message" provides a more detailed description of the error, offering insights into the issue and potentially how to rectify it.
	Errors []*DeviceErrorsItem `json:"errors,omitempty" url:"errors,omitempty"`
	// Array of warnings associated with the device. Each warning object within the array contains two fields: "warning_code" and "message." "warning_code" is a string that uniquely identifies the type of warning, enabling quick recognition and categorization of the issue. "message" provides a more detailed description of the warning, offering insights into the issue and potentially how to rectify it.
	Warnings []*DeviceWarningsItem `json:"warnings,omitempty" url:"warnings,omitempty"`
	// Date and time at which the device object was created.
	CreatedAt time.Time `json:"created_at" url:"created_at"`
	// Indicates whether Seam manages the device.
	IsManaged                    bool                                  `json:"is_managed" url:"is_managed"`
	CustomMetadata               map[string]*DeviceCustomMetadataValue `json:"custom_metadata,omitempty" url:"custom_metadata,omitempty"`
	CanRemotelyUnlock            *bool                                 `json:"can_remotely_unlock,omitempty" url:"can_remotely_unlock,omitempty"`
	CanRemotelyLock              *bool                                 `json:"can_remotely_lock,omitempty" url:"can_remotely_lock,omitempty"`
	CanProgramOfflineAccessCodes *bool                                 `json:"can_program_offline_access_codes,omitempty" url:"can_program_offline_access_codes,omitempty"`
	CanProgramOnlineAccessCodes  *bool                                 `json:"can_program_online_access_codes,omitempty" url:"can_program_online_access_codes,omitempty"`
	CanSimulateRemoval           *bool                                 `json:"can_simulate_removal,omitempty" url:"can_simulate_removal,omitempty"`

	_rawJSON json.RawMessage
}

func (d *Device) UnmarshalJSON(data []byte) error {
	type embed Device
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*d),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*d = Device(unmarshaler.embed)
	d.CreatedAt = unmarshaler.CreatedAt.Time()
	d._rawJSON = json.RawMessage(data)
	return nil
}

func (d *Device) MarshalJSON() ([]byte, error) {
	type embed Device
	var marshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed:     embed(*d),
		CreatedAt: core.NewDateTime(d.CreatedAt),
	}
	return json.Marshal(marshaler)
}

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

type DeviceCapabilitiesSupportedItem string

const (
	DeviceCapabilitiesSupportedItemAccessCode     DeviceCapabilitiesSupportedItem = "access_code"
	DeviceCapabilitiesSupportedItemLock           DeviceCapabilitiesSupportedItem = "lock"
	DeviceCapabilitiesSupportedItemNoiseDetection DeviceCapabilitiesSupportedItem = "noise_detection"
	DeviceCapabilitiesSupportedItemThermostat     DeviceCapabilitiesSupportedItem = "thermostat"
	DeviceCapabilitiesSupportedItemBattery        DeviceCapabilitiesSupportedItem = "battery"
	DeviceCapabilitiesSupportedItemPhone          DeviceCapabilitiesSupportedItem = "phone"
)

func NewDeviceCapabilitiesSupportedItemFromString(s string) (DeviceCapabilitiesSupportedItem, error) {
	switch s {
	case "access_code":
		return DeviceCapabilitiesSupportedItemAccessCode, nil
	case "lock":
		return DeviceCapabilitiesSupportedItemLock, nil
	case "noise_detection":
		return DeviceCapabilitiesSupportedItemNoiseDetection, nil
	case "thermostat":
		return DeviceCapabilitiesSupportedItemThermostat, nil
	case "battery":
		return DeviceCapabilitiesSupportedItemBattery, nil
	case "phone":
		return DeviceCapabilitiesSupportedItemPhone, nil
	}
	var t DeviceCapabilitiesSupportedItem
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DeviceCapabilitiesSupportedItem) Ptr() *DeviceCapabilitiesSupportedItem {
	return &d
}

type DeviceCustomMetadataValue struct {
	typeName string
	String   string
	Boolean  bool
}

func NewDeviceCustomMetadataValueFromString(value string) *DeviceCustomMetadataValue {
	return &DeviceCustomMetadataValue{typeName: "string", String: value}
}

func NewDeviceCustomMetadataValueFromBoolean(value bool) *DeviceCustomMetadataValue {
	return &DeviceCustomMetadataValue{typeName: "boolean", Boolean: value}
}

func (d *DeviceCustomMetadataValue) UnmarshalJSON(data []byte) error {
	var valueString string
	if err := json.Unmarshal(data, &valueString); err == nil {
		d.typeName = "string"
		d.String = valueString
		return nil
	}
	var valueBoolean bool
	if err := json.Unmarshal(data, &valueBoolean); err == nil {
		d.typeName = "boolean"
		d.Boolean = valueBoolean
		return nil
	}
	return fmt.Errorf("%s cannot be deserialized as a %T", data, d)
}

func (d DeviceCustomMetadataValue) MarshalJSON() ([]byte, error) {
	switch d.typeName {
	default:
		return nil, fmt.Errorf("invalid type %s in %T", d.typeName, d)
	case "string":
		return json.Marshal(d.String)
	case "boolean":
		return json.Marshal(d.Boolean)
	}
}

type DeviceCustomMetadataValueVisitor interface {
	VisitString(string) error
	VisitBoolean(bool) error
}

func (d *DeviceCustomMetadataValue) Accept(visitor DeviceCustomMetadataValueVisitor) error {
	switch d.typeName {
	default:
		return fmt.Errorf("invalid type %s in %T", d.typeName, d)
	case "string":
		return visitor.VisitString(d.String)
	case "boolean":
		return visitor.VisitBoolean(d.Boolean)
	}
}

type DeviceErrorsItem struct {
	ErrorCode string `json:"error_code" url:"error_code"`
	Message   string `json:"message" url:"message"`

	_rawJSON json.RawMessage
}

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

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

// Location information for the device.
type DeviceLocation struct {
	// Name of the device location.
	LocationName *string `json:"location_name,omitempty" url:"location_name,omitempty"`
	// Time zone of the device location.
	Timezone *string `json:"timezone,omitempty" url:"timezone,omitempty"`

	_rawJSON json.RawMessage
}

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

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

// Properties of the device.
type DeviceProperties struct {
	// Indicates whether the device is online.
	Online bool `json:"online" url:"online"`
	// ---
	// deprecated: use device.display_name instead
	// ---
	// Name of the device.
	Name string `json:"name" url:"name"`
	// Represents the accessory keypad state.
	AccessoryKeypad *DevicePropertiesAccessoryKeypad `json:"accessory_keypad,omitempty" url:"accessory_keypad,omitempty"`
	Appearance      *DevicePropertiesAppearance      `json:"appearance,omitempty" url:"appearance,omitempty"`
	Model           *DevicePropertiesModel           `json:"model,omitempty" url:"model,omitempty"`
	// Indicates whether the device has direct power.
	HasDirectPower *bool `json:"has_direct_power,omitempty" url:"has_direct_power,omitempty"`
	// Indicates the battery level of the device as a decimal value between 0 and 1, inclusive.
	BatteryLevel *float64 `json:"battery_level,omitempty" url:"battery_level,omitempty"`
	// Represents the current status of the battery charge level. Values are "critical," which indicates an extremely low level, suggesting imminent shutdown or an urgent need for charging; "low," which signifies that the battery is under the preferred threshold and should be charged soon; "good," which denotes a satisfactory charge level, adequate for normal use without the immediate need for recharging; and "full," which represents a battery that is fully charged, providing the maximum duration of usage.
	Battery *DevicePropertiesBattery `json:"battery,omitempty" url:"battery,omitempty"`
	// Manufacturer of the device.
	Manufacturer *string `json:"manufacturer,omitempty" url:"manufacturer,omitempty"`
	// Image URL for the device.
	ImageUrl *string `json:"image_url,omitempty" url:"image_url,omitempty"`
	// Alt text for the device image.
	ImageAltText *string `json:"image_alt_text,omitempty" url:"image_alt_text,omitempty"`
	// Serial number of the device.
	SerialNumber *string `json:"serial_number,omitempty" url:"serial_number,omitempty"`
	// Indicates whether it is currently possible to use online access codes for the device.
	OnlineAccessCodesEnabled *bool `json:"online_access_codes_enabled,omitempty" url:"online_access_codes_enabled,omitempty"`
	// Indicates whether it is currently possible to use offline access codes for the device.
	OfflineAccessCodesEnabled *bool `json:"offline_access_codes_enabled,omitempty" url:"offline_access_codes_enabled,omitempty"`
	// ---
	// deprecated: use model.accessory_keypad_supported
	// ---
	SupportsAccessoryKeypad *bool `json:"supports_accessory_keypad,omitempty" url:"supports_accessory_keypad,omitempty"`
	// ---
	// deprecated: use offline_access_codes_enabled
	// ---
	SupportsOfflineAccessCodes                      *bool                                               `json:"supports_offline_access_codes,omitempty" url:"supports_offline_access_codes,omitempty"`
	AssaAbloyCredentialServiceMetadata              *DevicePropertiesAssaAbloyCredentialServiceMetadata `json:"assa_abloy_credential_service_metadata,omitempty" url:"assa_abloy_credential_service_metadata,omitempty"`
	AugustMetadata                                  *DevicePropertiesAugustMetadata                     `json:"august_metadata,omitempty" url:"august_metadata,omitempty"`
	AvigilonAltaMetadata                            *DevicePropertiesAvigilonAltaMetadata               `json:"avigilon_alta_metadata,omitempty" url:"avigilon_alta_metadata,omitempty"`
	SchlageMetadata                                 *DevicePropertiesSchlageMetadata                    `json:"schlage_metadata,omitempty" url:"schlage_metadata,omitempty"`
	SmartthingsMetadata                             *DevicePropertiesSmartthingsMetadata                `json:"smartthings_metadata,omitempty" url:"smartthings_metadata,omitempty"`
	LocklyMetadata                                  *DevicePropertiesLocklyMetadata                     `json:"lockly_metadata,omitempty" url:"lockly_metadata,omitempty"`
	NukiMetadata                                    *DevicePropertiesNukiMetadata                       `json:"nuki_metadata,omitempty" url:"nuki_metadata,omitempty"`
	KwiksetMetadata                                 *DevicePropertiesKwiksetMetadata                    `json:"kwikset_metadata,omitempty" url:"kwikset_metadata,omitempty"`
	SaltoMetadata                                   *DevicePropertiesSaltoMetadata                      `json:"salto_metadata,omitempty" url:"salto_metadata,omitempty"`
	GenieMetadata                                   *DevicePropertiesGenieMetadata                      `json:"genie_metadata,omitempty" url:"genie_metadata,omitempty"`
	BrivoMetadata                                   *DevicePropertiesBrivoMetadata                      `json:"brivo_metadata,omitempty" url:"brivo_metadata,omitempty"`
	IglooMetadata                                   *DevicePropertiesIglooMetadata                      `json:"igloo_metadata,omitempty" url:"igloo_metadata,omitempty"`
	NoiseawareMetadata                              *DevicePropertiesNoiseawareMetadata                 `json:"noiseaware_metadata,omitempty" url:"noiseaware_metadata,omitempty"`
	MinutMetadata                                   *DevicePropertiesMinutMetadata                      `json:"minut_metadata,omitempty" url:"minut_metadata,omitempty"`
	FourSuitesMetadata                              *DevicePropertiesFourSuitesMetadata                 `json:"four_suites_metadata,omitempty" url:"four_suites_metadata,omitempty"`
	TwoNMetadata                                    *DevicePropertiesTwoNMetadata                       `json:"two_n_metadata,omitempty" url:"two_n_metadata,omitempty"`
	ControlbywebMetadata                            *DevicePropertiesControlbywebMetadata               `json:"controlbyweb_metadata,omitempty" url:"controlbyweb_metadata,omitempty"`
	TtlockMetadata                                  *DevicePropertiesTtlockMetadata                     `json:"ttlock_metadata,omitempty" url:"ttlock_metadata,omitempty"`
	SeamBridgeMetadata                              *DevicePropertiesSeamBridgeMetadata                 `json:"seam_bridge_metadata,omitempty" url:"seam_bridge_metadata,omitempty"`
	IgloohomeMetadata                               *DevicePropertiesIgloohomeMetadata                  `json:"igloohome_metadata,omitempty" url:"igloohome_metadata,omitempty"`
	NestMetadata                                    *DevicePropertiesNestMetadata                       `json:"nest_metadata,omitempty" url:"nest_metadata,omitempty"`
	EcobeeMetadata                                  *DevicePropertiesEcobeeMetadata                     `json:"ecobee_metadata,omitempty" url:"ecobee_metadata,omitempty"`
	HoneywellResideoMetadata                        *DevicePropertiesHoneywellResideoMetadata           `json:"honeywell_resideo_metadata,omitempty" url:"honeywell_resideo_metadata,omitempty"`
	HubitatMetadata                                 *DevicePropertiesHubitatMetadata                    `json:"hubitat_metadata,omitempty" url:"hubitat_metadata,omitempty"`
	DormakabaOracodeMetadata                        *DevicePropertiesDormakabaOracodeMetadata           `json:"dormakaba_oracode_metadata,omitempty" url:"dormakaba_oracode_metadata,omitempty"`
	WyzeMetadata                                    *DevicePropertiesWyzeMetadata                       `json:"wyze_metadata,omitempty" url:"wyze_metadata,omitempty"`
	TedeeMetadata                                   *DevicePropertiesTedeeMetadata                      `json:"tedee_metadata,omitempty" url:"tedee_metadata,omitempty"`
	ExperimentalSupportedCodeFromAccessCodesLengths []float64                                           `json:"_experimental_supported_code_from_access_codes_lengths,omitempty" url:"_experimental_supported_code_from_access_codes_lengths,omitempty"`
	CodeConstraints                                 []*DevicePropertiesCodeConstraintsItem              `json:"code_constraints,omitempty" url:"code_constraints,omitempty"`
	SupportedCodeLengths                            []float64                                           `json:"supported_code_lengths,omitempty" url:"supported_code_lengths,omitempty"`
	MaxActiveCodesSupported                         *float64                                            `json:"max_active_codes_supported,omitempty" url:"max_active_codes_supported,omitempty"`
	SupportsBackupAccessCodePool                    *bool                                               `json:"supports_backup_access_code_pool,omitempty" url:"supports_backup_access_code_pool,omitempty"`
	HasNativeEntryEvents                            *bool                                               `json:"has_native_entry_events,omitempty" url:"has_native_entry_events,omitempty"`
	Locked                                          *bool                                               `json:"locked,omitempty" url:"locked,omitempty"`
	KeypadBattery                                   *DevicePropertiesKeypadBattery                      `json:"keypad_battery,omitempty" url:"keypad_battery,omitempty"`
	DoorOpen                                        *bool                                               `json:"door_open,omitempty" url:"door_open,omitempty"`

	_rawJSON json.RawMessage
}

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

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

// Represents the accessory keypad state.
type DevicePropertiesAccessoryKeypad struct {
	// Indicates if the accessory_keypad is connected to the device.
	IsConnected bool `json:"is_connected" url:"is_connected"`
	// Indicates if the keypad battery properties.
	Battery *DevicePropertiesAccessoryKeypadBattery `json:"battery,omitempty" url:"battery,omitempty"`

	_rawJSON json.RawMessage
}

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

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

// Indicates if the keypad battery properties.
type DevicePropertiesAccessoryKeypadBattery struct {
	Level float64 `json:"level" url:"level"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesAppearance struct {
	// Name of the device as seen from the provider API and application, not settable through Seam.
	Name string `json:"name" url:"name"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesAssaAbloyCredentialServiceMetadata struct {
	HasActiveEndpoint bool                                                               `json:"has_active_endpoint" url:"has_active_endpoint"`
	Endpoints         []*DevicePropertiesAssaAbloyCredentialServiceMetadataEndpointsItem `json:"endpoints,omitempty" url:"endpoints,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesAssaAbloyCredentialServiceMetadataEndpointsItem struct {
	EndpointId string `json:"endpoint_id" url:"endpoint_id"`
	IsActive   bool   `json:"is_active" url:"is_active"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesAugustMetadata struct {
	LockId             string  `json:"lock_id" url:"lock_id"`
	LockName           string  `json:"lock_name" url:"lock_name"`
	HouseName          string  `json:"house_name" url:"house_name"`
	HasKeypad          bool    `json:"has_keypad" url:"has_keypad"`
	KeypadBatteryLevel *string `json:"keypad_battery_level,omitempty" url:"keypad_battery_level,omitempty"`
	Model              *string `json:"model,omitempty" url:"model,omitempty"`
	HouseId            *string `json:"house_id,omitempty" url:"house_id,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesAvigilonAltaMetadata struct {
	EntryName             string  `json:"entry_name" url:"entry_name"`
	OrgName               string  `json:"org_name" url:"org_name"`
	ZoneId                float64 `json:"zone_id" url:"zone_id"`
	ZoneName              string  `json:"zone_name" url:"zone_name"`
	SiteId                float64 `json:"site_id" url:"site_id"`
	SiteName              string  `json:"site_name" url:"site_name"`
	EntryRelaysTotalCount float64 `json:"entry_relays_total_count" url:"entry_relays_total_count"`

	_rawJSON json.RawMessage
}

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

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

// Represents the current status of the battery charge level. Values are "critical," which indicates an extremely low level, suggesting imminent shutdown or an urgent need for charging; "low," which signifies that the battery is under the preferred threshold and should be charged soon; "good," which denotes a satisfactory charge level, adequate for normal use without the immediate need for recharging; and "full," which represents a battery that is fully charged, providing the maximum duration of usage.
type DevicePropertiesBattery struct {
	Level  float64                       `json:"level" url:"level"`
	Status DevicePropertiesBatteryStatus `json:"status,omitempty" url:"status,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesBatteryStatus string

const (
	DevicePropertiesBatteryStatusCritical DevicePropertiesBatteryStatus = "critical"
	DevicePropertiesBatteryStatusLow      DevicePropertiesBatteryStatus = "low"
	DevicePropertiesBatteryStatusGood     DevicePropertiesBatteryStatus = "good"
	DevicePropertiesBatteryStatusFull     DevicePropertiesBatteryStatus = "full"
)

func NewDevicePropertiesBatteryStatusFromString(s string) (DevicePropertiesBatteryStatus, error) {
	switch s {
	case "critical":
		return DevicePropertiesBatteryStatusCritical, nil
	case "low":
		return DevicePropertiesBatteryStatusLow, nil
	case "good":
		return DevicePropertiesBatteryStatusGood, nil
	case "full":
		return DevicePropertiesBatteryStatusFull, nil
	}
	var t DevicePropertiesBatteryStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DevicePropertiesBatteryStatus) Ptr() *DevicePropertiesBatteryStatus {
	return &d
}

type DevicePropertiesBrivoMetadata struct {
	DeviceName string `json:"device_name" url:"device_name"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesCodeConstraintsItem struct {
	typeName                                     string
	DevicePropertiesCodeConstraintsItemZero      *DevicePropertiesCodeConstraintsItemZero
	DevicePropertiesCodeConstraintsItemMaxLength *DevicePropertiesCodeConstraintsItemMaxLength
}

func NewDevicePropertiesCodeConstraintsItemFromDevicePropertiesCodeConstraintsItemZero(value *DevicePropertiesCodeConstraintsItemZero) *DevicePropertiesCodeConstraintsItem {
	return &DevicePropertiesCodeConstraintsItem{typeName: "devicePropertiesCodeConstraintsItemZero", DevicePropertiesCodeConstraintsItemZero: value}
}

func NewDevicePropertiesCodeConstraintsItemFromDevicePropertiesCodeConstraintsItemMaxLength(value *DevicePropertiesCodeConstraintsItemMaxLength) *DevicePropertiesCodeConstraintsItem {
	return &DevicePropertiesCodeConstraintsItem{typeName: "devicePropertiesCodeConstraintsItemMaxLength", DevicePropertiesCodeConstraintsItemMaxLength: value}
}

func (d *DevicePropertiesCodeConstraintsItem) UnmarshalJSON(data []byte) error {
	valueDevicePropertiesCodeConstraintsItemZero := new(DevicePropertiesCodeConstraintsItemZero)
	if err := json.Unmarshal(data, &valueDevicePropertiesCodeConstraintsItemZero); err == nil {
		d.typeName = "devicePropertiesCodeConstraintsItemZero"
		d.DevicePropertiesCodeConstraintsItemZero = valueDevicePropertiesCodeConstraintsItemZero
		return nil
	}
	valueDevicePropertiesCodeConstraintsItemMaxLength := new(DevicePropertiesCodeConstraintsItemMaxLength)
	if err := json.Unmarshal(data, &valueDevicePropertiesCodeConstraintsItemMaxLength); err == nil {
		d.typeName = "devicePropertiesCodeConstraintsItemMaxLength"
		d.DevicePropertiesCodeConstraintsItemMaxLength = valueDevicePropertiesCodeConstraintsItemMaxLength
		return nil
	}
	return fmt.Errorf("%s cannot be deserialized as a %T", data, d)
}

func (d DevicePropertiesCodeConstraintsItem) MarshalJSON() ([]byte, error) {
	switch d.typeName {
	default:
		return nil, fmt.Errorf("invalid type %s in %T", d.typeName, d)
	case "devicePropertiesCodeConstraintsItemZero":
		return json.Marshal(d.DevicePropertiesCodeConstraintsItemZero)
	case "devicePropertiesCodeConstraintsItemMaxLength":
		return json.Marshal(d.DevicePropertiesCodeConstraintsItemMaxLength)
	}
}

type DevicePropertiesCodeConstraintsItemVisitor interface {
	VisitDevicePropertiesCodeConstraintsItemZero(*DevicePropertiesCodeConstraintsItemZero) error
	VisitDevicePropertiesCodeConstraintsItemMaxLength(*DevicePropertiesCodeConstraintsItemMaxLength) error
}

func (d *DevicePropertiesCodeConstraintsItem) Accept(visitor DevicePropertiesCodeConstraintsItemVisitor) error {
	switch d.typeName {
	default:
		return fmt.Errorf("invalid type %s in %T", d.typeName, d)
	case "devicePropertiesCodeConstraintsItemZero":
		return visitor.VisitDevicePropertiesCodeConstraintsItemZero(d.DevicePropertiesCodeConstraintsItemZero)
	case "devicePropertiesCodeConstraintsItemMaxLength":
		return visitor.VisitDevicePropertiesCodeConstraintsItemMaxLength(d.DevicePropertiesCodeConstraintsItemMaxLength)
	}
}

type DevicePropertiesCodeConstraintsItemMaxLength struct {
	ConstraintType DevicePropertiesCodeConstraintsItemMaxLengthConstraintType `json:"constraint_type,omitempty" url:"constraint_type,omitempty"`
	MinLength      *float64                                                   `json:"min_length,omitempty" url:"min_length,omitempty"`
	MaxLength      *float64                                                   `json:"max_length,omitempty" url:"max_length,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesCodeConstraintsItemMaxLengthConstraintType string

const (
	DevicePropertiesCodeConstraintsItemMaxLengthConstraintTypeNameLength       DevicePropertiesCodeConstraintsItemMaxLengthConstraintType = "name_length"
	DevicePropertiesCodeConstraintsItemMaxLengthConstraintTypeNameMustBeUnique DevicePropertiesCodeConstraintsItemMaxLengthConstraintType = "name_must_be_unique"
)

func NewDevicePropertiesCodeConstraintsItemMaxLengthConstraintTypeFromString(s string) (DevicePropertiesCodeConstraintsItemMaxLengthConstraintType, error) {
	switch s {
	case "name_length":
		return DevicePropertiesCodeConstraintsItemMaxLengthConstraintTypeNameLength, nil
	case "name_must_be_unique":
		return DevicePropertiesCodeConstraintsItemMaxLengthConstraintTypeNameMustBeUnique, nil
	}
	var t DevicePropertiesCodeConstraintsItemMaxLengthConstraintType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DevicePropertiesCodeConstraintsItemMaxLengthConstraintType) Ptr() *DevicePropertiesCodeConstraintsItemMaxLengthConstraintType {
	return &d
}

type DevicePropertiesCodeConstraintsItemZero struct {
	ConstraintType DevicePropertiesCodeConstraintsItemZeroConstraintType `json:"constraint_type,omitempty" url:"constraint_type,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesCodeConstraintsItemZeroConstraintType string

const (
	DevicePropertiesCodeConstraintsItemZeroConstraintTypeNoZeros                         DevicePropertiesCodeConstraintsItemZeroConstraintType = "no_zeros"
	DevicePropertiesCodeConstraintsItemZeroConstraintTypeCannotStartWith12               DevicePropertiesCodeConstraintsItemZeroConstraintType = "cannot_start_with_12"
	DevicePropertiesCodeConstraintsItemZeroConstraintTypeNoTripleConsecutiveInts         DevicePropertiesCodeConstraintsItemZeroConstraintType = "no_triple_consecutive_ints"
	DevicePropertiesCodeConstraintsItemZeroConstraintTypeCannotSpecifyPinCode            DevicePropertiesCodeConstraintsItemZeroConstraintType = "cannot_specify_pin_code"
	DevicePropertiesCodeConstraintsItemZeroConstraintTypePinCodeMatchesExistingSet       DevicePropertiesCodeConstraintsItemZeroConstraintType = "pin_code_matches_existing_set"
	DevicePropertiesCodeConstraintsItemZeroConstraintTypeStartDateInFuture               DevicePropertiesCodeConstraintsItemZeroConstraintType = "start_date_in_future"
	DevicePropertiesCodeConstraintsItemZeroConstraintTypeNoAscendingOrDescendingSequence DevicePropertiesCodeConstraintsItemZeroConstraintType = "no_ascending_or_descending_sequence"
	DevicePropertiesCodeConstraintsItemZeroConstraintTypeAtLeastThreeUniqueDigits        DevicePropertiesCodeConstraintsItemZeroConstraintType = "at_least_three_unique_digits"
	DevicePropertiesCodeConstraintsItemZeroConstraintTypeCannotContain089                DevicePropertiesCodeConstraintsItemZeroConstraintType = "cannot_contain_089"
)

func NewDevicePropertiesCodeConstraintsItemZeroConstraintTypeFromString(s string) (DevicePropertiesCodeConstraintsItemZeroConstraintType, error) {
	switch s {
	case "no_zeros":
		return DevicePropertiesCodeConstraintsItemZeroConstraintTypeNoZeros, nil
	case "cannot_start_with_12":
		return DevicePropertiesCodeConstraintsItemZeroConstraintTypeCannotStartWith12, nil
	case "no_triple_consecutive_ints":
		return DevicePropertiesCodeConstraintsItemZeroConstraintTypeNoTripleConsecutiveInts, nil
	case "cannot_specify_pin_code":
		return DevicePropertiesCodeConstraintsItemZeroConstraintTypeCannotSpecifyPinCode, nil
	case "pin_code_matches_existing_set":
		return DevicePropertiesCodeConstraintsItemZeroConstraintTypePinCodeMatchesExistingSet, nil
	case "start_date_in_future":
		return DevicePropertiesCodeConstraintsItemZeroConstraintTypeStartDateInFuture, nil
	case "no_ascending_or_descending_sequence":
		return DevicePropertiesCodeConstraintsItemZeroConstraintTypeNoAscendingOrDescendingSequence, nil
	case "at_least_three_unique_digits":
		return DevicePropertiesCodeConstraintsItemZeroConstraintTypeAtLeastThreeUniqueDigits, nil
	case "cannot_contain_089":
		return DevicePropertiesCodeConstraintsItemZeroConstraintTypeCannotContain089, nil
	}
	var t DevicePropertiesCodeConstraintsItemZeroConstraintType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DevicePropertiesCodeConstraintsItemZeroConstraintType) Ptr() *DevicePropertiesCodeConstraintsItemZeroConstraintType {
	return &d
}

type DevicePropertiesControlbywebMetadata struct {
	DeviceId   string  `json:"device_id" url:"device_id"`
	DeviceName string  `json:"device_name" url:"device_name"`
	RelayName  *string `json:"relay_name,omitempty" url:"relay_name,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesDormakabaOracodeMetadata struct {
	DoorId              float64                                                            `json:"door_id" url:"door_id"`
	DoorName            string                                                             `json:"door_name" url:"door_name"`
	DeviceId            *float64                                                           `json:"device_id,omitempty" url:"device_id,omitempty"`
	DoorIsWireless      bool                                                               `json:"door_is_wireless" url:"door_is_wireless"`
	SiteId              float64                                                            `json:"site_id" url:"site_id"`
	SiteName            string                                                             `json:"site_name" url:"site_name"`
	IanaTimezone        *string                                                            `json:"iana_timezone,omitempty" url:"iana_timezone,omitempty"`
	PredefinedTimeSlots []*DevicePropertiesDormakabaOracodeMetadataPredefinedTimeSlotsItem `json:"predefined_time_slots,omitempty" url:"predefined_time_slots,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesDormakabaOracodeMetadataPredefinedTimeSlotsItem struct {
	Name                               string  `json:"name" url:"name"`
	Prefix                             float64 `json:"prefix" url:"prefix"`
	CheckInTime                        string  `json:"check_in_time" url:"check_in_time"`
	CheckOutTime                       string  `json:"check_out_time" url:"check_out_time"`
	Is24Hour                           bool    `json:"is_24_hour" url:"is_24_hour"`
	IsBiweeklyMode                     bool    `json:"is_biweekly_mode" url:"is_biweekly_mode"`
	IsOneShot                          bool    `json:"is_one_shot" url:"is_one_shot"`
	IsMaster                           bool    `json:"is_master" url:"is_master"`
	ExtDormakabaOracodeUserLevelPrefix float64 `json:"ext_dormakaba_oracode_user_level_prefix" url:"ext_dormakaba_oracode_user_level_prefix"`
	DormakabaOracodeUserLevelId        string  `json:"dormakaba_oracode_user_level_id" url:"dormakaba_oracode_user_level_id"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesEcobeeMetadata struct {
	EcobeeDeviceId string `json:"ecobee_device_id" url:"ecobee_device_id"`
	DeviceName     string `json:"device_name" url:"device_name"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesFourSuitesMetadata struct {
	DeviceId              float64 `json:"device_id" url:"device_id"`
	DeviceName            string  `json:"device_name" url:"device_name"`
	RecloseDelayInSeconds float64 `json:"reclose_delay_in_seconds" url:"reclose_delay_in_seconds"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesGenieMetadata struct {
	DeviceName string `json:"device_name" url:"device_name"`
	DoorName   string `json:"door_name" url:"door_name"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesHoneywellResideoMetadata struct {
	HoneywellResideoDeviceId string `json:"honeywell_resideo_device_id" url:"honeywell_resideo_device_id"`
	DeviceName               string `json:"device_name" url:"device_name"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesHubitatMetadata struct {
	DeviceId    string `json:"device_id" url:"device_id"`
	DeviceName  string `json:"device_name" url:"device_name"`
	DeviceLabel string `json:"device_label" url:"device_label"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesIglooMetadata struct {
	DeviceId string  `json:"device_id" url:"device_id"`
	BridgeId string  `json:"bridge_id" url:"bridge_id"`
	Model    *string `json:"model,omitempty" url:"model,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesIgloohomeMetadata struct {
	DeviceId   string  `json:"device_id" url:"device_id"`
	DeviceName string  `json:"device_name" url:"device_name"`
	BridgeId   *string `json:"bridge_id,omitempty" url:"bridge_id,omitempty"`
	BridgeName *string `json:"bridge_name,omitempty" url:"bridge_name,omitempty"`
	KeypadId   *string `json:"keypad_id,omitempty" url:"keypad_id,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesKeypadBattery struct {
	Level float64 `json:"level" url:"level"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesKwiksetMetadata struct {
	DeviceId    string `json:"device_id" url:"device_id"`
	DeviceName  string `json:"device_name" url:"device_name"`
	ModelNumber string `json:"model_number" url:"model_number"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesLocklyMetadata struct {
	DeviceId   string  `json:"device_id" url:"device_id"`
	DeviceName string  `json:"device_name" url:"device_name"`
	Model      *string `json:"model,omitempty" url:"model,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesMinutMetadata struct {
	DeviceId           string                                           `json:"device_id" url:"device_id"`
	DeviceName         string                                           `json:"device_name" url:"device_name"`
	LatestSensorValues *DevicePropertiesMinutMetadataLatestSensorValues `json:"latest_sensor_values,omitempty" url:"latest_sensor_values,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesMinutMetadataLatestSensorValues struct {
	Temperature    *DevicePropertiesMinutMetadataLatestSensorValuesTemperature    `json:"temperature,omitempty" url:"temperature,omitempty"`
	Sound          *DevicePropertiesMinutMetadataLatestSensorValuesSound          `json:"sound,omitempty" url:"sound,omitempty"`
	Humidity       *DevicePropertiesMinutMetadataLatestSensorValuesHumidity       `json:"humidity,omitempty" url:"humidity,omitempty"`
	Pressure       *DevicePropertiesMinutMetadataLatestSensorValuesPressure       `json:"pressure,omitempty" url:"pressure,omitempty"`
	AccelerometerZ *DevicePropertiesMinutMetadataLatestSensorValuesAccelerometerZ `json:"accelerometer_z,omitempty" url:"accelerometer_z,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesMinutMetadataLatestSensorValuesAccelerometerZ struct {
	Time  string  `json:"time" url:"time"`
	Value float64 `json:"value" url:"value"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesMinutMetadataLatestSensorValuesHumidity struct {
	Time  string  `json:"time" url:"time"`
	Value float64 `json:"value" url:"value"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesMinutMetadataLatestSensorValuesPressure struct {
	Time  string  `json:"time" url:"time"`
	Value float64 `json:"value" url:"value"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesMinutMetadataLatestSensorValuesSound struct {
	Time  string  `json:"time" url:"time"`
	Value float64 `json:"value" url:"value"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesMinutMetadataLatestSensorValuesTemperature struct {
	Time  string  `json:"time" url:"time"`
	Value float64 `json:"value" url:"value"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesModel struct {
	// Indicates whether the device can connect a accessory keypad.
	CanConnectAccessoryKeypad *bool `json:"can_connect_accessory_keypad,omitempty" url:"can_connect_accessory_keypad,omitempty"`
	// Display name of the device model.
	DisplayName string `json:"display_name" url:"display_name"`
	// Display name that corresponds to the manufacturer-specific terminology for the device.
	ManufacturerDisplayName string `json:"manufacturer_display_name" url:"manufacturer_display_name"`
	// Indicates whether the device has a built in accessory keypad.
	HasBuiltInKeypad *bool `json:"has_built_in_keypad,omitempty" url:"has_built_in_keypad,omitempty"`
	// Indicates whether the device supports offline access codes.
	OfflineAccessCodesSupported *bool `json:"offline_access_codes_supported,omitempty" url:"offline_access_codes_supported,omitempty"`
	// Indicates whether the device supports online access codes.
	OnlineAccessCodesSupported *bool `json:"online_access_codes_supported,omitempty" url:"online_access_codes_supported,omitempty"`
	// Indicates whether the device supports an accessory keypad.
	AccessoryKeypadSupported *bool `json:"accessory_keypad_supported,omitempty" url:"accessory_keypad_supported,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesNestMetadata struct {
	NestDeviceId string `json:"nest_device_id" url:"nest_device_id"`
	DeviceName   string `json:"device_name" url:"device_name"`
	CustomName   string `json:"custom_name" url:"custom_name"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesNoiseawareMetadata struct {
	DeviceModel       DevicePropertiesNoiseawareMetadataDeviceModel `json:"device_model,omitempty" url:"device_model,omitempty"`
	NoiseLevelNrs     float64                                       `json:"noise_level_nrs" url:"noise_level_nrs"`
	NoiseLevelDecibel float64                                       `json:"noise_level_decibel" url:"noise_level_decibel"`
	DeviceName        string                                        `json:"device_name" url:"device_name"`
	DeviceId          string                                        `json:"device_id" url:"device_id"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesNoiseawareMetadataDeviceModel string

const (
	DevicePropertiesNoiseawareMetadataDeviceModelIndoor  DevicePropertiesNoiseawareMetadataDeviceModel = "indoor"
	DevicePropertiesNoiseawareMetadataDeviceModelOutdoor DevicePropertiesNoiseawareMetadataDeviceModel = "outdoor"
)

func NewDevicePropertiesNoiseawareMetadataDeviceModelFromString(s string) (DevicePropertiesNoiseawareMetadataDeviceModel, error) {
	switch s {
	case "indoor":
		return DevicePropertiesNoiseawareMetadataDeviceModelIndoor, nil
	case "outdoor":
		return DevicePropertiesNoiseawareMetadataDeviceModelOutdoor, nil
	}
	var t DevicePropertiesNoiseawareMetadataDeviceModel
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DevicePropertiesNoiseawareMetadataDeviceModel) Ptr() *DevicePropertiesNoiseawareMetadataDeviceModel {
	return &d
}

type DevicePropertiesNukiMetadata struct {
	DeviceId              string `json:"device_id" url:"device_id"`
	DeviceName            string `json:"device_name" url:"device_name"`
	KeypadBatteryCritical *bool  `json:"keypad_battery_critical,omitempty" url:"keypad_battery_critical,omitempty"`
	KeypadPaired          *bool  `json:"keypad_paired,omitempty" url:"keypad_paired,omitempty"`
	Keypad2Paired         *bool  `json:"keypad_2_paired,omitempty" url:"keypad_2_paired,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesSaltoMetadata struct {
	LockId            string  `json:"lock_id" url:"lock_id"`
	CustomerReference string  `json:"customer_reference" url:"customer_reference"`
	LockType          string  `json:"lock_type" url:"lock_type"`
	BatteryLevel      string  `json:"battery_level" url:"battery_level"`
	LockedState       string  `json:"locked_state" url:"locked_state"`
	Model             *string `json:"model,omitempty" url:"model,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesSchlageMetadata struct {
	DeviceId         string   `json:"device_id" url:"device_id"`
	DeviceName       string   `json:"device_name" url:"device_name"`
	AccessCodeLength *float64 `json:"access_code_length,omitempty" url:"access_code_length,omitempty"`
	Model            *string  `json:"model,omitempty" url:"model,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesSeamBridgeMetadata struct {
	UnlockMethod *DevicePropertiesSeamBridgeMetadataUnlockMethod `json:"unlock_method,omitempty" url:"unlock_method,omitempty"`
	DeviceNum    float64                                         `json:"device_num" url:"device_num"`
	Name         string                                          `json:"name" url:"name"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesSeamBridgeMetadataUnlockMethod string

const (
	DevicePropertiesSeamBridgeMetadataUnlockMethodBridge   DevicePropertiesSeamBridgeMetadataUnlockMethod = "bridge"
	DevicePropertiesSeamBridgeMetadataUnlockMethodDoorking DevicePropertiesSeamBridgeMetadataUnlockMethod = "doorking"
)

func NewDevicePropertiesSeamBridgeMetadataUnlockMethodFromString(s string) (DevicePropertiesSeamBridgeMetadataUnlockMethod, error) {
	switch s {
	case "bridge":
		return DevicePropertiesSeamBridgeMetadataUnlockMethodBridge, nil
	case "doorking":
		return DevicePropertiesSeamBridgeMetadataUnlockMethodDoorking, nil
	}
	var t DevicePropertiesSeamBridgeMetadataUnlockMethod
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DevicePropertiesSeamBridgeMetadataUnlockMethod) Ptr() *DevicePropertiesSeamBridgeMetadataUnlockMethod {
	return &d
}

type DevicePropertiesSmartthingsMetadata struct {
	DeviceId   string  `json:"device_id" url:"device_id"`
	DeviceName string  `json:"device_name" url:"device_name"`
	Model      *string `json:"model,omitempty" url:"model,omitempty"`
	LocationId *string `json:"location_id,omitempty" url:"location_id,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesTedeeMetadata struct {
	DeviceId     float64  `json:"device_id" url:"device_id"`
	SerialNumber string   `json:"serial_number" url:"serial_number"`
	DeviceName   string   `json:"device_name" url:"device_name"`
	DeviceModel  string   `json:"device_model" url:"device_model"`
	BridgeId     float64  `json:"bridge_id" url:"bridge_id"`
	BridgeName   string   `json:"bridge_name" url:"bridge_name"`
	KeypadId     *float64 `json:"keypad_id,omitempty" url:"keypad_id,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesTtlockMetadata struct {
	LockId    float64 `json:"lock_id" url:"lock_id"`
	LockAlias string  `json:"lock_alias" url:"lock_alias"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesTwoNMetadata struct {
	DeviceId   float64 `json:"device_id" url:"device_id"`
	DeviceName string  `json:"device_name" url:"device_name"`

	_rawJSON json.RawMessage
}

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

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

type DevicePropertiesWyzeMetadata struct {
	DeviceId             string   `json:"device_id" url:"device_id"`
	DeviceName           string   `json:"device_name" url:"device_name"`
	ProductName          string   `json:"product_name" url:"product_name"`
	ProductType          string   `json:"product_type" url:"product_type"`
	ProductModel         string   `json:"product_model" url:"product_model"`
	DeviceInfoModel      string   `json:"device_info_model" url:"device_info_model"`
	KeypadUuid           *string  `json:"keypad_uuid,omitempty" url:"keypad_uuid,omitempty"`
	LockerStatusHardlock *float64 `json:"locker_status_hardlock,omitempty" url:"locker_status_hardlock,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DeviceProvider struct {
	DeviceProviderName DeviceProviderDeviceProviderName       `json:"device_provider_name,omitempty" url:"device_provider_name,omitempty"`
	DisplayName        string                                 `json:"display_name" url:"display_name"`
	ImageUrl           string                                 `json:"image_url" url:"image_url"`
	ProviderCategories []DeviceProviderProviderCategoriesItem `json:"provider_categories,omitempty" url:"provider_categories,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type DeviceProviderDeviceProviderName string

const (
	DeviceProviderDeviceProviderNameAkuvox                     DeviceProviderDeviceProviderName = "akuvox"
	DeviceProviderDeviceProviderNameAugust                     DeviceProviderDeviceProviderName = "august"
	DeviceProviderDeviceProviderNameAvigilonAlta               DeviceProviderDeviceProviderName = "avigilon_alta"
	DeviceProviderDeviceProviderNameBrivo                      DeviceProviderDeviceProviderName = "brivo"
	DeviceProviderDeviceProviderNameButterflymx                DeviceProviderDeviceProviderName = "butterflymx"
	DeviceProviderDeviceProviderNameSchlage                    DeviceProviderDeviceProviderName = "schlage"
	DeviceProviderDeviceProviderNameSmartthings                DeviceProviderDeviceProviderName = "smartthings"
	DeviceProviderDeviceProviderNameYale                       DeviceProviderDeviceProviderName = "yale"
	DeviceProviderDeviceProviderNameGenie                      DeviceProviderDeviceProviderName = "genie"
	DeviceProviderDeviceProviderNameDoorking                   DeviceProviderDeviceProviderName = "doorking"
	DeviceProviderDeviceProviderNameSalto                      DeviceProviderDeviceProviderName = "salto"
	DeviceProviderDeviceProviderNameLockly                     DeviceProviderDeviceProviderName = "lockly"
	DeviceProviderDeviceProviderNameTtlock                     DeviceProviderDeviceProviderName = "ttlock"
	DeviceProviderDeviceProviderNameLinear                     DeviceProviderDeviceProviderName = "linear"
	DeviceProviderDeviceProviderNameNoiseaware                 DeviceProviderDeviceProviderName = "noiseaware"
	DeviceProviderDeviceProviderNameNuki                       DeviceProviderDeviceProviderName = "nuki"
	DeviceProviderDeviceProviderNameSeamRelayAdmin             DeviceProviderDeviceProviderName = "seam_relay_admin"
	DeviceProviderDeviceProviderNameIgloo                      DeviceProviderDeviceProviderName = "igloo"
	DeviceProviderDeviceProviderNameKwikset                    DeviceProviderDeviceProviderName = "kwikset"
	DeviceProviderDeviceProviderNameMinut                      DeviceProviderDeviceProviderName = "minut"
	DeviceProviderDeviceProviderNameMy2N                       DeviceProviderDeviceProviderName = "my_2n"
	DeviceProviderDeviceProviderNameControlbyweb               DeviceProviderDeviceProviderName = "controlbyweb"
	DeviceProviderDeviceProviderNameNest                       DeviceProviderDeviceProviderName = "nest"
	DeviceProviderDeviceProviderNameIgloohome                  DeviceProviderDeviceProviderName = "igloohome"
	DeviceProviderDeviceProviderNameEcobee                     DeviceProviderDeviceProviderName = "ecobee"
	DeviceProviderDeviceProviderNameHubitat                    DeviceProviderDeviceProviderName = "hubitat"
	DeviceProviderDeviceProviderNameFourSuites                 DeviceProviderDeviceProviderName = "four_suites"
	DeviceProviderDeviceProviderNameDormakabaOracode           DeviceProviderDeviceProviderName = "dormakaba_oracode"
	DeviceProviderDeviceProviderNamePti                        DeviceProviderDeviceProviderName = "pti"
	DeviceProviderDeviceProviderNameWyze                       DeviceProviderDeviceProviderName = "wyze"
	DeviceProviderDeviceProviderNameSeamPassport               DeviceProviderDeviceProviderName = "seam_passport"
	DeviceProviderDeviceProviderNameVisionline                 DeviceProviderDeviceProviderName = "visionline"
	DeviceProviderDeviceProviderNameAssaAbloyCredentialService DeviceProviderDeviceProviderName = "assa_abloy_credential_service"
	DeviceProviderDeviceProviderNameSeamBridge                 DeviceProviderDeviceProviderName = "seam_bridge"
	DeviceProviderDeviceProviderNameTedee                      DeviceProviderDeviceProviderName = "tedee"
	DeviceProviderDeviceProviderNameHoneywellResideo           DeviceProviderDeviceProviderName = "honeywell_resideo"
	DeviceProviderDeviceProviderNameLatch                      DeviceProviderDeviceProviderName = "latch"
)

func NewDeviceProviderDeviceProviderNameFromString(s string) (DeviceProviderDeviceProviderName, error) {
	switch s {
	case "akuvox":
		return DeviceProviderDeviceProviderNameAkuvox, nil
	case "august":
		return DeviceProviderDeviceProviderNameAugust, nil
	case "avigilon_alta":
		return DeviceProviderDeviceProviderNameAvigilonAlta, nil
	case "brivo":
		return DeviceProviderDeviceProviderNameBrivo, nil
	case "butterflymx":
		return DeviceProviderDeviceProviderNameButterflymx, nil
	case "schlage":
		return DeviceProviderDeviceProviderNameSchlage, nil
	case "smartthings":
		return DeviceProviderDeviceProviderNameSmartthings, nil
	case "yale":
		return DeviceProviderDeviceProviderNameYale, nil
	case "genie":
		return DeviceProviderDeviceProviderNameGenie, nil
	case "doorking":
		return DeviceProviderDeviceProviderNameDoorking, nil
	case "salto":
		return DeviceProviderDeviceProviderNameSalto, nil
	case "lockly":
		return DeviceProviderDeviceProviderNameLockly, nil
	case "ttlock":
		return DeviceProviderDeviceProviderNameTtlock, nil
	case "linear":
		return DeviceProviderDeviceProviderNameLinear, nil
	case "noiseaware":
		return DeviceProviderDeviceProviderNameNoiseaware, nil
	case "nuki":
		return DeviceProviderDeviceProviderNameNuki, nil
	case "seam_relay_admin":
		return DeviceProviderDeviceProviderNameSeamRelayAdmin, nil
	case "igloo":
		return DeviceProviderDeviceProviderNameIgloo, nil
	case "kwikset":
		return DeviceProviderDeviceProviderNameKwikset, nil
	case "minut":
		return DeviceProviderDeviceProviderNameMinut, nil
	case "my_2n":
		return DeviceProviderDeviceProviderNameMy2N, nil
	case "controlbyweb":
		return DeviceProviderDeviceProviderNameControlbyweb, nil
	case "nest":
		return DeviceProviderDeviceProviderNameNest, nil
	case "igloohome":
		return DeviceProviderDeviceProviderNameIgloohome, nil
	case "ecobee":
		return DeviceProviderDeviceProviderNameEcobee, nil
	case "hubitat":
		return DeviceProviderDeviceProviderNameHubitat, nil
	case "four_suites":
		return DeviceProviderDeviceProviderNameFourSuites, nil
	case "dormakaba_oracode":
		return DeviceProviderDeviceProviderNameDormakabaOracode, nil
	case "pti":
		return DeviceProviderDeviceProviderNamePti, nil
	case "wyze":
		return DeviceProviderDeviceProviderNameWyze, nil
	case "seam_passport":
		return DeviceProviderDeviceProviderNameSeamPassport, nil
	case "visionline":
		return DeviceProviderDeviceProviderNameVisionline, nil
	case "assa_abloy_credential_service":
		return DeviceProviderDeviceProviderNameAssaAbloyCredentialService, nil
	case "seam_bridge":
		return DeviceProviderDeviceProviderNameSeamBridge, nil
	case "tedee":
		return DeviceProviderDeviceProviderNameTedee, nil
	case "honeywell_resideo":
		return DeviceProviderDeviceProviderNameHoneywellResideo, nil
	case "latch":
		return DeviceProviderDeviceProviderNameLatch, nil
	}
	var t DeviceProviderDeviceProviderName
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DeviceProviderDeviceProviderName) Ptr() *DeviceProviderDeviceProviderName {
	return &d
}

type DeviceProviderProviderCategoriesItem string

const (
	DeviceProviderProviderCategoriesItemStable               DeviceProviderProviderCategoriesItem = "stable"
	DeviceProviderProviderCategoriesItemConsumerSmartlocks   DeviceProviderProviderCategoriesItem = "consumer_smartlocks"
	DeviceProviderProviderCategoriesItemThermostats          DeviceProviderProviderCategoriesItem = "thermostats"
	DeviceProviderProviderCategoriesItemNoiseSensors         DeviceProviderProviderCategoriesItem = "noise_sensors"
	DeviceProviderProviderCategoriesItemAccessControlSystems DeviceProviderProviderCategoriesItem = "access_control_systems"
)

func NewDeviceProviderProviderCategoriesItemFromString(s string) (DeviceProviderProviderCategoriesItem, error) {
	switch s {
	case "stable":
		return DeviceProviderProviderCategoriesItemStable, nil
	case "consumer_smartlocks":
		return DeviceProviderProviderCategoriesItemConsumerSmartlocks, nil
	case "thermostats":
		return DeviceProviderProviderCategoriesItemThermostats, nil
	case "noise_sensors":
		return DeviceProviderProviderCategoriesItemNoiseSensors, nil
	case "access_control_systems":
		return DeviceProviderProviderCategoriesItemAccessControlSystems, nil
	}
	var t DeviceProviderProviderCategoriesItem
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DeviceProviderProviderCategoriesItem) Ptr() *DeviceProviderProviderCategoriesItem {
	return &d
}

type DeviceType string

const (
	DeviceTypeAkuvoxLock             DeviceType = "akuvox_lock"
	DeviceTypeAugustLock             DeviceType = "august_lock"
	DeviceTypeBrivoAccessPoint       DeviceType = "brivo_access_point"
	DeviceTypeButterflymxPanel       DeviceType = "butterflymx_panel"
	DeviceTypeAvigilonAltaEntry      DeviceType = "avigilon_alta_entry"
	DeviceTypeDoorkingLock           DeviceType = "doorking_lock"
	DeviceTypeGenieDoor              DeviceType = "genie_door"
	DeviceTypeIglooLock              DeviceType = "igloo_lock"
	DeviceTypeLinearLock             DeviceType = "linear_lock"
	DeviceTypeLocklyLock             DeviceType = "lockly_lock"
	DeviceTypeKwiksetLock            DeviceType = "kwikset_lock"
	DeviceTypeNukiLock               DeviceType = "nuki_lock"
	DeviceTypeSaltoLock              DeviceType = "salto_lock"
	DeviceTypeSchlageLock            DeviceType = "schlage_lock"
	DeviceTypeSeamRelay              DeviceType = "seam_relay"
	DeviceTypeSmartthingsLock        DeviceType = "smartthings_lock"
	DeviceTypeWyzeLock               DeviceType = "wyze_lock"
	DeviceTypeYaleLock               DeviceType = "yale_lock"
	DeviceTypeTwoNIntercom           DeviceType = "two_n_intercom"
	DeviceTypeControlbywebDevice     DeviceType = "controlbyweb_device"
	DeviceTypeTtlockLock             DeviceType = "ttlock_lock"
	DeviceTypeIgloohomeLock          DeviceType = "igloohome_lock"
	DeviceTypeHubitatLock            DeviceType = "hubitat_lock"
	DeviceTypeFourSuitesDoor         DeviceType = "four_suites_door"
	DeviceTypeDormakabaOracodeDoor   DeviceType = "dormakaba_oracode_door"
	DeviceTypeNoiseawareActivityZone DeviceType = "noiseaware_activity_zone"
	DeviceTypeMinutSensor            DeviceType = "minut_sensor"
	DeviceTypeEcobeeThermostat       DeviceType = "ecobee_thermostat"
	DeviceTypeNestThermostat         DeviceType = "nest_thermostat"
	DeviceTypeIosPhone               DeviceType = "ios_phone"
	DeviceTypeAndroidPhone           DeviceType = "android_phone"
)

func NewDeviceTypeFromString(s string) (DeviceType, error) {
	switch s {
	case "akuvox_lock":
		return DeviceTypeAkuvoxLock, nil
	case "august_lock":
		return DeviceTypeAugustLock, nil
	case "brivo_access_point":
		return DeviceTypeBrivoAccessPoint, nil
	case "butterflymx_panel":
		return DeviceTypeButterflymxPanel, nil
	case "avigilon_alta_entry":
		return DeviceTypeAvigilonAltaEntry, nil
	case "doorking_lock":
		return DeviceTypeDoorkingLock, nil
	case "genie_door":
		return DeviceTypeGenieDoor, nil
	case "igloo_lock":
		return DeviceTypeIglooLock, nil
	case "linear_lock":
		return DeviceTypeLinearLock, nil
	case "lockly_lock":
		return DeviceTypeLocklyLock, nil
	case "kwikset_lock":
		return DeviceTypeKwiksetLock, nil
	case "nuki_lock":
		return DeviceTypeNukiLock, nil
	case "salto_lock":
		return DeviceTypeSaltoLock, nil
	case "schlage_lock":
		return DeviceTypeSchlageLock, nil
	case "seam_relay":
		return DeviceTypeSeamRelay, nil
	case "smartthings_lock":
		return DeviceTypeSmartthingsLock, nil
	case "wyze_lock":
		return DeviceTypeWyzeLock, nil
	case "yale_lock":
		return DeviceTypeYaleLock, nil
	case "two_n_intercom":
		return DeviceTypeTwoNIntercom, nil
	case "controlbyweb_device":
		return DeviceTypeControlbywebDevice, nil
	case "ttlock_lock":
		return DeviceTypeTtlockLock, nil
	case "igloohome_lock":
		return DeviceTypeIgloohomeLock, nil
	case "hubitat_lock":
		return DeviceTypeHubitatLock, nil
	case "four_suites_door":
		return DeviceTypeFourSuitesDoor, nil
	case "dormakaba_oracode_door":
		return DeviceTypeDormakabaOracodeDoor, nil
	case "noiseaware_activity_zone":
		return DeviceTypeNoiseawareActivityZone, nil
	case "minut_sensor":
		return DeviceTypeMinutSensor, nil
	case "ecobee_thermostat":
		return DeviceTypeEcobeeThermostat, nil
	case "nest_thermostat":
		return DeviceTypeNestThermostat, nil
	case "ios_phone":
		return DeviceTypeIosPhone, nil
	case "android_phone":
		return DeviceTypeAndroidPhone, nil
	}
	var t DeviceType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DeviceType) Ptr() *DeviceType {
	return &d
}

type DeviceWarningsItem struct {
	WarningCode string `json:"warning_code" url:"warning_code"`
	Message     string `json:"message" url:"message"`

	_rawJSON json.RawMessage
}

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

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

type EnrollmentAutomation struct {
	CredentialManagerAcsSystemId string    `json:"credential_manager_acs_system_id" url:"credential_manager_acs_system_id"`
	UserIdentityId               string    `json:"user_identity_id" url:"user_identity_id"`
	CreatedAt                    time.Time `json:"created_at" url:"created_at"`
	WorkspaceId                  string    `json:"workspace_id" url:"workspace_id"`
	EnrollmentAutomationId       string    `json:"enrollment_automation_id" url:"enrollment_automation_id"`

	_rawJSON json.RawMessage
}

func (e *EnrollmentAutomation) UnmarshalJSON(data []byte) error {
	type embed EnrollmentAutomation
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*e),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*e = EnrollmentAutomation(unmarshaler.embed)
	e.CreatedAt = unmarshaler.CreatedAt.Time()
	e._rawJSON = json.RawMessage(data)
	return nil
}

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

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

type Event struct {
	EventId                string    `json:"event_id" url:"event_id"`
	DeviceId               *string   `json:"device_id,omitempty" url:"device_id,omitempty"`
	ActionAttemptId        *string   `json:"action_attempt_id,omitempty" url:"action_attempt_id,omitempty"`
	AcsCredentialId        *string   `json:"acs_credential_id,omitempty" url:"acs_credential_id,omitempty"`
	AcsUserId              *string   `json:"acs_user_id,omitempty" url:"acs_user_id,omitempty"`
	AcsSystemId            *string   `json:"acs_system_id,omitempty" url:"acs_system_id,omitempty"`
	ClientSessionId        *string   `json:"client_session_id,omitempty" url:"client_session_id,omitempty"`
	EnrollmentAutomationId *string   `json:"enrollment_automation_id,omitempty" url:"enrollment_automation_id,omitempty"`
	EventType              string    `json:"event_type" url:"event_type"`
	WorkspaceId            string    `json:"workspace_id" url:"workspace_id"`
	CreatedAt              time.Time `json:"created_at" url:"created_at"`
	OccurredAt             time.Time `json:"occurred_at" url:"occurred_at"`

	_rawJSON json.RawMessage
}

func (e *Event) UnmarshalJSON(data []byte) error {
	type embed Event
	var unmarshaler = struct {
		embed
		CreatedAt  *core.DateTime `json:"created_at"`
		OccurredAt *core.DateTime `json:"occurred_at"`
	}{
		embed: embed(*e),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*e = Event(unmarshaler.embed)
	e.CreatedAt = unmarshaler.CreatedAt.Time()
	e.OccurredAt = unmarshaler.OccurredAt.Time()
	e._rawJSON = json.RawMessage(data)
	return nil
}

func (e *Event) MarshalJSON() ([]byte, error) {
	type embed Event
	var marshaler = struct {
		embed
		CreatedAt  *core.DateTime `json:"created_at"`
		OccurredAt *core.DateTime `json:"occurred_at"`
	}{
		embed:      embed(*e),
		CreatedAt:  core.NewDateTime(e.CreatedAt),
		OccurredAt: core.NewDateTime(e.OccurredAt),
	}
	return json.Marshal(marshaler)
}

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

type EventType string

const (
	EventTypeDeviceConnected                             EventType = "device.connected"
	EventTypeDeviceUnmanagedConnected                    EventType = "device.unmanaged.connected"
	EventTypeDeviceDisconnected                          EventType = "device.disconnected"
	EventTypeDeviceUnmanagedDisconnected                 EventType = "device.unmanaged.disconnected"
	EventTypeDeviceConvertedToUnmanaged                  EventType = "device.converted_to_unmanaged"
	EventTypeDeviceUnmanagedConvertedToManaged           EventType = "device.unmanaged.converted_to_managed"
	EventTypeDeviceRemoved                               EventType = "device.removed"
	EventTypeDeviceTampered                              EventType = "device.tampered"
	EventTypeDeviceLowBattery                            EventType = "device.low_battery"
	EventTypeDeviceBatteryStatusChanged                  EventType = "device.battery_status_changed"
	EventTypeDeviceThirdPartyIntegrationDetected         EventType = "device.third_party_integration_detected"
	EventTypeDeviceThirdPartyIntegrationNoLongerDetected EventType = "device.third_party_integration_no_longer_detected"
	EventTypeDeviceSaltoPrivacyModeActivated             EventType = "device.salto.privacy_mode_activated"
	EventTypeDeviceSaltoPrivacyModeDeactivated           EventType = "device.salto.privacy_mode_deactivated"
	EventTypeDeviceConnectionBecameFlaky                 EventType = "device.connection_became_flaky"
	EventTypeDeviceConnectionStabilized                  EventType = "device.connection_stabilized"
	EventTypeDeviceErrorSubscriptionRequired             EventType = "device.error.subscription_required"
	EventTypeDeviceErrorSubscriptionRequiredResolved     EventType = "device.error.subscription_required.resolved"
	EventTypeAccessCodeCreated                           EventType = "access_code.created"
	EventTypeAccessCodeChanged                           EventType = "access_code.changed"
	EventTypeAccessCodeScheduledOnDevice                 EventType = "access_code.scheduled_on_device"
	EventTypeAccessCodeSetOnDevice                       EventType = "access_code.set_on_device"
	EventTypeAccessCodeDeleted                           EventType = "access_code.deleted"
	EventTypeAccessCodeRemovedFromDevice                 EventType = "access_code.removed_from_device"
	EventTypeAccessCodeFailedToSetOnDevice               EventType = "access_code.failed_to_set_on_device"
	EventTypeAccessCodeDelayInSettingOnDevice            EventType = "access_code.delay_in_setting_on_device"
	EventTypeAccessCodeFailedToRemoveFromDevice          EventType = "access_code.failed_to_remove_from_device"
	EventTypeAccessCodeDelayInRemovingFromDevice         EventType = "access_code.delay_in_removing_from_device"
	EventTypeAccessCodeDeletedExternalToSeam             EventType = "access_code.deleted_external_to_seam"
	EventTypeAccessCodeModifiedExternalToSeam            EventType = "access_code.modified_external_to_seam"
	EventTypeAccessCodeUnmanagedConvertedToManaged       EventType = "access_code.unmanaged.converted_to_managed"
	EventTypeAccessCodeUnmanagedFailedToConvertToManaged EventType = "access_code.unmanaged.failed_to_convert_to_managed"
	EventTypeAccessCodeUnmanagedCreated                  EventType = "access_code.unmanaged.created"
	EventTypeAccessCodeUnmanagedRemoved                  EventType = "access_code.unmanaged.removed"
	EventTypeLockLocked                                  EventType = "lock.locked"
	EventTypeLockUnlocked                                EventType = "lock.unlocked"
	EventTypeConnectedAccountConnected                   EventType = "connected_account.connected"
	EventTypeConnectedAccountSuccessfulLogin             EventType = "connected_account.successful_login"
	EventTypeConnectedAccountCreated                     EventType = "connected_account.created"
	EventTypeConnectedAccountDeleted                     EventType = "connected_account.deleted"
	EventTypeConnectedAccountDisconnected                EventType = "connected_account.disconnected"
	EventTypeConnectedAccountCompletedFirstSync          EventType = "connected_account.completed_first_sync"
	EventTypeNoiseSensorNoiseThresholdTriggered          EventType = "noise_sensor.noise_threshold_triggered"
	EventTypeAccessCodeBackupAccessCodePulled            EventType = "access_code.backup_access_code_pulled"
	EventTypeEnrollmentAutomationDeleted                 EventType = "enrollment_automation.deleted"
	EventTypeAcsUserDeleted                              EventType = "acs_user.deleted"
	EventTypeAcsCredentialDeleted                        EventType = "acs_credential.deleted"
	EventTypePhoneDeactivated                            EventType = "phone.deactivated"
	EventTypeClientSessionDeleted                        EventType = "client_session.deleted"
)

func NewEventTypeFromString(s string) (EventType, error) {
	switch s {
	case "device.connected":
		return EventTypeDeviceConnected, nil
	case "device.unmanaged.connected":
		return EventTypeDeviceUnmanagedConnected, nil
	case "device.disconnected":
		return EventTypeDeviceDisconnected, nil
	case "device.unmanaged.disconnected":
		return EventTypeDeviceUnmanagedDisconnected, nil
	case "device.converted_to_unmanaged":
		return EventTypeDeviceConvertedToUnmanaged, nil
	case "device.unmanaged.converted_to_managed":
		return EventTypeDeviceUnmanagedConvertedToManaged, nil
	case "device.removed":
		return EventTypeDeviceRemoved, nil
	case "device.tampered":
		return EventTypeDeviceTampered, nil
	case "device.low_battery":
		return EventTypeDeviceLowBattery, nil
	case "device.battery_status_changed":
		return EventTypeDeviceBatteryStatusChanged, nil
	case "device.third_party_integration_detected":
		return EventTypeDeviceThirdPartyIntegrationDetected, nil
	case "device.third_party_integration_no_longer_detected":
		return EventTypeDeviceThirdPartyIntegrationNoLongerDetected, nil
	case "device.salto.privacy_mode_activated":
		return EventTypeDeviceSaltoPrivacyModeActivated, nil
	case "device.salto.privacy_mode_deactivated":
		return EventTypeDeviceSaltoPrivacyModeDeactivated, nil
	case "device.connection_became_flaky":
		return EventTypeDeviceConnectionBecameFlaky, nil
	case "device.connection_stabilized":
		return EventTypeDeviceConnectionStabilized, nil
	case "device.error.subscription_required":
		return EventTypeDeviceErrorSubscriptionRequired, nil
	case "device.error.subscription_required.resolved":
		return EventTypeDeviceErrorSubscriptionRequiredResolved, nil
	case "access_code.created":
		return EventTypeAccessCodeCreated, nil
	case "access_code.changed":
		return EventTypeAccessCodeChanged, nil
	case "access_code.scheduled_on_device":
		return EventTypeAccessCodeScheduledOnDevice, nil
	case "access_code.set_on_device":
		return EventTypeAccessCodeSetOnDevice, nil
	case "access_code.deleted":
		return EventTypeAccessCodeDeleted, nil
	case "access_code.removed_from_device":
		return EventTypeAccessCodeRemovedFromDevice, nil
	case "access_code.failed_to_set_on_device":
		return EventTypeAccessCodeFailedToSetOnDevice, nil
	case "access_code.delay_in_setting_on_device":
		return EventTypeAccessCodeDelayInSettingOnDevice, nil
	case "access_code.failed_to_remove_from_device":
		return EventTypeAccessCodeFailedToRemoveFromDevice, nil
	case "access_code.delay_in_removing_from_device":
		return EventTypeAccessCodeDelayInRemovingFromDevice, nil
	case "access_code.deleted_external_to_seam":
		return EventTypeAccessCodeDeletedExternalToSeam, nil
	case "access_code.modified_external_to_seam":
		return EventTypeAccessCodeModifiedExternalToSeam, nil
	case "access_code.unmanaged.converted_to_managed":
		return EventTypeAccessCodeUnmanagedConvertedToManaged, nil
	case "access_code.unmanaged.failed_to_convert_to_managed":
		return EventTypeAccessCodeUnmanagedFailedToConvertToManaged, nil
	case "access_code.unmanaged.created":
		return EventTypeAccessCodeUnmanagedCreated, nil
	case "access_code.unmanaged.removed":
		return EventTypeAccessCodeUnmanagedRemoved, nil
	case "lock.locked":
		return EventTypeLockLocked, nil
	case "lock.unlocked":
		return EventTypeLockUnlocked, nil
	case "connected_account.connected":
		return EventTypeConnectedAccountConnected, nil
	case "connected_account.successful_login":
		return EventTypeConnectedAccountSuccessfulLogin, nil
	case "connected_account.created":
		return EventTypeConnectedAccountCreated, nil
	case "connected_account.deleted":
		return EventTypeConnectedAccountDeleted, nil
	case "connected_account.disconnected":
		return EventTypeConnectedAccountDisconnected, nil
	case "connected_account.completed_first_sync":
		return EventTypeConnectedAccountCompletedFirstSync, nil
	case "noise_sensor.noise_threshold_triggered":
		return EventTypeNoiseSensorNoiseThresholdTriggered, nil
	case "access_code.backup_access_code_pulled":
		return EventTypeAccessCodeBackupAccessCodePulled, nil
	case "enrollment_automation.deleted":
		return EventTypeEnrollmentAutomationDeleted, nil
	case "acs_user.deleted":
		return EventTypeAcsUserDeleted, nil
	case "acs_credential.deleted":
		return EventTypeAcsCredentialDeleted, nil
	case "phone.deactivated":
		return EventTypePhoneDeactivated, nil
	case "client_session.deleted":
		return EventTypeClientSessionDeleted, nil
	}
	var t EventType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type FanMode string

const (
	FanModeAuto FanMode = "auto"
	FanModeOn   FanMode = "on"
)

func NewFanModeFromString(s string) (FanMode, error) {
	switch s {
	case "auto":
		return FanModeAuto, nil
	case "on":
		return FanModeOn, nil
	}
	var t FanMode
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type FanModeSetting string

const (
	FanModeSettingAuto FanModeSetting = "auto"
	FanModeSettingOn   FanModeSetting = "on"
)

func NewFanModeSettingFromString(s string) (FanModeSetting, error) {
	switch s {
	case "auto":
		return FanModeSettingAuto, nil
	case "on":
		return FanModeSettingOn, nil
	}
	var t FanModeSetting
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type HvacModeSetting string

const (
	HvacModeSettingOff      HvacModeSetting = "off"
	HvacModeSettingHeat     HvacModeSetting = "heat"
	HvacModeSettingCool     HvacModeSetting = "cool"
	HvacModeSettingHeatCool HvacModeSetting = "heat_cool"
)

func NewHvacModeSettingFromString(s string) (HvacModeSetting, error) {
	switch s {
	case "off":
		return HvacModeSettingOff, nil
	case "heat":
		return HvacModeSettingHeat, nil
	case "cool":
		return HvacModeSettingCool, nil
	case "heat_cool":
		return HvacModeSettingHeatCool, nil
	}
	var t HvacModeSetting
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (h HvacModeSetting) Ptr() *HvacModeSetting {
	return &h
}

type Manufacturer string

const (
	ManufacturerAkuvox           Manufacturer = "akuvox"
	ManufacturerAugust           Manufacturer = "august"
	ManufacturerAvigilonAlta     Manufacturer = "avigilon_alta"
	ManufacturerBrivo            Manufacturer = "brivo"
	ManufacturerButterflymx      Manufacturer = "butterflymx"
	ManufacturerDoorking         Manufacturer = "doorking"
	ManufacturerFourSuites       Manufacturer = "four_suites"
	ManufacturerGenie            Manufacturer = "genie"
	ManufacturerIgloo            Manufacturer = "igloo"
	ManufacturerKeywe            Manufacturer = "keywe"
	ManufacturerKwikset          Manufacturer = "kwikset"
	ManufacturerLinear           Manufacturer = "linear"
	ManufacturerLockly           Manufacturer = "lockly"
	ManufacturerNuki             Manufacturer = "nuki"
	ManufacturerPhilia           Manufacturer = "philia"
	ManufacturerSalto            Manufacturer = "salto"
	ManufacturerSamsung          Manufacturer = "samsung"
	ManufacturerSchlage          Manufacturer = "schlage"
	ManufacturerSeam             Manufacturer = "seam"
	ManufacturerUnknown          Manufacturer = "unknown"
	ManufacturerWyze             Manufacturer = "wyze"
	ManufacturerYale             Manufacturer = "yale"
	ManufacturerMinut            Manufacturer = "minut"
	ManufacturerTwoN             Manufacturer = "two_n"
	ManufacturerTtlock           Manufacturer = "ttlock"
	ManufacturerNest             Manufacturer = "nest"
	ManufacturerIgloohome        Manufacturer = "igloohome"
	ManufacturerEcobee           Manufacturer = "ecobee"
	ManufacturerHubitat          Manufacturer = "hubitat"
	ManufacturerControlbyweb     Manufacturer = "controlbyweb"
	ManufacturerSmartthings      Manufacturer = "smartthings"
	ManufacturerDormakabaOracode Manufacturer = "dormakaba_oracode"
)

func NewManufacturerFromString(s string) (Manufacturer, error) {
	switch s {
	case "akuvox":
		return ManufacturerAkuvox, nil
	case "august":
		return ManufacturerAugust, nil
	case "avigilon_alta":
		return ManufacturerAvigilonAlta, nil
	case "brivo":
		return ManufacturerBrivo, nil
	case "butterflymx":
		return ManufacturerButterflymx, nil
	case "doorking":
		return ManufacturerDoorking, nil
	case "four_suites":
		return ManufacturerFourSuites, nil
	case "genie":
		return ManufacturerGenie, nil
	case "igloo":
		return ManufacturerIgloo, nil
	case "keywe":
		return ManufacturerKeywe, nil
	case "kwikset":
		return ManufacturerKwikset, nil
	case "linear":
		return ManufacturerLinear, nil
	case "lockly":
		return ManufacturerLockly, nil
	case "nuki":
		return ManufacturerNuki, nil
	case "philia":
		return ManufacturerPhilia, nil
	case "salto":
		return ManufacturerSalto, nil
	case "samsung":
		return ManufacturerSamsung, nil
	case "schlage":
		return ManufacturerSchlage, nil
	case "seam":
		return ManufacturerSeam, nil
	case "unknown":
		return ManufacturerUnknown, nil
	case "wyze":
		return ManufacturerWyze, nil
	case "yale":
		return ManufacturerYale, nil
	case "minut":
		return ManufacturerMinut, nil
	case "two_n":
		return ManufacturerTwoN, nil
	case "ttlock":
		return ManufacturerTtlock, nil
	case "nest":
		return ManufacturerNest, nil
	case "igloohome":
		return ManufacturerIgloohome, nil
	case "ecobee":
		return ManufacturerEcobee, nil
	case "hubitat":
		return ManufacturerHubitat, nil
	case "controlbyweb":
		return ManufacturerControlbyweb, nil
	case "smartthings":
		return ManufacturerSmartthings, nil
	case "dormakaba_oracode":
		return ManufacturerDormakabaOracode, nil
	}
	var t Manufacturer
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type MaxTimeRounding string

const (
	MaxTimeRoundingOneHour MaxTimeRounding = "1hour"
	MaxTimeRoundingOneDay  MaxTimeRounding = "1day"
	MaxTimeRoundingOneH    MaxTimeRounding = "1h"
	MaxTimeRoundingOneD    MaxTimeRounding = "1d"
)

func NewMaxTimeRoundingFromString(s string) (MaxTimeRounding, error) {
	switch s {
	case "1hour":
		return MaxTimeRoundingOneHour, nil
	case "1day":
		return MaxTimeRoundingOneDay, nil
	case "1h":
		return MaxTimeRoundingOneH, nil
	case "1d":
		return MaxTimeRoundingOneD, nil
	}
	var t MaxTimeRounding
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type Network struct {
	NetworkId   string    `json:"network_id" url:"network_id"`
	WorkspaceId string    `json:"workspace_id" url:"workspace_id"`
	DisplayName string    `json:"display_name" url:"display_name"`
	CreatedAt   time.Time `json:"created_at" url:"created_at"`

	_rawJSON json.RawMessage
}

func (n *Network) UnmarshalJSON(data []byte) error {
	type embed Network
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*n),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*n = Network(unmarshaler.embed)
	n.CreatedAt = unmarshaler.CreatedAt.Time()
	n._rawJSON = json.RawMessage(data)
	return nil
}

func (n *Network) MarshalJSON() ([]byte, error) {
	type embed Network
	var marshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed:     embed(*n),
		CreatedAt: core.NewDateTime(n.CreatedAt),
	}
	return json.Marshal(marshaler)
}

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

type NoiseThreshold struct {
	NoiseThresholdId       string   `json:"noise_threshold_id" url:"noise_threshold_id"`
	DeviceId               string   `json:"device_id" url:"device_id"`
	Name                   string   `json:"name" url:"name"`
	NoiseThresholdNrs      *float64 `json:"noise_threshold_nrs,omitempty" url:"noise_threshold_nrs,omitempty"`
	StartsDailyAt          string   `json:"starts_daily_at" url:"starts_daily_at"`
	EndsDailyAt            string   `json:"ends_daily_at" url:"ends_daily_at"`
	NoiseThresholdDecibels float64  `json:"noise_threshold_decibels" url:"noise_threshold_decibels"`

	_rawJSON json.RawMessage
}

func (n *NoiseThreshold) UnmarshalJSON(data []byte) error {
	type unmarshaler NoiseThreshold
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*n = NoiseThreshold(value)
	n._rawJSON = json.RawMessage(data)
	return nil
}

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

type Phone struct {
	// Unique identifier for the device.
	DeviceId   string          `json:"device_id" url:"device_id"`
	DeviceType PhoneDeviceType `json:"device_type,omitempty" url:"device_type,omitempty"`
	// Optional nickname to describe the device, settable through Seam
	Nickname *string `json:"nickname,omitempty" url:"nickname,omitempty"`
	// Display name of the device, defaults to nickname (if it is set) or properties.appearance.name otherwise. Enables administrators and users to identify the device easily, especially when there are numerous devices.
	DisplayName string `json:"display_name" url:"display_name"`
	// Collection of capabilities that the device supports when connected to Seam. Values are "access_code," which indicates that the device can manage and utilize digital PIN codes for secure access; "lock," which indicates that the device controls a door locking mechanism, enabling the remote opening and closing of doors and other entry points; "noise_detection," which indicates that the device supports monitoring and responding to ambient noise levels; "thermostat," which indicates that the device can regulate and adjust indoor temperatures; and "battery," which indicates that the device can manage battery life and health.
	CapabilitiesSupported []PhoneCapabilitiesSupportedItem `json:"capabilities_supported,omitempty" url:"capabilities_supported,omitempty"`
	Properties            *PhoneProperties                 `json:"properties,omitempty" url:"properties,omitempty"`
	// Location information for the device.
	Location *PhoneLocation `json:"location,omitempty" url:"location,omitempty"`
	// Unique identifier for the Seam workspace associated with the device.
	WorkspaceId string `json:"workspace_id" url:"workspace_id"`
	// Array of errors associated with the device. Each error object within the array contains two fields: "error_code" and "message." "error_code" is a string that uniquely identifies the type of error, enabling quick recognition and categorization of the issue. "message" provides a more detailed description of the error, offering insights into the issue and potentially how to rectify it.
	Errors []*PhoneErrorsItem `json:"errors,omitempty" url:"errors,omitempty"`
	// Array of warnings associated with the device. Each warning object within the array contains two fields: "warning_code" and "message." "warning_code" is a string that uniquely identifies the type of warning, enabling quick recognition and categorization of the issue. "message" provides a more detailed description of the warning, offering insights into the issue and potentially how to rectify it.
	Warnings []*PhoneWarningsItem `json:"warnings,omitempty" url:"warnings,omitempty"`
	// Date and time at which the device object was created.
	CreatedAt time.Time `json:"created_at" url:"created_at"`
	// Indicates whether Seam manages the device.
	IsManaged                    bool                                 `json:"is_managed" url:"is_managed"`
	CustomMetadata               map[string]*PhoneCustomMetadataValue `json:"custom_metadata,omitempty" url:"custom_metadata,omitempty"`
	CanRemotelyUnlock            *bool                                `json:"can_remotely_unlock,omitempty" url:"can_remotely_unlock,omitempty"`
	CanRemotelyLock              *bool                                `json:"can_remotely_lock,omitempty" url:"can_remotely_lock,omitempty"`
	CanProgramOfflineAccessCodes *bool                                `json:"can_program_offline_access_codes,omitempty" url:"can_program_offline_access_codes,omitempty"`
	CanProgramOnlineAccessCodes  *bool                                `json:"can_program_online_access_codes,omitempty" url:"can_program_online_access_codes,omitempty"`
	CanSimulateRemoval           *bool                                `json:"can_simulate_removal,omitempty" url:"can_simulate_removal,omitempty"`

	_rawJSON json.RawMessage
}

func (p *Phone) UnmarshalJSON(data []byte) error {
	type embed Phone
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*p),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*p = Phone(unmarshaler.embed)
	p.CreatedAt = unmarshaler.CreatedAt.Time()
	p._rawJSON = json.RawMessage(data)
	return nil
}

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

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

type PhoneCapabilitiesSupportedItem string

const (
	PhoneCapabilitiesSupportedItemAccessCode     PhoneCapabilitiesSupportedItem = "access_code"
	PhoneCapabilitiesSupportedItemLock           PhoneCapabilitiesSupportedItem = "lock"
	PhoneCapabilitiesSupportedItemNoiseDetection PhoneCapabilitiesSupportedItem = "noise_detection"
	PhoneCapabilitiesSupportedItemThermostat     PhoneCapabilitiesSupportedItem = "thermostat"
	PhoneCapabilitiesSupportedItemBattery        PhoneCapabilitiesSupportedItem = "battery"
	PhoneCapabilitiesSupportedItemPhone          PhoneCapabilitiesSupportedItem = "phone"
)

func NewPhoneCapabilitiesSupportedItemFromString(s string) (PhoneCapabilitiesSupportedItem, error) {
	switch s {
	case "access_code":
		return PhoneCapabilitiesSupportedItemAccessCode, nil
	case "lock":
		return PhoneCapabilitiesSupportedItemLock, nil
	case "noise_detection":
		return PhoneCapabilitiesSupportedItemNoiseDetection, nil
	case "thermostat":
		return PhoneCapabilitiesSupportedItemThermostat, nil
	case "battery":
		return PhoneCapabilitiesSupportedItemBattery, nil
	case "phone":
		return PhoneCapabilitiesSupportedItemPhone, nil
	}
	var t PhoneCapabilitiesSupportedItem
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (p PhoneCapabilitiesSupportedItem) Ptr() *PhoneCapabilitiesSupportedItem {
	return &p
}

type PhoneCustomMetadataValue struct {
	typeName string
	String   string
	Boolean  bool
}

func NewPhoneCustomMetadataValueFromString(value string) *PhoneCustomMetadataValue {
	return &PhoneCustomMetadataValue{typeName: "string", String: value}
}

func NewPhoneCustomMetadataValueFromBoolean(value bool) *PhoneCustomMetadataValue {
	return &PhoneCustomMetadataValue{typeName: "boolean", Boolean: value}
}

func (p *PhoneCustomMetadataValue) UnmarshalJSON(data []byte) error {
	var valueString string
	if err := json.Unmarshal(data, &valueString); err == nil {
		p.typeName = "string"
		p.String = valueString
		return nil
	}
	var valueBoolean bool
	if err := json.Unmarshal(data, &valueBoolean); err == nil {
		p.typeName = "boolean"
		p.Boolean = valueBoolean
		return nil
	}
	return fmt.Errorf("%s cannot be deserialized as a %T", data, p)
}

func (p PhoneCustomMetadataValue) MarshalJSON() ([]byte, error) {
	switch p.typeName {
	default:
		return nil, fmt.Errorf("invalid type %s in %T", p.typeName, p)
	case "string":
		return json.Marshal(p.String)
	case "boolean":
		return json.Marshal(p.Boolean)
	}
}

type PhoneCustomMetadataValueVisitor interface {
	VisitString(string) error
	VisitBoolean(bool) error
}

func (p *PhoneCustomMetadataValue) Accept(visitor PhoneCustomMetadataValueVisitor) error {
	switch p.typeName {
	default:
		return fmt.Errorf("invalid type %s in %T", p.typeName, p)
	case "string":
		return visitor.VisitString(p.String)
	case "boolean":
		return visitor.VisitBoolean(p.Boolean)
	}
}

type PhoneDeviceType string

const (
	PhoneDeviceTypeAndroidPhone PhoneDeviceType = "android_phone"
	PhoneDeviceTypeIosPhone     PhoneDeviceType = "ios_phone"
)

func NewPhoneDeviceTypeFromString(s string) (PhoneDeviceType, error) {
	switch s {
	case "android_phone":
		return PhoneDeviceTypeAndroidPhone, nil
	case "ios_phone":
		return PhoneDeviceTypeIosPhone, nil
	}
	var t PhoneDeviceType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (p PhoneDeviceType) Ptr() *PhoneDeviceType {
	return &p
}

type PhoneErrorsItem struct {
	ErrorCode string `json:"error_code" url:"error_code"`
	Message   string `json:"message" url:"message"`

	_rawJSON json.RawMessage
}

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

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

// Location information for the device.
type PhoneLocation struct {
	// Name of the device location.
	LocationName *string `json:"location_name,omitempty" url:"location_name,omitempty"`
	// Time zone of the device location.
	Timezone *string `json:"timezone,omitempty" url:"timezone,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type PhoneOperatingSystem string

const (
	PhoneOperatingSystemAndroid PhoneOperatingSystem = "android"
	PhoneOperatingSystemIos     PhoneOperatingSystem = "ios"
)

func NewPhoneOperatingSystemFromString(s string) (PhoneOperatingSystem, error) {
	switch s {
	case "android":
		return PhoneOperatingSystemAndroid, nil
	case "ios":
		return PhoneOperatingSystemIos, nil
	}
	var t PhoneOperatingSystem
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (p PhoneOperatingSystem) Ptr() *PhoneOperatingSystem {
	return &p
}

type PhoneProperties struct {
	AssaAbloyCredentialServiceMetadata *PhonePropertiesAssaAbloyCredentialServiceMetadata `json:"assa_abloy_credential_service_metadata,omitempty" url:"assa_abloy_credential_service_metadata,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type PhonePropertiesAssaAbloyCredentialServiceMetadata struct {
	HasActiveEndpoint bool                                                              `json:"has_active_endpoint" url:"has_active_endpoint"`
	Endpoints         []*PhonePropertiesAssaAbloyCredentialServiceMetadataEndpointsItem `json:"endpoints,omitempty" url:"endpoints,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type PhonePropertiesAssaAbloyCredentialServiceMetadataEndpointsItem struct {
	EndpointId string `json:"endpoint_id" url:"endpoint_id"`
	IsActive   bool   `json:"is_active" url:"is_active"`

	_rawJSON json.RawMessage
}

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

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

type PhoneWarningsItem struct {
	WarningCode string `json:"warning_code" url:"warning_code"`
	Message     string `json:"message" url:"message"`

	_rawJSON json.RawMessage
}

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

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

type ProviderCategory string

const (
	ProviderCategoryStable             ProviderCategory = "stable"
	ProviderCategoryConsumerSmartlocks ProviderCategory = "consumer_smartlocks"
)

func NewProviderCategoryFromString(s string) (ProviderCategory, error) {
	switch s {
	case "stable":
		return ProviderCategoryStable, nil
	case "consumer_smartlocks":
		return ProviderCategoryConsumerSmartlocks, nil
	}
	var t ProviderCategory
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (p ProviderCategory) Ptr() *ProviderCategory {
	return &p
}

type SelectionMode string

const (
	SelectionModeNone     SelectionMode = "none"
	SelectionModeSingle   SelectionMode = "single"
	SelectionModeMultiple SelectionMode = "multiple"
)

func NewSelectionModeFromString(s string) (SelectionMode, error) {
	switch s {
	case "none":
		return SelectionModeNone, nil
	case "single":
		return SelectionModeSingle, nil
	case "multiple":
		return SelectionModeMultiple, nil
	}
	var t SelectionMode
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type ServiceHealth struct {
	Service     string              `json:"service" url:"service"`
	Status      ServiceHealthStatus `json:"status,omitempty" url:"status,omitempty"`
	Description string              `json:"description" url:"description"`

	_rawJSON json.RawMessage
}

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

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

type ServiceHealthStatus string

const (
	ServiceHealthStatusHealthy  ServiceHealthStatus = "healthy"
	ServiceHealthStatusDegraded ServiceHealthStatus = "degraded"
	ServiceHealthStatusDown     ServiceHealthStatus = "down"
)

func NewServiceHealthStatusFromString(s string) (ServiceHealthStatus, error) {
	switch s {
	case "healthy":
		return ServiceHealthStatusHealthy, nil
	case "degraded":
		return ServiceHealthStatusDegraded, nil
	case "down":
		return ServiceHealthStatusDown, nil
	}
	var t ServiceHealthStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type UnmanagedAccessCode struct {
	// Nature of the access code. Values are "ongoing" for access codes that are active continuously until deactivated manually or "time_bound" for access codes that have a specific duration.
	Type UnmanagedAccessCodeType `json:"type,omitempty" url:"type,omitempty"`
	// Unique identifier for the access code.
	AccessCodeId string `json:"access_code_id" url:"access_code_id"`
	// Unique identifier for the device associated with the access code.
	DeviceId string `json:"device_id" url:"device_id"`
	// Name of the access code. Enables administrators and users to identify the access code easily, especially when there are numerous access codes.
	Name *string `json:"name,omitempty" url:"name,omitempty"`
	// Code used for access. Typically, a numeric or alphanumeric string.
	Code *string `json:"code,omitempty" url:"code,omitempty"`
	// Date and time at which the access code was created.
	CreatedAt time.Time   `json:"created_at" url:"created_at"`
	Errors    interface{} `json:"errors,omitempty" url:"errors,omitempty"`
	Warnings  interface{} `json:"warnings,omitempty" url:"warnings,omitempty"`
	IsManaged bool        `json:"is_managed" url:"is_managed"`
	// Date and time at which the time-bound access code becomes active.
	StartsAt *time.Time `json:"starts_at,omitempty" url:"starts_at,omitempty"`
	// Date and time after which the time-bound access code becomes inactive.
	EndsAt *time.Time `json:"ends_at,omitempty" url:"ends_at,omitempty"`
	status string

	_rawJSON json.RawMessage
}

func (u *UnmanagedAccessCode) Status() string {
	return u.status
}

func (u *UnmanagedAccessCode) UnmarshalJSON(data []byte) error {
	type embed UnmanagedAccessCode
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
		StartsAt  *core.DateTime `json:"starts_at,omitempty"`
		EndsAt    *core.DateTime `json:"ends_at,omitempty"`
	}{
		embed: embed(*u),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*u = UnmanagedAccessCode(unmarshaler.embed)
	u.CreatedAt = unmarshaler.CreatedAt.Time()
	u.StartsAt = unmarshaler.StartsAt.TimePtr()
	u.EndsAt = unmarshaler.EndsAt.TimePtr()
	u.status = "set"
	u._rawJSON = json.RawMessage(data)
	return nil
}

func (u *UnmanagedAccessCode) MarshalJSON() ([]byte, error) {
	type embed UnmanagedAccessCode
	var marshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
		StartsAt  *core.DateTime `json:"starts_at,omitempty"`
		EndsAt    *core.DateTime `json:"ends_at,omitempty"`
		Status    string         `json:"status"`
	}{
		embed:     embed(*u),
		CreatedAt: core.NewDateTime(u.CreatedAt),
		StartsAt:  core.NewOptionalDateTime(u.StartsAt),
		EndsAt:    core.NewOptionalDateTime(u.EndsAt),
		Status:    "set",
	}
	return json.Marshal(marshaler)
}

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

// Nature of the access code. Values are "ongoing" for access codes that are active continuously until deactivated manually or "time_bound" for access codes that have a specific duration.
type UnmanagedAccessCodeType string

const (
	UnmanagedAccessCodeTypeTimeBound UnmanagedAccessCodeType = "time_bound"
	UnmanagedAccessCodeTypeOngoing   UnmanagedAccessCodeType = "ongoing"
)

func NewUnmanagedAccessCodeTypeFromString(s string) (UnmanagedAccessCodeType, error) {
	switch s {
	case "time_bound":
		return UnmanagedAccessCodeTypeTimeBound, nil
	case "ongoing":
		return UnmanagedAccessCodeTypeOngoing, nil
	}
	var t UnmanagedAccessCodeType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type UnmanagedDevice struct {
	// Unique identifier for the device.
	DeviceId string `json:"device_id" url:"device_id"`
	// Type of the device.
	DeviceType DeviceType `json:"device_type,omitempty" url:"device_type,omitempty"`
	// Unique identifier for the account associated with the device.
	ConnectedAccountId string `json:"connected_account_id" url:"connected_account_id"`
	// Collection of capabilities that the device supports when connected to Seam. Values are "access_code," which indicates that the device can manage and utilize digital PIN codes for secure access; "lock," which indicates that the device controls a door locking mechanism, enabling the remote opening and closing of doors and other entry points; "noise_detection," which indicates that the device supports monitoring and responding to ambient noise levels; "thermostat," which indicates that the device can regulate and adjust indoor temperatures; and "battery," which indicates that the device can manage battery life and health.
	CapabilitiesSupported []UnmanagedDeviceCapabilitiesSupportedItem `json:"capabilities_supported,omitempty" url:"capabilities_supported,omitempty"`
	// Unique identifier for the Seam workspace associated with the device.
	WorkspaceId string `json:"workspace_id" url:"workspace_id"`
	// Array of errors associated with the device. Each error object within the array contains two fields: "error_code" and "message." "error_code" is a string that uniquely identifies the type of error, enabling quick recognition and categorization of the issue. "message" provides a more detailed description of the error, offering insights into the issue and potentially how to rectify it.
	Errors []*UnmanagedDeviceErrorsItem `json:"errors,omitempty" url:"errors,omitempty"`
	// Array of warnings associated with the device. Each warning object within the array contains two fields: "warning_code" and "message." "warning_code" is a string that uniquely identifies the type of warning, enabling quick recognition and categorization of the issue. "message" provides a more detailed description of the warning, offering insights into the issue and potentially how to rectify it.
	Warnings []*UnmanagedDeviceWarningsItem `json:"warnings,omitempty" url:"warnings,omitempty"`
	// Date and time at which the device object was created.
	CreatedAt                    time.Time                      `json:"created_at" url:"created_at"`
	IsManaged                    bool                           `json:"is_managed" url:"is_managed"`
	Properties                   *UnmanagedDeviceProperties     `json:"properties,omitempty" url:"properties,omitempty"`
	CanRemotelyUnlock            *bool                          `json:"can_remotely_unlock,omitempty" url:"can_remotely_unlock,omitempty"`
	CanRemotelyLock              *bool                          `json:"can_remotely_lock,omitempty" url:"can_remotely_lock,omitempty"`
	CanProgramOfflineAccessCodes *bool                          `json:"can_program_offline_access_codes,omitempty" url:"can_program_offline_access_codes,omitempty"`
	CanProgramOnlineAccessCodes  *bool                          `json:"can_program_online_access_codes,omitempty" url:"can_program_online_access_codes,omitempty"`
	CanSimulateRemoval           *bool                          `json:"can_simulate_removal,omitempty" url:"can_simulate_removal,omitempty"`
	DeviceProvider               *UnmanagedDeviceDeviceProvider `json:"device_provider,omitempty" url:"device_provider,omitempty"`

	_rawJSON json.RawMessage
}

func (u *UnmanagedDevice) UnmarshalJSON(data []byte) error {
	type embed UnmanagedDevice
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*u),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*u = UnmanagedDevice(unmarshaler.embed)
	u.CreatedAt = unmarshaler.CreatedAt.Time()
	u._rawJSON = json.RawMessage(data)
	return nil
}

func (u *UnmanagedDevice) MarshalJSON() ([]byte, error) {
	type embed UnmanagedDevice
	var marshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed:     embed(*u),
		CreatedAt: core.NewDateTime(u.CreatedAt),
	}
	return json.Marshal(marshaler)
}

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

type UnmanagedDeviceCapabilitiesSupportedItem string

const (
	UnmanagedDeviceCapabilitiesSupportedItemAccessCode     UnmanagedDeviceCapabilitiesSupportedItem = "access_code"
	UnmanagedDeviceCapabilitiesSupportedItemLock           UnmanagedDeviceCapabilitiesSupportedItem = "lock"
	UnmanagedDeviceCapabilitiesSupportedItemNoiseDetection UnmanagedDeviceCapabilitiesSupportedItem = "noise_detection"
	UnmanagedDeviceCapabilitiesSupportedItemThermostat     UnmanagedDeviceCapabilitiesSupportedItem = "thermostat"
	UnmanagedDeviceCapabilitiesSupportedItemBattery        UnmanagedDeviceCapabilitiesSupportedItem = "battery"
	UnmanagedDeviceCapabilitiesSupportedItemPhone          UnmanagedDeviceCapabilitiesSupportedItem = "phone"
)

func NewUnmanagedDeviceCapabilitiesSupportedItemFromString(s string) (UnmanagedDeviceCapabilitiesSupportedItem, error) {
	switch s {
	case "access_code":
		return UnmanagedDeviceCapabilitiesSupportedItemAccessCode, nil
	case "lock":
		return UnmanagedDeviceCapabilitiesSupportedItemLock, nil
	case "noise_detection":
		return UnmanagedDeviceCapabilitiesSupportedItemNoiseDetection, nil
	case "thermostat":
		return UnmanagedDeviceCapabilitiesSupportedItemThermostat, nil
	case "battery":
		return UnmanagedDeviceCapabilitiesSupportedItemBattery, nil
	case "phone":
		return UnmanagedDeviceCapabilitiesSupportedItemPhone, nil
	}
	var t UnmanagedDeviceCapabilitiesSupportedItem
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type UnmanagedDeviceDeviceProvider struct {
	ProviderCategories interface{} `json:"provider_categories,omitempty" url:"provider_categories,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type UnmanagedDeviceErrorsItem struct {
	ErrorCode string `json:"error_code" url:"error_code"`
	Message   string `json:"message" url:"message"`

	_rawJSON json.RawMessage
}

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

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

type UnmanagedDeviceProperties struct {
	// Represents the accessory keypad state.
	AccessoryKeypad *UnmanagedDevicePropertiesAccessoryKeypad `json:"accessory_keypad,omitempty" url:"accessory_keypad,omitempty"`
	// ---
	// deprecated: use device.display_name instead
	// ---
	// Name of the device.
	Name string `json:"name" url:"name"`
	// Indicates whether the device is online.
	Online bool `json:"online" url:"online"`
	// Manufacturer of the device.
	Manufacturer *string `json:"manufacturer,omitempty" url:"manufacturer,omitempty"`
	// Image URL for the device.
	ImageUrl *string `json:"image_url,omitempty" url:"image_url,omitempty"`
	// Alt text for the device image.
	ImageAltText *string `json:"image_alt_text,omitempty" url:"image_alt_text,omitempty"`
	// Indicates the battery level of the device as a decimal value between 0 and 1, inclusive.
	BatteryLevel *float64 `json:"battery_level,omitempty" url:"battery_level,omitempty"`
	// Represents the current status of the battery charge level. Values are "critical," which indicates an extremely low level, suggesting imminent shutdown or an urgent need for charging; "low," which signifies that the battery is under the preferred threshold and should be charged soon; "good," which denotes a satisfactory charge level, adequate for normal use without the immediate need for recharging; and "full," which represents a battery that is fully charged, providing the maximum duration of usage.
	Battery *UnmanagedDevicePropertiesBattery `json:"battery,omitempty" url:"battery,omitempty"`
	// Indicates whether it is currently possible to use online access codes for the device.
	OnlineAccessCodesEnabled *bool `json:"online_access_codes_enabled,omitempty" url:"online_access_codes_enabled,omitempty"`
	// Indicates whether it is currently possible to use offline access codes for the device.
	OfflineAccessCodesEnabled *bool                           `json:"offline_access_codes_enabled,omitempty" url:"offline_access_codes_enabled,omitempty"`
	Model                     *UnmanagedDevicePropertiesModel `json:"model,omitempty" url:"model,omitempty"`

	_rawJSON json.RawMessage
}

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

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

// Represents the accessory keypad state.
type UnmanagedDevicePropertiesAccessoryKeypad struct {
	// Indicates if the accessory_keypad is connected to the device.
	IsConnected bool `json:"is_connected" url:"is_connected"`
	// Indicates if the keypad battery properties.
	Battery *UnmanagedDevicePropertiesAccessoryKeypadBattery `json:"battery,omitempty" url:"battery,omitempty"`

	_rawJSON json.RawMessage
}

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

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

// Indicates if the keypad battery properties.
type UnmanagedDevicePropertiesAccessoryKeypadBattery struct {
	Level float64 `json:"level" url:"level"`

	_rawJSON json.RawMessage
}

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

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

// Represents the current status of the battery charge level. Values are "critical," which indicates an extremely low level, suggesting imminent shutdown or an urgent need for charging; "low," which signifies that the battery is under the preferred threshold and should be charged soon; "good," which denotes a satisfactory charge level, adequate for normal use without the immediate need for recharging; and "full," which represents a battery that is fully charged, providing the maximum duration of usage.
type UnmanagedDevicePropertiesBattery struct {
	Level  float64                                `json:"level" url:"level"`
	Status UnmanagedDevicePropertiesBatteryStatus `json:"status,omitempty" url:"status,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type UnmanagedDevicePropertiesBatteryStatus string

const (
	UnmanagedDevicePropertiesBatteryStatusCritical UnmanagedDevicePropertiesBatteryStatus = "critical"
	UnmanagedDevicePropertiesBatteryStatusLow      UnmanagedDevicePropertiesBatteryStatus = "low"
	UnmanagedDevicePropertiesBatteryStatusGood     UnmanagedDevicePropertiesBatteryStatus = "good"
	UnmanagedDevicePropertiesBatteryStatusFull     UnmanagedDevicePropertiesBatteryStatus = "full"
)

func NewUnmanagedDevicePropertiesBatteryStatusFromString(s string) (UnmanagedDevicePropertiesBatteryStatus, error) {
	switch s {
	case "critical":
		return UnmanagedDevicePropertiesBatteryStatusCritical, nil
	case "low":
		return UnmanagedDevicePropertiesBatteryStatusLow, nil
	case "good":
		return UnmanagedDevicePropertiesBatteryStatusGood, nil
	case "full":
		return UnmanagedDevicePropertiesBatteryStatusFull, nil
	}
	var t UnmanagedDevicePropertiesBatteryStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type UnmanagedDevicePropertiesModel struct {
	// Indicates whether the device can connect a accessory keypad.
	CanConnectAccessoryKeypad *bool `json:"can_connect_accessory_keypad,omitempty" url:"can_connect_accessory_keypad,omitempty"`
	// Display name of the device model.
	DisplayName string `json:"display_name" url:"display_name"`
	// Display name that corresponds to the manufacturer-specific terminology for the device.
	ManufacturerDisplayName string `json:"manufacturer_display_name" url:"manufacturer_display_name"`
	// Indicates whether the device has a built in accessory keypad.
	HasBuiltInKeypad *bool `json:"has_built_in_keypad,omitempty" url:"has_built_in_keypad,omitempty"`
	// Indicates whether the device supports offline access codes.
	OfflineAccessCodesSupported *bool `json:"offline_access_codes_supported,omitempty" url:"offline_access_codes_supported,omitempty"`
	// Indicates whether the device supports online access codes.
	OnlineAccessCodesSupported *bool `json:"online_access_codes_supported,omitempty" url:"online_access_codes_supported,omitempty"`
	// Indicates whether the device supports an accessory keypad.
	AccessoryKeypadSupported *bool `json:"accessory_keypad_supported,omitempty" url:"accessory_keypad_supported,omitempty"`

	_rawJSON json.RawMessage
}

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

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

type UnmanagedDeviceWarningsItem struct {
	WarningCode string `json:"warning_code" url:"warning_code"`
	Message     string `json:"message" url:"message"`

	_rawJSON json.RawMessage
}

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

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

type UserIdentity struct {
	UserIdentityId  string    `json:"user_identity_id" url:"user_identity_id"`
	UserIdentityKey *string   `json:"user_identity_key,omitempty" url:"user_identity_key,omitempty"`
	EmailAddress    *string   `json:"email_address,omitempty" url:"email_address,omitempty"`
	PhoneNumber     *string   `json:"phone_number,omitempty" url:"phone_number,omitempty"`
	DisplayName     string    `json:"display_name" url:"display_name"`
	FullName        *string   `json:"full_name,omitempty" url:"full_name,omitempty"`
	CreatedAt       time.Time `json:"created_at" url:"created_at"`
	WorkspaceId     string    `json:"workspace_id" url:"workspace_id"`

	_rawJSON json.RawMessage
}

func (u *UserIdentity) UnmarshalJSON(data []byte) error {
	type embed UserIdentity
	var unmarshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed: embed(*u),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*u = UserIdentity(unmarshaler.embed)
	u.CreatedAt = unmarshaler.CreatedAt.Time()
	u._rawJSON = json.RawMessage(data)
	return nil
}

func (u *UserIdentity) MarshalJSON() ([]byte, error) {
	type embed UserIdentity
	var marshaler = struct {
		embed
		CreatedAt *core.DateTime `json:"created_at"`
	}{
		embed:     embed(*u),
		CreatedAt: core.NewDateTime(u.CreatedAt),
	}
	return json.Marshal(marshaler)
}

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

type Webhook struct {
	WebhookId  string   `json:"webhook_id" url:"webhook_id"`
	Url        string   `json:"url" url:"url"`
	EventTypes []string `json:"event_types,omitempty" url:"event_types,omitempty"`
	Secret     *string  `json:"secret,omitempty" url:"secret,omitempty"`

	_rawJSON json.RawMessage
}

func (w *Webhook) UnmarshalJSON(data []byte) error {
	type unmarshaler Webhook
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*w = Webhook(value)
	w._rawJSON = json.RawMessage(data)
	return nil
}

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

type Workspace struct {
	WorkspaceId        string  `json:"workspace_id" url:"workspace_id"`
	Name               string  `json:"name" url:"name"`
	IsSandbox          bool    `json:"is_sandbox" url:"is_sandbox"`
	ConnectPartnerName *string `json:"connect_partner_name,omitempty" url:"connect_partner_name,omitempty"`

	_rawJSON json.RawMessage
}

func (w *Workspace) UnmarshalJSON(data []byte) error {
	type unmarshaler Workspace
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*w = Workspace(value)
	w._rawJSON = json.RawMessage(data)
	return nil
}

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

type ConnectedAccountsGetRequestConnectedAccountId struct {
	ConnectedAccountId string `json:"connected_account_id" url:"connected_account_id"`

	_rawJSON json.RawMessage
}

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

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

type ConnectedAccountsGetRequestEmail struct {
	Email string `json:"email" url:"email"`

	_rawJSON json.RawMessage
}

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

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

type ThermostatsUpdateRequestDefaultClimateSettingHvacModeSetting string

const (
	ThermostatsUpdateRequestDefaultClimateSettingHvacModeSettingOff      ThermostatsUpdateRequestDefaultClimateSettingHvacModeSetting = "off"
	ThermostatsUpdateRequestDefaultClimateSettingHvacModeSettingHeat     ThermostatsUpdateRequestDefaultClimateSettingHvacModeSetting = "heat"
	ThermostatsUpdateRequestDefaultClimateSettingHvacModeSettingCool     ThermostatsUpdateRequestDefaultClimateSettingHvacModeSetting = "cool"
	ThermostatsUpdateRequestDefaultClimateSettingHvacModeSettingHeatCool ThermostatsUpdateRequestDefaultClimateSettingHvacModeSetting = "heat_cool"
)

func NewThermostatsUpdateRequestDefaultClimateSettingHvacModeSettingFromString(s string) (ThermostatsUpdateRequestDefaultClimateSettingHvacModeSetting, error) {
	switch s {
	case "off":
		return ThermostatsUpdateRequestDefaultClimateSettingHvacModeSettingOff, nil
	case "heat":
		return ThermostatsUpdateRequestDefaultClimateSettingHvacModeSettingHeat, nil
	case "cool":
		return ThermostatsUpdateRequestDefaultClimateSettingHvacModeSettingCool, nil
	case "heat_cool":
		return ThermostatsUpdateRequestDefaultClimateSettingHvacModeSettingHeatCool, nil
	}
	var t ThermostatsUpdateRequestDefaultClimateSettingHvacModeSetting
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

type UserIdentitiesGetRequestUserIdentityId struct {
	UserIdentityId string `json:"user_identity_id" url:"user_identity_id"`

	_rawJSON json.RawMessage
}

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

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

type UserIdentitiesGetRequestUserIdentityKey struct {
	UserIdentityKey string `json:"user_identity_key" url:"user_identity_key"`

	_rawJSON json.RawMessage
}

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

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