resource_tagging

type ASN = shared.ASN

type ASNParam = shared.ASNParam

type AccountTagDeleteParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id" api:"required"`
	IfMatch   param.Field[string] `header:"If-Match"`
}

type AccountTagGetParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id" api:"required"`
	// The ID of the resource to retrieve tags for.
	ResourceID param.Field[string] `query:"resource_id" api:"required"`
	// The type of the resource.
	ResourceType param.Field[AccountTagGetParamsResourceType] `query:"resource_type" api:"required"`
	// Worker identifier. Required for worker_version resources.
	WorkerID param.Field[string] `query:"worker_id"`
}

type AccountTagGetParamsResourceType string

type AccountTagGetResponse struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// This field can have the runtime type of [map[string]string].
	Tags interface{}               `json:"tags" api:"required"`
	Type AccountTagGetResponseType `json:"type" api:"required"`
	// Access application ID is required only for access_application_policy resources
	AccessApplicationID string `json:"access_application_id" format:"uuid"`
	// Worker ID is required only for worker_version resources
	WorkerID string `json:"worker_id"`
	// Zone ID is required only for zone-level resources
	ZoneID string                    `json:"zone_id"`
	JSON   accountTagGetResponseJSON `json:"-"`
	// contains filtered or unexported fields
}

type AccountTagGetResponseEnvelope struct {
	Errors   []AccountTagGetResponseEnvelopeErrors   `json:"errors" api:"required"`
	Messages []AccountTagGetResponseEnvelopeMessages `json:"messages" api:"required"`
	// Whether the API call was successful.
	Success AccountTagGetResponseEnvelopeSuccess `json:"success" api:"required"`
	// Response for access_application resources
	Result AccountTagGetResponse             `json:"result"`
	JSON   accountTagGetResponseEnvelopeJSON `json:"-"`
}

type AccountTagGetResponseEnvelopeErrors struct {
	Code             int64                                     `json:"code" api:"required"`
	Message          string                                    `json:"message" api:"required"`
	DocumentationURL string                                    `json:"documentation_url"`
	Source           AccountTagGetResponseEnvelopeErrorsSource `json:"source"`
	JSON             accountTagGetResponseEnvelopeErrorsJSON   `json:"-"`
}

type AccountTagGetResponseEnvelopeErrorsSource struct {
	Pointer string                                        `json:"pointer"`
	JSON    accountTagGetResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type AccountTagGetResponseEnvelopeMessages struct {
	Code             int64                                       `json:"code" api:"required"`
	Message          string                                      `json:"message" api:"required"`
	DocumentationURL string                                      `json:"documentation_url"`
	Source           AccountTagGetResponseEnvelopeMessagesSource `json:"source"`
	JSON             accountTagGetResponseEnvelopeMessagesJSON   `json:"-"`
}

type AccountTagGetResponseEnvelopeMessagesSource struct {
	Pointer string                                          `json:"pointer"`
	JSON    accountTagGetResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type AccountTagGetResponseEnvelopeSuccess bool

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAIGateway struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                     `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectAIGatewayType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectAIGatewayJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAIGatewayType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAPIGatewayOperation struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                               `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectAPIGatewayOperationType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                          `json:"zone_id" api:"required"`
	JSON   accountTagGetResponseResourceTaggingTaggedResourceObjectAPIGatewayOperationJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAPIGatewayOperationType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccessApplication struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                             `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccessApplicationType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectAccessApplicationJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccessApplicationPolicy struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// Access application ID is required only for access_application_policy resources
	AccessApplicationID string `json:"access_application_id" api:"required" format:"uuid"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                                   `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccessApplicationPolicyType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                              `json:"zone_id" api:"required"`
	JSON   accountTagGetResponseResourceTaggingTaggedResourceObjectAccessApplicationPolicyJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccessApplicationPolicyType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccessApplicationType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccessGroup struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                       `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccessGroupType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectAccessGroupJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccessGroupType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccount struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                   `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccountType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectAccountJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccountType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAlertingPolicy struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                          `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectAlertingPolicyType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectAlertingPolicyJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAlertingPolicyType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAlertingWebhook struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                           `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectAlertingWebhookType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectAlertingWebhookJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAlertingWebhookType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectCloudflaredTunnel struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                             `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectCloudflaredTunnelType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectCloudflaredTunnelJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectCloudflaredTunnelType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectCustomCertificate struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                             `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectCustomCertificateType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                        `json:"zone_id" api:"required"`
	JSON   accountTagGetResponseResourceTaggingTaggedResourceObjectCustomCertificateJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectCustomCertificateType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectCustomHostname struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                          `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectCustomHostnameType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                     `json:"zone_id" api:"required"`
	JSON   accountTagGetResponseResourceTaggingTaggedResourceObjectCustomHostnameJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectCustomHostnameType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectD1Database struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                      `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectD1DatabaseType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectD1DatabaseJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectD1DatabaseType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectDNSRecord struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                     `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectDNSRecordType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                `json:"zone_id" api:"required"`
	JSON   accountTagGetResponseResourceTaggingTaggedResourceObjectDNSRecordJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectDNSRecordType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectDurableObjectNamespace struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                                  `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectDurableObjectNamespaceType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectDurableObjectNamespaceJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectDurableObjectNamespaceType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectGatewayList struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                       `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectGatewayListType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectGatewayListJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectGatewayListType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectGatewayRule struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                       `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectGatewayRuleType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectGatewayRuleJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectGatewayRuleType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectImage struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                 `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectImageType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectImageJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectImageType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectKVNamespace struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                       `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectKVNamespaceType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectKVNamespaceJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectKVNamespaceType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectManagedClientCertificate struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                                    `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectManagedClientCertificateType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                               `json:"zone_id" api:"required"`
	JSON   accountTagGetResponseResourceTaggingTaggedResourceObjectManagedClientCertificateJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectManagedClientCertificateType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectQueue struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                 `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectQueueType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectQueueJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectQueueType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectR2Bucket struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                    `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectR2BucketType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectR2BucketJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectR2BucketType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectResourceShare struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                         `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectResourceShareType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectResourceShareJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectResourceShareType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectStreamLiveInput struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                           `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectStreamLiveInputType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectStreamLiveInputJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectStreamLiveInputType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectStreamVideo struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                       `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectStreamVideoType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectStreamVideoJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectStreamVideoType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectWorker struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                  `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectWorkerType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectWorkerJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectWorkerType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectWorkerVersion struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                         `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectWorkerVersionType `json:"type" api:"required"`
	// Worker ID is required only for worker_version resources
	WorkerID string                                                                    `json:"worker_id" api:"required"`
	JSON     accountTagGetResponseResourceTaggingTaggedResourceObjectWorkerVersionJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectWorkerVersionType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectZone struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectZoneType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                           `json:"zone_id" api:"required"`
	JSON   accountTagGetResponseResourceTaggingTaggedResourceObjectZoneJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectZoneType string

type AccountTagGetResponseType string

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

type AccountTagService struct {
	Options []option.RequestOption
}

type AccountTagUpdateParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id" api:"required"`
	// Request body schema for setting tags on account-level resources.
	Body    AccountTagUpdateParamsBodyUnion `json:"body" api:"required"`
	IfMatch param.Field[string]             `header:"If-Match"`
}

type AccountTagUpdateParamsBody struct {
	// Identifies the unique resource.
	ResourceID param.Field[string] `json:"resource_id" api:"required"`
	// Enum for base account-level resource types (those with no extra required
	// fields).
	ResourceType param.Field[AccountTagUpdateParamsBodyResourceType] `json:"resource_type" api:"required"`
	Tags         param.Field[interface{}]                            `json:"tags"`
	// Worker ID is required only for worker_version resources
	WorkerID param.Field[string] `json:"worker_id"`
}

type AccountTagUpdateParamsBodyResourceTaggingSetTagsRequestAccountLevelBase struct {
	// Identifies the unique resource.
	ResourceID param.Field[string] `json:"resource_id" api:"required"`
	// Enum for base account-level resource types (those with no extra required
	// fields).
	ResourceType param.Field[AccountTagUpdateParamsBodyResourceTaggingSetTagsRequestAccountLevelBaseResourceType] `json:"resource_type" api:"required"`
	// Contains key-value pairs of tags.
	Tags param.Field[map[string]string] `json:"tags"`
}

type AccountTagUpdateParamsBodyResourceTaggingSetTagsRequestAccountLevelBaseResourceType string

type AccountTagUpdateParamsBodyResourceTaggingSetTagsRequestAccountLevelWorkerVersion struct {
	// Identifies the unique resource.
	ResourceID param.Field[string] `json:"resource_id" api:"required"`
	// Enum for base account-level resource types (those with no extra required
	// fields).
	ResourceType param.Field[AccountTagUpdateParamsBodyResourceTaggingSetTagsRequestAccountLevelWorkerVersionResourceType] `json:"resource_type" api:"required"`
	// Worker ID is required only for worker_version resources
	WorkerID param.Field[string] `json:"worker_id" api:"required"`
	// Contains key-value pairs of tags.
	Tags param.Field[map[string]string] `json:"tags"`
}

type AccountTagUpdateParamsBodyResourceTaggingSetTagsRequestAccountLevelWorkerVersionResourceType string

type AccountTagUpdateParamsBodyResourceType string

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

type AccountTagUpdateResponse struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// This field can have the runtime type of [map[string]string].
	Tags interface{}                  `json:"tags" api:"required"`
	Type AccountTagUpdateResponseType `json:"type" api:"required"`
	// Access application ID is required only for access_application_policy resources
	AccessApplicationID string `json:"access_application_id" format:"uuid"`
	// Worker ID is required only for worker_version resources
	WorkerID string `json:"worker_id"`
	// Zone ID is required only for zone-level resources
	ZoneID string                       `json:"zone_id"`
	JSON   accountTagUpdateResponseJSON `json:"-"`
	// contains filtered or unexported fields
}

type AccountTagUpdateResponseEnvelope struct {
	Errors   []AccountTagUpdateResponseEnvelopeErrors   `json:"errors" api:"required"`
	Messages []AccountTagUpdateResponseEnvelopeMessages `json:"messages" api:"required"`
	// Whether the API call was successful.
	Success AccountTagUpdateResponseEnvelopeSuccess `json:"success" api:"required"`
	// Response for access_application resources
	Result AccountTagUpdateResponse             `json:"result"`
	JSON   accountTagUpdateResponseEnvelopeJSON `json:"-"`
}

type AccountTagUpdateResponseEnvelopeErrors struct {
	Code             int64                                        `json:"code" api:"required"`
	Message          string                                       `json:"message" api:"required"`
	DocumentationURL string                                       `json:"documentation_url"`
	Source           AccountTagUpdateResponseEnvelopeErrorsSource `json:"source"`
	JSON             accountTagUpdateResponseEnvelopeErrorsJSON   `json:"-"`
}

type AccountTagUpdateResponseEnvelopeErrorsSource struct {
	Pointer string                                           `json:"pointer"`
	JSON    accountTagUpdateResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type AccountTagUpdateResponseEnvelopeMessages struct {
	Code             int64                                          `json:"code" api:"required"`
	Message          string                                         `json:"message" api:"required"`
	DocumentationURL string                                         `json:"documentation_url"`
	Source           AccountTagUpdateResponseEnvelopeMessagesSource `json:"source"`
	JSON             accountTagUpdateResponseEnvelopeMessagesJSON   `json:"-"`
}

type AccountTagUpdateResponseEnvelopeMessagesSource struct {
	Pointer string                                             `json:"pointer"`
	JSON    accountTagUpdateResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type AccountTagUpdateResponseEnvelopeSuccess bool

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAIGateway struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                        `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAIGatewayType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectAIGatewayJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAIGatewayType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAPIGatewayOperation struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                                  `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAPIGatewayOperationType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                             `json:"zone_id" api:"required"`
	JSON   accountTagUpdateResponseResourceTaggingTaggedResourceObjectAPIGatewayOperationJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAPIGatewayOperationType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccessApplication struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                                `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccessApplicationType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectAccessApplicationJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccessApplicationPolicy struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// Access application ID is required only for access_application_policy resources
	AccessApplicationID string `json:"access_application_id" api:"required" format:"uuid"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                                      `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccessApplicationPolicyType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                                 `json:"zone_id" api:"required"`
	JSON   accountTagUpdateResponseResourceTaggingTaggedResourceObjectAccessApplicationPolicyJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccessApplicationPolicyType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccessApplicationType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccessGroup struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                          `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccessGroupType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectAccessGroupJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccessGroupType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccount struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                      `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccountType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectAccountJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccountType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAlertingPolicy struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                             `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAlertingPolicyType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectAlertingPolicyJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAlertingPolicyType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAlertingWebhook struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                              `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAlertingWebhookType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectAlertingWebhookJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAlertingWebhookType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectCloudflaredTunnel struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                                `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectCloudflaredTunnelType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectCloudflaredTunnelJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectCloudflaredTunnelType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectCustomCertificate struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                                `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectCustomCertificateType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                           `json:"zone_id" api:"required"`
	JSON   accountTagUpdateResponseResourceTaggingTaggedResourceObjectCustomCertificateJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectCustomCertificateType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectCustomHostname struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                             `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectCustomHostnameType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                        `json:"zone_id" api:"required"`
	JSON   accountTagUpdateResponseResourceTaggingTaggedResourceObjectCustomHostnameJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectCustomHostnameType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectD1Database struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                         `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectD1DatabaseType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectD1DatabaseJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectD1DatabaseType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectDNSRecord struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                        `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectDNSRecordType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                   `json:"zone_id" api:"required"`
	JSON   accountTagUpdateResponseResourceTaggingTaggedResourceObjectDNSRecordJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectDNSRecordType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectDurableObjectNamespace struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                                     `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectDurableObjectNamespaceType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectDurableObjectNamespaceJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectDurableObjectNamespaceType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectGatewayList struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                          `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectGatewayListType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectGatewayListJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectGatewayListType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectGatewayRule struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                          `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectGatewayRuleType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectGatewayRuleJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectGatewayRuleType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectImage struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                    `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectImageType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectImageJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectImageType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectKVNamespace struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                          `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectKVNamespaceType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectKVNamespaceJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectKVNamespaceType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectManagedClientCertificate struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                                       `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectManagedClientCertificateType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                                  `json:"zone_id" api:"required"`
	JSON   accountTagUpdateResponseResourceTaggingTaggedResourceObjectManagedClientCertificateJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectManagedClientCertificateType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectQueue struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                    `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectQueueType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectQueueJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectQueueType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectR2Bucket struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                       `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectR2BucketType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectR2BucketJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectR2BucketType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectResourceShare struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                            `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectResourceShareType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectResourceShareJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectResourceShareType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectStreamLiveInput struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                              `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectStreamLiveInputType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectStreamLiveInputJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectStreamLiveInputType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectStreamVideo struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                          `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectStreamVideoType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectStreamVideoJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectStreamVideoType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectWorker struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                     `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectWorkerType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectWorkerJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectWorkerType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectWorkerVersion struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                            `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectWorkerVersionType `json:"type" api:"required"`
	// Worker ID is required only for worker_version resources
	WorkerID string                                                                       `json:"worker_id" api:"required"`
	JSON     accountTagUpdateResponseResourceTaggingTaggedResourceObjectWorkerVersionJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectWorkerVersionType string

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectZone struct {
	// Identifies the unique resource.
	ID string `json:"id" api:"required"`
	// ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
	// where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
	// tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
	// should treat ETags as opaque strings and pass them back via the If-Match header
	// on write operations.
	Etag string `json:"etag" api:"required"`
	// Human-readable name of the resource.
	Name string `json:"name" api:"required"`
	// Contains key-value pairs of tags.
	Tags map[string]string                                                   `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectZoneType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                              `json:"zone_id" api:"required"`
	JSON   accountTagUpdateResponseResourceTaggingTaggedResourceObjectZoneJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectZoneType string

type AccountTagUpdateResponseType string

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

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 KeyListParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id" api:"required"`
	// Cursor for pagination.
	Cursor param.Field[string] `query:"cursor"`
}

type KeyService struct {
	Options []option.RequestOption
}

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

type PermissionGrant = shared.PermissionGrant

type PermissionGrantParam = shared.PermissionGrantParam