import { APIResource } from "../../core/resource.js";
import { APIPromise } from "../../core/api-promise.js";
import { RequestOptions } from "../../internal/request-options.js";
export declare class BaseZoneTags extends APIResource {
    static readonly _key: readonly ['resourceTagging', 'zoneTags'];
    /**
     * Creates or updates tags for a specific zone-level resource. Replaces all
     * existing tags for the resource.
     *
     * @example
     * ```ts
     * const zoneTag =
     *   await client.resourceTagging.zoneTags.update({
     *     zone_id: '023e105f4ecef8ad9ca31a8372d0c353',
     *     resource_id: '023e105f4ecef8ad9ca31a8372d0c353',
     *     resource_type: 'zone',
     *   });
     * ```
     */
    update(params: ZoneTagUpdateParams, options?: RequestOptions): APIPromise<ZoneTagUpdateResponse>;
    /**
     * Removes all tags from a specific zone-level resource.
     */
    delete(params: ZoneTagDeleteParams, options?: RequestOptions): APIPromise<void>;
    /**
     * Retrieves tags for a specific zone-level resource.
     */
    get(params: ZoneTagGetParams, options?: RequestOptions): APIPromise<ZoneTagGetResponse>;
}
export declare class ZoneTags extends BaseZoneTags {
}
/**
 * Response for access_application resources
 */
export type ZoneTagUpdateResponse = ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccessApplication | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccessApplicationPolicy | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccessGroup | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccount | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccountRuleset | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectAIGateway | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectAlertingPolicy | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectAlertingWebhook | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectAPIGatewayOperation | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectCloudflaredTunnel | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectCustomCertificate | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectCustomHostname | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectCwsDeployment | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectCwsPolicy | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectCwsPolicySet | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectCwsWorkload | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectD1Database | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectDNSRecord | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectDurableObjectNamespace | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectGatewayList | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectGatewayRule | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectHealthcheck | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectImage | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectInfrastructureTarget | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectKVNamespace | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectLoadBalancer | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectLoadBalancerMonitor | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectLoadBalancerPool | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectManagedClientCertificate | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectPagesProject | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectQueue | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectR2Bucket | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectResourceShare | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectStreamLiveInput | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectStreamVideo | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectVectorizeIndex | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectWorker | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectWorkerRoute | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectWorkerVersion | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectZone | ZoneTagUpdateResponse.ResourceTaggingTaggedResourceObjectZoneRuleset;
export declare namespace ZoneTagUpdateResponse {
    /**
     * Response for access_application resources
     */
    interface ResourceTaggingTaggedResourceObjectAccessApplication {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'access_application';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for access_application_policy resources
     */
    interface ResourceTaggingTaggedResourceObjectAccessApplicationPolicy {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * Access application ID is required only for access_application_policy resources
         */
        access_application_id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'access_application_policy';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for access_group resources
     */
    interface ResourceTaggingTaggedResourceObjectAccessGroup {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'access_group';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for account resources
     */
    interface ResourceTaggingTaggedResourceObjectAccount {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'account';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for account_ruleset resources
     */
    interface ResourceTaggingTaggedResourceObjectAccountRuleset {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'account_ruleset';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for ai_gateway resources
     */
    interface ResourceTaggingTaggedResourceObjectAIGateway {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'ai_gateway';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for alerting_policy resources
     */
    interface ResourceTaggingTaggedResourceObjectAlertingPolicy {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'alerting_policy';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for alerting_webhook resources
     */
    interface ResourceTaggingTaggedResourceObjectAlertingWebhook {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'alerting_webhook';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for api_gateway_operation resources
     */
    interface ResourceTaggingTaggedResourceObjectAPIGatewayOperation {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'api_gateway_operation';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for cloudflared_tunnel resources
     */
    interface ResourceTaggingTaggedResourceObjectCloudflaredTunnel {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'cloudflared_tunnel';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for custom_certificate resources
     */
    interface ResourceTaggingTaggedResourceObjectCustomCertificate {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'custom_certificate';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for custom_hostname resources
     */
    interface ResourceTaggingTaggedResourceObjectCustomHostname {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'custom_hostname';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for cws_deployment resources
     */
    interface ResourceTaggingTaggedResourceObjectCwsDeployment {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'cws_deployment';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for cws_policy resources
     */
    interface ResourceTaggingTaggedResourceObjectCwsPolicy {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'cws_policy';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for cws_policy_set resources
     */
    interface ResourceTaggingTaggedResourceObjectCwsPolicySet {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'cws_policy_set';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for cws_workload resources
     */
    interface ResourceTaggingTaggedResourceObjectCwsWorkload {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'cws_workload';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for d1_database resources
     */
    interface ResourceTaggingTaggedResourceObjectD1Database {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'd1_database';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for dns_record resources
     */
    interface ResourceTaggingTaggedResourceObjectDNSRecord {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'dns_record';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for durable_object_namespace resources
     */
    interface ResourceTaggingTaggedResourceObjectDurableObjectNamespace {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'durable_object_namespace';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for gateway_list resources
     */
    interface ResourceTaggingTaggedResourceObjectGatewayList {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'gateway_list';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for gateway_rule resources
     */
    interface ResourceTaggingTaggedResourceObjectGatewayRule {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'gateway_rule';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for healthcheck resources
     */
    interface ResourceTaggingTaggedResourceObjectHealthcheck {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'healthcheck';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for image resources
     */
    interface ResourceTaggingTaggedResourceObjectImage {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'image';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for infrastructure_target resources
     */
    interface ResourceTaggingTaggedResourceObjectInfrastructureTarget {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'infrastructure_target';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for kv_namespace resources
     */
    interface ResourceTaggingTaggedResourceObjectKVNamespace {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'kv_namespace';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for load_balancer resources
     */
    interface ResourceTaggingTaggedResourceObjectLoadBalancer {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'load_balancer';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for load_balancer_monitor resources
     */
    interface ResourceTaggingTaggedResourceObjectLoadBalancerMonitor {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'load_balancer_monitor';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for load_balancer_pool resources
     */
    interface ResourceTaggingTaggedResourceObjectLoadBalancerPool {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'load_balancer_pool';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for managed_client_certificate resources
     */
    interface ResourceTaggingTaggedResourceObjectManagedClientCertificate {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'managed_client_certificate';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for pages_project resources
     */
    interface ResourceTaggingTaggedResourceObjectPagesProject {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'pages_project';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for queue resources
     */
    interface ResourceTaggingTaggedResourceObjectQueue {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'queue';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for r2_bucket resources
     */
    interface ResourceTaggingTaggedResourceObjectR2Bucket {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'r2_bucket';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for resource_share resources
     */
    interface ResourceTaggingTaggedResourceObjectResourceShare {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'resource_share';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for stream_live_input resources
     */
    interface ResourceTaggingTaggedResourceObjectStreamLiveInput {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'stream_live_input';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for stream_video resources
     */
    interface ResourceTaggingTaggedResourceObjectStreamVideo {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'stream_video';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for vectorize_index resources
     */
    interface ResourceTaggingTaggedResourceObjectVectorizeIndex {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'vectorize_index';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for worker resources
     */
    interface ResourceTaggingTaggedResourceObjectWorker {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'worker';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for worker_route resources
     */
    interface ResourceTaggingTaggedResourceObjectWorkerRoute {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'worker_route';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for worker_version resources
     */
    interface ResourceTaggingTaggedResourceObjectWorkerVersion {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'worker_version';
        /**
         * Worker ID is required only for worker_version resources
         */
        worker_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for zone resources
     */
    interface ResourceTaggingTaggedResourceObjectZone {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'zone';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for zone_ruleset resources
     */
    interface ResourceTaggingTaggedResourceObjectZoneRuleset {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'zone_ruleset';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
}
/**
 * Response for access_application resources
 */
export type ZoneTagGetResponse = ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAccessApplication | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAccessApplicationPolicy | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAccessGroup | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAccount | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAccountRuleset | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAIGateway | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAlertingPolicy | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAlertingWebhook | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAPIGatewayOperation | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCloudflaredTunnel | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCustomCertificate | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCustomHostname | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCwsDeployment | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCwsPolicy | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCwsPolicySet | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCwsWorkload | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectD1Database | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectDNSRecord | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectDurableObjectNamespace | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectGatewayList | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectGatewayRule | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectHealthcheck | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectImage | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectInfrastructureTarget | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectKVNamespace | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectLoadBalancer | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectLoadBalancerMonitor | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectLoadBalancerPool | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectManagedClientCertificate | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectPagesProject | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectQueue | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectR2Bucket | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectResourceShare | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectStreamLiveInput | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectStreamVideo | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectVectorizeIndex | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectWorker | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectWorkerRoute | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectWorkerVersion | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectZone | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectZoneRuleset;
export declare namespace ZoneTagGetResponse {
    /**
     * Response for access_application resources
     */
    interface ResourceTaggingTaggedResourceObjectAccessApplication {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'access_application';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for access_application_policy resources
     */
    interface ResourceTaggingTaggedResourceObjectAccessApplicationPolicy {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * Access application ID is required only for access_application_policy resources
         */
        access_application_id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'access_application_policy';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for access_group resources
     */
    interface ResourceTaggingTaggedResourceObjectAccessGroup {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'access_group';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for account resources
     */
    interface ResourceTaggingTaggedResourceObjectAccount {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'account';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for account_ruleset resources
     */
    interface ResourceTaggingTaggedResourceObjectAccountRuleset {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'account_ruleset';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for ai_gateway resources
     */
    interface ResourceTaggingTaggedResourceObjectAIGateway {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'ai_gateway';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for alerting_policy resources
     */
    interface ResourceTaggingTaggedResourceObjectAlertingPolicy {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'alerting_policy';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for alerting_webhook resources
     */
    interface ResourceTaggingTaggedResourceObjectAlertingWebhook {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'alerting_webhook';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for api_gateway_operation resources
     */
    interface ResourceTaggingTaggedResourceObjectAPIGatewayOperation {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'api_gateway_operation';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for cloudflared_tunnel resources
     */
    interface ResourceTaggingTaggedResourceObjectCloudflaredTunnel {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'cloudflared_tunnel';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for custom_certificate resources
     */
    interface ResourceTaggingTaggedResourceObjectCustomCertificate {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'custom_certificate';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for custom_hostname resources
     */
    interface ResourceTaggingTaggedResourceObjectCustomHostname {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'custom_hostname';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for cws_deployment resources
     */
    interface ResourceTaggingTaggedResourceObjectCwsDeployment {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'cws_deployment';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for cws_policy resources
     */
    interface ResourceTaggingTaggedResourceObjectCwsPolicy {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'cws_policy';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for cws_policy_set resources
     */
    interface ResourceTaggingTaggedResourceObjectCwsPolicySet {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'cws_policy_set';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for cws_workload resources
     */
    interface ResourceTaggingTaggedResourceObjectCwsWorkload {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'cws_workload';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for d1_database resources
     */
    interface ResourceTaggingTaggedResourceObjectD1Database {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'd1_database';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for dns_record resources
     */
    interface ResourceTaggingTaggedResourceObjectDNSRecord {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'dns_record';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for durable_object_namespace resources
     */
    interface ResourceTaggingTaggedResourceObjectDurableObjectNamespace {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'durable_object_namespace';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for gateway_list resources
     */
    interface ResourceTaggingTaggedResourceObjectGatewayList {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'gateway_list';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for gateway_rule resources
     */
    interface ResourceTaggingTaggedResourceObjectGatewayRule {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'gateway_rule';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for healthcheck resources
     */
    interface ResourceTaggingTaggedResourceObjectHealthcheck {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'healthcheck';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for image resources
     */
    interface ResourceTaggingTaggedResourceObjectImage {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'image';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for infrastructure_target resources
     */
    interface ResourceTaggingTaggedResourceObjectInfrastructureTarget {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'infrastructure_target';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for kv_namespace resources
     */
    interface ResourceTaggingTaggedResourceObjectKVNamespace {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'kv_namespace';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for load_balancer resources
     */
    interface ResourceTaggingTaggedResourceObjectLoadBalancer {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'load_balancer';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for load_balancer_monitor resources
     */
    interface ResourceTaggingTaggedResourceObjectLoadBalancerMonitor {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'load_balancer_monitor';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for load_balancer_pool resources
     */
    interface ResourceTaggingTaggedResourceObjectLoadBalancerPool {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'load_balancer_pool';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for managed_client_certificate resources
     */
    interface ResourceTaggingTaggedResourceObjectManagedClientCertificate {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'managed_client_certificate';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for pages_project resources
     */
    interface ResourceTaggingTaggedResourceObjectPagesProject {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'pages_project';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for queue resources
     */
    interface ResourceTaggingTaggedResourceObjectQueue {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'queue';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for r2_bucket resources
     */
    interface ResourceTaggingTaggedResourceObjectR2Bucket {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'r2_bucket';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for resource_share resources
     */
    interface ResourceTaggingTaggedResourceObjectResourceShare {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'resource_share';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for stream_live_input resources
     */
    interface ResourceTaggingTaggedResourceObjectStreamLiveInput {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'stream_live_input';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for stream_video resources
     */
    interface ResourceTaggingTaggedResourceObjectStreamVideo {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'stream_video';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for vectorize_index resources
     */
    interface ResourceTaggingTaggedResourceObjectVectorizeIndex {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'vectorize_index';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for worker resources
     */
    interface ResourceTaggingTaggedResourceObjectWorker {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'worker';
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for worker_route resources
     */
    interface ResourceTaggingTaggedResourceObjectWorkerRoute {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'worker_route';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for worker_version resources
     */
    interface ResourceTaggingTaggedResourceObjectWorkerVersion {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'worker_version';
        /**
         * Worker ID is required only for worker_version resources
         */
        worker_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for zone resources
     */
    interface ResourceTaggingTaggedResourceObjectZone {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'zone';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
    /**
     * Response for zone_ruleset resources
     */
    interface ResourceTaggingTaggedResourceObjectZoneRuleset {
        /**
         * Identifies the unique resource.
         */
        id: string;
        /**
         * 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;
        /**
         * Human-readable name of the resource.
         */
        name: string;
        /**
         * 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: {
            [key: string]: string;
        };
        type: 'zone_ruleset';
        /**
         * Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Monotonic version of the resource's tags: the timestamp assigned when the tags
         * were last written. Returned by read endpoints, by 2PC prepare (the version that
         * will be assigned on commit, unless a concurrent write lands first, in which case
         * a newer version is assigned), and by 2PC commit (the authoritative committed
         * version). Omitted for untagged resources and delete commits: a deleted resource
         * has no current version, and deletions are ordered by event order rather than by
         * version.
         */
        tags_updated_at?: string;
    }
}
export type ZoneTagUpdateParams = ZoneTagUpdateParams.ResourceTaggingSetTagsRequestZoneLevelBase | ZoneTagUpdateParams.ResourceTaggingSetTagsRequestZoneLevelAccessApplicationPolicy;
export declare namespace ZoneTagUpdateParams {
    interface ResourceTaggingSetTagsRequestZoneLevelBase {
        /**
         * Path param: Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Body param: Identifies the unique resource.
         */
        resource_id: string;
        /**
         * Body param: Enum for base zone-level resource types (those with no extra
         * required fields).
         */
        resource_type: 'api_gateway_operation' | 'custom_certificate' | 'custom_hostname' | 'dns_record' | 'healthcheck' | 'load_balancer' | 'managed_client_certificate' | 'worker_route' | 'zone' | 'zone_ruleset';
        /**
         * Body param: 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?: {
            [key: string]: string;
        };
        /**
         * Header param: ETag value for optimistic concurrency control. When provided, the
         * server will verify the current resource ETag matches before applying the write.
         * Returns 412 Precondition Failed if the resource has been modified since the ETag
         * was obtained. Omit this header for unconditional writes.
         */
        'If-Match'?: string;
    }
    interface ResourceTaggingSetTagsRequestZoneLevelAccessApplicationPolicy {
        /**
         * Path param: Zone ID is required only for zone-level resources
         */
        zone_id: string;
        /**
         * Body param: Access application ID is required only for access_application_policy
         * resources
         */
        access_application_id: string;
        /**
         * Body param: Identifies the unique resource.
         */
        resource_id: string;
        /**
         * Body param: Enum for access_application_policy resource type.
         */
        resource_type: 'access_application_policy';
        /**
         * Body param: 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?: {
            [key: string]: string;
        };
        /**
         * Header param: ETag value for optimistic concurrency control. When provided, the
         * server will verify the current resource ETag matches before applying the write.
         * Returns 412 Precondition Failed if the resource has been modified since the ETag
         * was obtained. Omit this header for unconditional writes.
         */
        'If-Match'?: string;
    }
}
export interface ZoneTagDeleteParams {
    /**
     * Path param: Zone ID is required only for zone-level resources
     */
    zone_id: string;
    /**
     * Header param: ETag value for optimistic concurrency control. When provided, the
     * server will verify the current resource ETag matches before applying the write.
     * Returns 412 Precondition Failed if the resource has been modified since the ETag
     * was obtained. Omit this header for unconditional writes.
     */
    'If-Match'?: string;
}
export interface ZoneTagGetParams {
    /**
     * Path param: Zone ID is required only for zone-level resources
     */
    zone_id: string;
    /**
     * Query param: The ID of the resource to retrieve tags for.
     */
    resource_id: string;
    /**
     * Query param: The type of the resource.
     */
    resource_type: 'access_application_policy' | 'api_gateway_operation' | 'custom_certificate' | 'custom_hostname' | 'dns_record' | 'healthcheck' | 'load_balancer' | 'managed_client_certificate' | 'worker_route' | 'zone' | 'zone_ruleset';
    /**
     * Query param: Access application ID identifier. Required for
     * access_application_policy resources.
     */
    access_application_id?: string;
}
export declare namespace ZoneTags {
    export { type ZoneTagUpdateResponse as ZoneTagUpdateResponse, type ZoneTagGetResponse as ZoneTagGetResponse, type ZoneTagUpdateParams as ZoneTagUpdateParams, type ZoneTagDeleteParams as ZoneTagDeleteParams, type ZoneTagGetParams as ZoneTagGetParams, };
}
//# sourceMappingURL=zone-tags.d.ts.map