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 CloudflareTunnel = shared.CloudflareTunnel

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

type Error = apierror.Error

type ErrorData = shared.ErrorData

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 MemberParam = shared.MemberParam

type MemberRole = shared.MemberRole

type MemberRoleParam = shared.MemberRoleParam

type MemberRolesPermissions = shared.MemberRolesPermissions

type MemberRolesPermissionsParam = shared.MemberRolesPermissionsParam

type MemberUser = shared.MemberUser

type MemberUserParam = shared.MemberUserParam

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 NamespaceBulkDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo            `json:"errors,required"`
	Messages []shared.ResponseInfo            `json:"messages,required"`
	Result   NamespaceBulkDeleteResponseUnion `json:"result,required"`
	// Whether the API call was successful
	Success NamespaceBulkDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    namespaceBulkDeleteResponseEnvelopeJSON    `json:"-"`
}

type NamespaceBulkDeleteResponseEnvelopeSuccess bool

type NamespaceBulkDeleteResponseUnion interface {
	ImplementsKVNamespaceBulkDeleteResponseUnion()
}

type NamespaceBulkService struct {
	Options []option.RequestOption
}

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

type NamespaceBulkUpdateParamsBody struct {
	// 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"`
	// The time, measured in number of seconds since the UNIX epoch, at which the key
	// should expire.
	Expiration param.Field[float64] `json:"expiration"`
	// The number of seconds for which the key should be visible before it expires. At
	// least 60.
	ExpirationTTL param.Field[float64] `json:"expiration_ttl"`
	// 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"`
	// Arbitrary JSON that is associated with a key.
	Metadata param.Field[interface{}] `json:"metadata"`
	// A UTF-8 encoded string to be stored, up to 25 MiB in length.
	Value param.Field[string] `json:"value"`
}

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

type NamespaceBulkUpdateResponseEnvelopeSuccess bool

type NamespaceBulkUpdateResponseUnion interface {
	ImplementsKVNamespaceBulkUpdateResponseUnion()
}

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

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

type NamespaceDeleteResponseEnvelopeSuccess bool

type NamespaceDeleteResponseUnion interface {
	ImplementsKVNamespaceDeleteResponseUnion()
}

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"`
	// The number of keys to return. 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"`
	// A string prefix used to filter down which keys will be returned. 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"`
	// Arbitrary JSON that is associated with a key.
	Result NamespaceMetadataGetResponse `json:"result,required"`
	// Whether the API call was successful
	Success NamespaceMetadataGetResponseEnvelopeSuccess `json:"success,required"`
	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"`
	Result   Namespace             `json:"result,required"`
	// Whether the API call was successful
	Success NamespaceNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    namespaceNewResponseEnvelopeJSON    `json:"-"`
}

type NamespaceNewResponseEnvelopeSuccess bool

type NamespaceService struct {
	Options  []option.RequestOption
	Bulk     *NamespaceBulkService
	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   NamespaceUpdateResponseUnion `json:"result,required"`
	// Whether the API call was successful
	Success NamespaceUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    namespaceUpdateResponseEnvelopeJSON    `json:"-"`
}

type NamespaceUpdateResponseEnvelopeSuccess bool

type NamespaceUpdateResponseUnion interface {
	ImplementsKVNamespaceUpdateResponseUnion()
}

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

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

type NamespaceValueDeleteResponseEnvelopeSuccess bool

type NamespaceValueDeleteResponseUnion interface {
	ImplementsKVNamespaceValueDeleteResponseUnion()
}

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"`
	// Arbitrary JSON to be associated with a key/value pair.
	Metadata param.Field[string] `json:"metadata,required"`
	// A byte sequence to be stored, up to 25 MiB in length.
	Value param.Field[string] `json:"value,required"`
}

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

type NamespaceValueUpdateResponseEnvelopeSuccess bool

type NamespaceValueUpdateResponseUnion interface {
	ImplementsKVNamespaceValueUpdateResponseUnion()
}

type Permission = shared.Permission

type PermissionGrant = shared.PermissionGrant

type PermissionGrantParam = shared.PermissionGrantParam

type ResponseInfo = shared.ResponseInfo

type Role = shared.Role