kv

type ASN = shared.ASN

type ASNParam = shared.ASNParam

type AuditLog = shared.AuditLog

type AuditLogAction = shared.AuditLogAction

type AuditLogActor = shared.AuditLogActor

type AuditLogActorType = shared.AuditLogActorType

type AuditLogOwner = shared.AuditLogOwner

type AuditLogResource = shared.AuditLogResource

type CertificateCA = shared.CertificateCA

type CertificateRequestType = shared.CertificateRequestType

type CloudflareTunnel = shared.CloudflareTunnel

type CloudflareTunnelConfigSrc = shared.CloudflareTunnelConfigSrc

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

type CloudflareTunnelStatus = shared.CloudflareTunnelStatus

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

type Error = apierror.Error

type ErrorData = shared.ErrorData

type ErrorDataSource = shared.ErrorDataSource

type KVService struct {
	Options    []option.RequestOption
	Namespaces *NamespaceService
}

type Key struct {
	// A key's name. The name may be at most 512 bytes. All printable, non-whitespace
	// characters are valid. Use percent-encoding to define key names as part of a URL.
	Name string `json:"name,required"`
	// The time, measured in number of seconds since the UNIX epoch, at which the key
	// will expire. This property is omitted for keys that will not expire.
	Expiration float64 `json:"expiration"`
	// Arbitrary JSON that is associated with a key.
	Metadata interface{} `json:"metadata"`
	JSON     keyJSON     `json:"-"`
}

type Member = shared.Member

type MemberPoliciesAccess = shared.MemberPoliciesAccess

type MemberPoliciesPermissionGroup = shared.MemberPoliciesPermissionGroup

type MemberPoliciesPermissionGroupsMeta = shared.MemberPoliciesPermissionGroupsMeta

type MemberPoliciesResourceGroup = shared.MemberPoliciesResourceGroup

type MemberPoliciesResourceGroupsMeta = shared.MemberPoliciesResourceGroupsMeta

type MemberPoliciesResourceGroupsScope = shared.MemberPoliciesResourceGroupsScope

type MemberPoliciesResourceGroupsScopeObject = shared.MemberPoliciesResourceGroupsScopeObject

type MemberPolicy = shared.MemberPolicy

type MemberStatus = shared.MemberStatus

type MemberUser = shared.MemberUser

type Namespace struct {
	// Namespace identifier tag.
	ID string `json:"id,required"`
	// A human-readable string name for a Namespace.
	Title string `json:"title,required"`
	// True if keys written on the URL will be URL-decoded before storing. For example,
	// if set to "true", a key written on the URL as "%3F" will be stored as "?".
	SupportsURLEncoding bool          `json:"supports_url_encoding"`
	JSON                namespaceJSON `json:"-"`
}

type NamespaceBulkDeleteParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
	Body      []string            `json:"body,required"`
}

type NamespaceBulkDeleteResponse struct {
	// Number of keys successfully updated.
	SuccessfulKeyCount float64 `json:"successful_key_count"`
	// Name of the keys that failed to be fully updated. They should be retried.
	UnsuccessfulKeys []string                        `json:"unsuccessful_keys"`
	JSON             namespaceBulkDeleteResponseJSON `json:"-"`
}

type NamespaceBulkDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful.
	Success NamespaceBulkDeleteResponseEnvelopeSuccess `json:"success,required"`
	Result  NamespaceBulkDeleteResponse                `json:"result,nullable"`
	JSON    namespaceBulkDeleteResponseEnvelopeJSON    `json:"-"`
}

type NamespaceBulkDeleteResponseEnvelopeSuccess bool

type NamespaceBulkGetParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
	// Array of keys to retrieve (maximum of 100).
	Keys param.Field[[]string] `json:"keys,required"`
	// Whether to parse JSON values in the response.
	Type param.Field[NamespaceBulkGetParamsType] `json:"type"`
	// Whether to include metadata in the response.
	WithMetadata param.Field[bool] `json:"withMetadata"`
}

type NamespaceBulkGetParamsType string

type NamespaceBulkGetResponse struct {
	// This field can have the runtime type of
	// [map[string]NamespaceBulkGetResponseWorkersKVBulkGetResultValuesUnion],
	// [map[string]NamespaceBulkGetResponseWorkersKVBulkGetResultWithMetadataValue].
	Values interface{}                  `json:"values"`
	JSON   namespaceBulkGetResponseJSON `json:"-"`
	// contains filtered or unexported fields
}

type NamespaceBulkGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful.
	Success NamespaceBulkGetResponseEnvelopeSuccess `json:"success,required"`
	Result  NamespaceBulkGetResponse                `json:"result,nullable"`
	JSON    namespaceBulkGetResponseEnvelopeJSON    `json:"-"`
}

type NamespaceBulkGetResponseEnvelopeSuccess bool

type NamespaceBulkGetResponseUnion interface {
	// contains filtered or unexported methods
}

type NamespaceBulkGetResponseWorkersKVBulkGetResult struct {
	// Requested keys are paired with their values in an object.
	Values map[string]NamespaceBulkGetResponseWorkersKVBulkGetResultValuesUnion `json:"values"`
	JSON   namespaceBulkGetResponseWorkersKVBulkGetResultJSON                   `json:"-"`
}

type NamespaceBulkGetResponseWorkersKVBulkGetResultValuesMap map[string]interface{}

type NamespaceBulkGetResponseWorkersKVBulkGetResultValuesUnion interface {
	ImplementsNamespaceBulkGetResponseWorkersKVBulkGetResultValuesUnion()
}

type NamespaceBulkGetResponseWorkersKVBulkGetResultWithMetadata struct {
	// Requested keys are paired with their values and metadata in an object.
	Values map[string]NamespaceBulkGetResponseWorkersKVBulkGetResultWithMetadataValue `json:"values"`
	JSON   namespaceBulkGetResponseWorkersKVBulkGetResultWithMetadataJSON             `json:"-"`
}

type NamespaceBulkGetResponseWorkersKVBulkGetResultWithMetadataValue struct {
	// The metadata associated with the key.
	Metadata interface{} `json:"metadata,required"`
	// The value associated with the key.
	Value interface{} `json:"value,required"`
	// Expires the key at a certain time, measured in number of seconds since the UNIX
	// epoch.
	Expiration float64                                                             `json:"expiration"`
	JSON       namespaceBulkGetResponseWorkersKVBulkGetResultWithMetadataValueJSON `json:"-"`
}

type NamespaceBulkUpdateParams struct {
	// Identifier.
	AccountID param.Field[string]             `path:"account_id,required"`
	Body      []NamespaceBulkUpdateParamsBody `json:"body,required"`
}

type NamespaceBulkUpdateParamsBody struct {
	// A key's name. The name may be at most 512 bytes. All printable, non-whitespace
	// characters are valid.
	Key param.Field[string] `json:"key,required"`
	// A UTF-8 encoded string to be stored, up to 25 MiB in length.
	Value param.Field[string] `json:"value,required"`
	// Indicates whether or not the server should base64 decode the value before
	// storing it. Useful for writing values that wouldn't otherwise be valid JSON
	// strings, such as images.
	Base64 param.Field[bool] `json:"base64"`
	// Expires the key at a certain time, measured in number of seconds since the UNIX
	// epoch.
	Expiration param.Field[float64] `json:"expiration"`
	// Expires the key after a number of seconds. Must be at least 60.
	ExpirationTTL param.Field[float64] `json:"expiration_ttl"`
	// Arbitrary JSON that is associated with a key.
	Metadata param.Field[interface{}] `json:"metadata"`
}

type NamespaceBulkUpdateResponse struct {
	// Number of keys successfully updated.
	SuccessfulKeyCount float64 `json:"successful_key_count"`
	// Name of the keys that failed to be fully updated. They should be retried.
	UnsuccessfulKeys []string                        `json:"unsuccessful_keys"`
	JSON             namespaceBulkUpdateResponseJSON `json:"-"`
}

type NamespaceBulkUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful.
	Success NamespaceBulkUpdateResponseEnvelopeSuccess `json:"success,required"`
	Result  NamespaceBulkUpdateResponse                `json:"result,nullable"`
	JSON    namespaceBulkUpdateResponseEnvelopeJSON    `json:"-"`
}

type NamespaceBulkUpdateResponseEnvelopeSuccess bool

type NamespaceDeleteParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
}

type NamespaceDeleteResponse struct {
	JSON namespaceDeleteResponseJSON `json:"-"`
}

type NamespaceDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful.
	Success NamespaceDeleteResponseEnvelopeSuccess `json:"success,required"`
	Result  NamespaceDeleteResponse                `json:"result,nullable"`
	JSON    namespaceDeleteResponseEnvelopeJSON    `json:"-"`
}

type NamespaceDeleteResponseEnvelopeSuccess bool

type NamespaceGetParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
}

type NamespaceGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful.
	Success NamespaceGetResponseEnvelopeSuccess `json:"success,required"`
	Result  Namespace                           `json:"result"`
	JSON    namespaceGetResponseEnvelopeJSON    `json:"-"`
}

type NamespaceGetResponseEnvelopeSuccess bool

type NamespaceKeyBulkDeleteParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
	Body      []string            `json:"body,required"`
}

type NamespaceKeyBulkDeleteResponse struct {
	// Number of keys successfully updated.
	SuccessfulKeyCount float64 `json:"successful_key_count"`
	// Name of the keys that failed to be fully updated. They should be retried.
	UnsuccessfulKeys []string                           `json:"unsuccessful_keys"`
	JSON             namespaceKeyBulkDeleteResponseJSON `json:"-"`
}

type NamespaceKeyBulkDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful.
	Success NamespaceKeyBulkDeleteResponseEnvelopeSuccess `json:"success,required"`
	Result  NamespaceKeyBulkDeleteResponse                `json:"result,nullable"`
	JSON    namespaceKeyBulkDeleteResponseEnvelopeJSON    `json:"-"`
}

type NamespaceKeyBulkDeleteResponseEnvelopeSuccess bool

type NamespaceKeyBulkGetParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
	// Array of keys to retrieve (maximum of 100).
	Keys param.Field[[]string] `json:"keys,required"`
	// Whether to parse JSON values in the response.
	Type param.Field[NamespaceKeyBulkGetParamsType] `json:"type"`
	// Whether to include metadata in the response.
	WithMetadata param.Field[bool] `json:"withMetadata"`
}

type NamespaceKeyBulkGetParamsType string

type NamespaceKeyBulkGetResponse struct {
	// This field can have the runtime type of
	// [map[string]NamespaceKeyBulkGetResponseWorkersKVBulkGetResultValuesUnion],
	// [map[string]NamespaceKeyBulkGetResponseWorkersKVBulkGetResultWithMetadataValue].
	Values interface{}                     `json:"values"`
	JSON   namespaceKeyBulkGetResponseJSON `json:"-"`
	// contains filtered or unexported fields
}

type NamespaceKeyBulkGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful.
	Success NamespaceKeyBulkGetResponseEnvelopeSuccess `json:"success,required"`
	Result  NamespaceKeyBulkGetResponse                `json:"result,nullable"`
	JSON    namespaceKeyBulkGetResponseEnvelopeJSON    `json:"-"`
}

type NamespaceKeyBulkGetResponseEnvelopeSuccess bool

type NamespaceKeyBulkGetResponseUnion interface {
	// contains filtered or unexported methods
}

type NamespaceKeyBulkGetResponseWorkersKVBulkGetResult struct {
	// Requested keys are paired with their values in an object.
	Values map[string]NamespaceKeyBulkGetResponseWorkersKVBulkGetResultValuesUnion `json:"values"`
	JSON   namespaceKeyBulkGetResponseWorkersKVBulkGetResultJSON                   `json:"-"`
}

type NamespaceKeyBulkGetResponseWorkersKVBulkGetResultValuesMap map[string]interface{}

type NamespaceKeyBulkGetResponseWorkersKVBulkGetResultValuesUnion interface {
	ImplementsNamespaceKeyBulkGetResponseWorkersKVBulkGetResultValuesUnion()
}

type NamespaceKeyBulkGetResponseWorkersKVBulkGetResultWithMetadata struct {
	// Requested keys are paired with their values and metadata in an object.
	Values map[string]NamespaceKeyBulkGetResponseWorkersKVBulkGetResultWithMetadataValue `json:"values"`
	JSON   namespaceKeyBulkGetResponseWorkersKVBulkGetResultWithMetadataJSON             `json:"-"`
}

type NamespaceKeyBulkGetResponseWorkersKVBulkGetResultWithMetadataValue struct {
	// The metadata associated with the key.
	Metadata interface{} `json:"metadata,required"`
	// The value associated with the key.
	Value interface{} `json:"value,required"`
	// Expires the key at a certain time, measured in number of seconds since the UNIX
	// epoch.
	Expiration float64                                                                `json:"expiration"`
	JSON       namespaceKeyBulkGetResponseWorkersKVBulkGetResultWithMetadataValueJSON `json:"-"`
}

type NamespaceKeyBulkUpdateParams struct {
	// Identifier.
	AccountID param.Field[string]                `path:"account_id,required"`
	Body      []NamespaceKeyBulkUpdateParamsBody `json:"body,required"`
}

type NamespaceKeyBulkUpdateParamsBody struct {
	// A key's name. The name may be at most 512 bytes. All printable, non-whitespace
	// characters are valid.
	Key param.Field[string] `json:"key,required"`
	// A UTF-8 encoded string to be stored, up to 25 MiB in length.
	Value param.Field[string] `json:"value,required"`
	// Indicates whether or not the server should base64 decode the value before
	// storing it. Useful for writing values that wouldn't otherwise be valid JSON
	// strings, such as images.
	Base64 param.Field[bool] `json:"base64"`
	// Expires the key at a certain time, measured in number of seconds since the UNIX
	// epoch.
	Expiration param.Field[float64] `json:"expiration"`
	// Expires the key after a number of seconds. Must be at least 60.
	ExpirationTTL param.Field[float64] `json:"expiration_ttl"`
	// Arbitrary JSON that is associated with a key.
	Metadata param.Field[interface{}] `json:"metadata"`
}

type NamespaceKeyBulkUpdateResponse struct {
	// Number of keys successfully updated.
	SuccessfulKeyCount float64 `json:"successful_key_count"`
	// Name of the keys that failed to be fully updated. They should be retried.
	UnsuccessfulKeys []string                           `json:"unsuccessful_keys"`
	JSON             namespaceKeyBulkUpdateResponseJSON `json:"-"`
}

type NamespaceKeyBulkUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful.
	Success NamespaceKeyBulkUpdateResponseEnvelopeSuccess `json:"success,required"`
	Result  NamespaceKeyBulkUpdateResponse                `json:"result,nullable"`
	JSON    namespaceKeyBulkUpdateResponseEnvelopeJSON    `json:"-"`
}

type NamespaceKeyBulkUpdateResponseEnvelopeSuccess bool

type NamespaceKeyListParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
	// Opaque token indicating the position from which to continue when requesting the
	// next set of records if the amount of list results was limited by the limit
	// parameter. A valid value for the cursor can be obtained from the `cursors`
	// object in the `result_info` structure.
	Cursor param.Field[string] `query:"cursor"`
	// Limits the number of keys returned in the response. The cursor attribute may be
	// used to iterate over the next batch of keys if there are more than the limit.
	Limit param.Field[float64] `query:"limit"`
	// Filters returned keys by a name prefix. Exact matches and any key names that
	// begin with the prefix will be returned.
	Prefix param.Field[string] `query:"prefix"`
}

type NamespaceKeyService struct {
	Options []option.RequestOption
}

type NamespaceListParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
	// Direction to order namespaces.
	Direction param.Field[NamespaceListParamsDirection] `query:"direction"`
	// Field to order results by.
	Order param.Field[NamespaceListParamsOrder] `query:"order"`
	// Page number of paginated results.
	Page param.Field[float64] `query:"page"`
	// Maximum number of results per page.
	PerPage param.Field[float64] `query:"per_page"`
}

type NamespaceListParamsDirection string

type NamespaceListParamsOrder string

type NamespaceMetadataGetParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
}

type NamespaceMetadataGetResponse = interface{}

type NamespaceMetadataGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful.
	Success NamespaceMetadataGetResponseEnvelopeSuccess `json:"success,required"`
	// Arbitrary JSON that is associated with a key.
	Result NamespaceMetadataGetResponse             `json:"result"`
	JSON   namespaceMetadataGetResponseEnvelopeJSON `json:"-"`
}

type NamespaceMetadataGetResponseEnvelopeSuccess bool

type NamespaceMetadataService struct {
	Options []option.RequestOption
}

type NamespaceNewParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
	// A human-readable string name for a Namespace.
	Title param.Field[string] `json:"title,required"`
}

type NamespaceNewResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful.
	Success NamespaceNewResponseEnvelopeSuccess `json:"success,required"`
	Result  Namespace                           `json:"result"`
	JSON    namespaceNewResponseEnvelopeJSON    `json:"-"`
}

type NamespaceNewResponseEnvelopeSuccess bool

type NamespaceService struct {
	Options  []option.RequestOption
	Keys     *NamespaceKeyService
	Metadata *NamespaceMetadataService
	Values   *NamespaceValueService
}

type NamespaceUpdateParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
	// A human-readable string name for a Namespace.
	Title param.Field[string] `json:"title,required"`
}

type NamespaceUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   Namespace             `json:"result,required"`
	// Whether the API call was successful.
	Success NamespaceUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    namespaceUpdateResponseEnvelopeJSON    `json:"-"`
}

type NamespaceUpdateResponseEnvelopeSuccess bool

type NamespaceValueDeleteParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
}

type NamespaceValueDeleteResponse struct {
	JSON namespaceValueDeleteResponseJSON `json:"-"`
}

type NamespaceValueDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful.
	Success NamespaceValueDeleteResponseEnvelopeSuccess `json:"success,required"`
	Result  NamespaceValueDeleteResponse                `json:"result,nullable"`
	JSON    namespaceValueDeleteResponseEnvelopeJSON    `json:"-"`
}

type NamespaceValueDeleteResponseEnvelopeSuccess bool

type NamespaceValueGetParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
}

type NamespaceValueService struct {
	Options []option.RequestOption
}

type NamespaceValueUpdateParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
	// A byte sequence to be stored, up to 25 MiB in length.
	Value param.Field[string] `json:"value,required"`
	// Expires the key at a certain time, measured in number of seconds since the UNIX
	// epoch.
	Expiration param.Field[float64] `query:"expiration"`
	// Expires the key after a number of seconds. Must be at least 60.
	ExpirationTTL param.Field[float64] `query:"expiration_ttl"`
	// Associates arbitrary JSON data with a key/value pair.
	Metadata param.Field[interface{}] `json:"metadata"`
}

type NamespaceValueUpdateResponse struct {
	JSON namespaceValueUpdateResponseJSON `json:"-"`
}

type NamespaceValueUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful.
	Success NamespaceValueUpdateResponseEnvelopeSuccess `json:"success,required"`
	Result  NamespaceValueUpdateResponse                `json:"result,nullable"`
	JSON    namespaceValueUpdateResponseEnvelopeJSON    `json:"-"`
}

type NamespaceValueUpdateResponseEnvelopeSuccess bool

type Permission = shared.Permission

type PermissionGrant = shared.PermissionGrant

type PermissionGrantParam = shared.PermissionGrantParam

type RatePlan = shared.RatePlan

type RatePlanID = shared.RatePlanID

type RatePlanParam = shared.RatePlanParam

type ResponseInfo = shared.ResponseInfo

type ResponseInfoSource = shared.ResponseInfoSource

type Role = shared.Role

type RoleParam = shared.RoleParam

type RolePermissions = shared.RolePermissions

type RolePermissionsParam = shared.RolePermissionsParam

type SortDirection = shared.SortDirection

type Subscription = shared.Subscription

type SubscriptionFrequency = shared.SubscriptionFrequency

type SubscriptionParam = shared.SubscriptionParam

type SubscriptionState = shared.SubscriptionState

type Token = shared.Token

type TokenCondition = shared.TokenCondition

type TokenConditionCIDRList = shared.TokenConditionCIDRList

type TokenConditionCIDRListParam = shared.TokenConditionCIDRListParam

type TokenConditionParam = shared.TokenConditionParam

type TokenConditionRequestIP = shared.TokenConditionRequestIP

type TokenConditionRequestIPParam = shared.TokenConditionRequestIPParam

type TokenParam = shared.TokenParam

type TokenPolicy = shared.TokenPolicy

type TokenPolicyEffect = shared.TokenPolicyEffect

type TokenPolicyParam = shared.TokenPolicyParam

type TokenPolicyPermissionGroup = shared.TokenPolicyPermissionGroup

type TokenPolicyPermissionGroupParam = shared.TokenPolicyPermissionGroupParam

type TokenPolicyPermissionGroupsMeta = shared.TokenPolicyPermissionGroupsMeta

type TokenPolicyPermissionGroupsMetaParam = shared.TokenPolicyPermissionGroupsMetaParam

type TokenPolicyResourcesIAMResourcesTypeObjectNested = shared.TokenPolicyResourcesIAMResourcesTypeObjectNested

type TokenPolicyResourcesIAMResourcesTypeObjectNestedParam = shared.TokenPolicyResourcesIAMResourcesTypeObjectNestedParam

type TokenPolicyResourcesIAMResourcesTypeObjectString = shared.TokenPolicyResourcesIAMResourcesTypeObjectString

type TokenPolicyResourcesIAMResourcesTypeObjectStringParam = shared.TokenPolicyResourcesIAMResourcesTypeObjectStringParam

type TokenPolicyResourcesUnion = shared.TokenPolicyResourcesUnion

type TokenPolicyResourcesUnionParam = shared.TokenPolicyResourcesUnionParam

type TokenStatus = shared.TokenStatus

type TokenValue = shared.TokenValue