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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                   `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccountType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectAccountJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccountRuleset 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                          `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccountRulesetType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectAccountRulesetJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectAccountRulesetType string

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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                       `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectGatewayRuleType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectGatewayRuleJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectGatewayRuleType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectHealthcheck 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                       `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectHealthcheckType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                  `json:"zone_id" api:"required"`
	JSON   accountTagGetResponseResourceTaggingTaggedResourceObjectHealthcheckJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectHealthcheckType 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                 `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectImageType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectImageJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectImageType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectInfrastructureTarget 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                                `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectInfrastructureTargetType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectInfrastructureTargetJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectInfrastructureTargetType 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                       `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectKVNamespaceType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectKVNamespaceJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectKVNamespaceType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectLoadBalancer 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                        `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectLoadBalancerType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                   `json:"zone_id" api:"required"`
	JSON   accountTagGetResponseResourceTaggingTaggedResourceObjectLoadBalancerJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectLoadBalancerMonitor 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                               `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectLoadBalancerMonitorType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectLoadBalancerMonitorJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectLoadBalancerMonitorType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectLoadBalancerPool 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                            `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectLoadBalancerPoolType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectLoadBalancerPoolJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectLoadBalancerPoolType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectLoadBalancerType 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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 AccountTagGetResponseResourceTaggingTaggedResourceObjectPagesProject 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                        `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectPagesProjectType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectPagesProjectJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectPagesProjectType 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                       `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectStreamVideoType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectStreamVideoJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectStreamVideoType string

type AccountTagGetResponseResourceTaggingTaggedResourceObjectVectorizeIndex 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                          `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectVectorizeIndexType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectVectorizeIndexJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectVectorizeIndexType 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                  `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectWorkerType `json:"type" api:"required"`
	JSON accountTagGetResponseResourceTaggingTaggedResourceObjectWorkerJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectWorkerRoute 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                       `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectWorkerRouteType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                  `json:"zone_id" api:"required"`
	JSON   accountTagGetResponseResourceTaggingTaggedResourceObjectWorkerRouteJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectWorkerRouteType string

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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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 AccountTagGetResponseResourceTaggingTaggedResourceObjectZoneRuleset 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                       `json:"tags" api:"required"`
	Type AccountTagGetResponseResourceTaggingTaggedResourceObjectZoneRulesetType `json:"type" api:"required"`
	// Zone ID is required only for zone-level resources
	ZoneID string                                                                  `json:"zone_id" api:"required"`
	JSON   accountTagGetResponseResourceTaggingTaggedResourceObjectZoneRulesetJSON `json:"-"`
}

type AccountTagGetResponseResourceTaggingTaggedResourceObjectZoneRulesetType string

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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                      `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccountType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectAccountJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccountRuleset 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only tags.
	Tags map[string]string                                                             `json:"tags" api:"required"`
	Type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccountRulesetType `json:"type" api:"required"`
	JSON accountTagUpdateResponseResourceTaggingTaggedResourceObjectAccountRulesetJSON `json:"-"`
}

type AccountTagUpdateResponseResourceTaggingTaggedResourceObjectAccountRulesetType string

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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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. Keys may contain at most 256 characters.
	// Values may contain at most 1024 characters and may be empty for key-only 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:"-"`
}