import { APIResource } from "../../core/resource.mjs";
import { APIPromise } from "../../core/api-promise.mjs";
import { RequestOptions } from "../../internal/request-options.mjs";
export declare class BaseAccountTags extends APIResource {
    static readonly _key: readonly ['resourceTagging', 'accountTags'];
    /**
     * Creates or updates tags for a specific account-level resource. Replaces all
     * existing tags for the resource.
     *
     * @example
     * ```ts
     * const accountTag =
     *   await client.resourceTagging.accountTags.update({
     *     account_id: '023e105f4ecef8ad9ca31a8372d0c353',
     *     resource_id: '023e105f4ecef8ad9ca31a8372d0c353',
     *     resource_type: 'worker_version',
     *     worker_id: '3f72a691-44b3-4c11-8642-c18a88ddaa5e',
     *   });
     * ```
     */
    update(params: AccountTagUpdateParams, options?: RequestOptions): APIPromise<AccountTagUpdateResponse>;
    /**
     * Removes all tags from a specific account-level resource.
     */
    delete(params: AccountTagDeleteParams, options?: RequestOptions): APIPromise<void>;
    /**
     * Retrieves tags for a specific account-level resource.
     */
    get(params: AccountTagGetParams, options?: RequestOptions): APIPromise<AccountTagGetResponse>;
}
export declare class AccountTags extends BaseAccountTags {
}
/**
 * Response for access_application resources
 */
export type AccountTagUpdateResponse = AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccessApplication | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccessApplicationPolicy | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccessGroup | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccount | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccountRuleset | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAIGateway | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAlertingPolicy | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAlertingWebhook | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAPIGatewayOperation | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCloudflaredTunnel | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCustomCertificate | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCustomHostname | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCwsDeployment | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCwsPolicy | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCwsPolicySet | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCwsWorkload | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectD1Database | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectDNSRecord | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectDurableObjectNamespace | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectGatewayList | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectGatewayRule | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectHealthcheck | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectImage | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectInfrastructureTarget | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectKVNamespace | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectLoadBalancer | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectLoadBalancerMonitor | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectLoadBalancerPool | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectManagedClientCertificate | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectPagesProject | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectQueue | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectR2Bucket | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectResourceShare | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectStreamLiveInput | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectStreamVideo | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectVectorizeIndex | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectWorker | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectWorkerRoute | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectWorkerVersion | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectZone | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectZoneRuleset;
export declare namespace AccountTagUpdateResponse {
    /**
     * 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 AccountTagGetResponse = AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccessApplication | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccessApplicationPolicy | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccessGroup | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccount | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccountRuleset | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAIGateway | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAlertingPolicy | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAlertingWebhook | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAPIGatewayOperation | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCloudflaredTunnel | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCustomCertificate | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCustomHostname | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCwsDeployment | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCwsPolicy | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCwsPolicySet | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCwsWorkload | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectD1Database | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectDNSRecord | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectDurableObjectNamespace | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectGatewayList | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectGatewayRule | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectHealthcheck | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectImage | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectInfrastructureTarget | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectKVNamespace | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectLoadBalancer | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectLoadBalancerMonitor | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectLoadBalancerPool | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectManagedClientCertificate | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectPagesProject | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectQueue | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectR2Bucket | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectResourceShare | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectStreamLiveInput | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectStreamVideo | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectVectorizeIndex | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectWorker | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectWorkerRoute | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectWorkerVersion | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectZone | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectZoneRuleset;
export declare namespace AccountTagGetResponse {
    /**
     * 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 AccountTagUpdateParams = AccountTagUpdateParams.ResourceTaggingSetTagsRequestAccountLevelWorkerVersion | AccountTagUpdateParams.ResourceTaggingSetTagsRequestAccountLevelBase;
export declare namespace AccountTagUpdateParams {
    interface ResourceTaggingSetTagsRequestAccountLevelWorkerVersion {
        /**
         * Path param: Identifier.
         */
        account_id: string;
        /**
         * Body param: Identifies the unique resource.
         */
        resource_id: string;
        /**
         * Body param: Enum for worker_version resource type.
         */
        resource_type: 'worker_version';
        /**
         * Body param: Worker ID is required only for worker_version resources
         */
        worker_id: string;
        /**
         * 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 ResourceTaggingSetTagsRequestAccountLevelBase {
        /**
         * Path param: Identifier.
         */
        account_id: string;
        /**
         * Body param: Identifies the unique resource.
         */
        resource_id: string;
        /**
         * Body param: Enum for base account-level resource types (those with no extra
         * required fields).
         */
        resource_type: 'access_application' | 'access_group' | 'account' | 'account_ruleset' | 'ai_gateway' | 'alerting_policy' | 'alerting_webhook' | 'cloudflared_tunnel' | 'cws_deployment' | 'cws_policy' | 'cws_policy_set' | 'cws_workload' | 'd1_database' | 'durable_object_namespace' | 'gateway_list' | 'gateway_rule' | 'image' | 'infrastructure_target' | 'kv_namespace' | 'load_balancer_monitor' | 'load_balancer_pool' | 'pages_project' | 'queue' | 'r2_bucket' | 'resource_share' | 'stream_live_input' | 'stream_video' | 'vectorize_index' | 'worker';
        /**
         * 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 AccountTagDeleteParams {
    /**
     * Path param: Identifier.
     */
    account_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 AccountTagGetParams {
    /**
     * Path param: Identifier.
     */
    account_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' | 'access_group' | 'account' | 'account_ruleset' | 'ai_gateway' | 'alerting_policy' | 'alerting_webhook' | 'cloudflared_tunnel' | 'cws_deployment' | 'cws_policy' | 'cws_policy_set' | 'cws_workload' | 'd1_database' | 'durable_object_namespace' | 'gateway_list' | 'gateway_rule' | 'image' | 'infrastructure_target' | 'kv_namespace' | 'load_balancer_monitor' | 'load_balancer_pool' | 'pages_project' | 'queue' | 'r2_bucket' | 'resource_share' | 'stream_live_input' | 'stream_video' | 'vectorize_index' | 'worker' | 'worker_version';
    /**
     * Query param: Worker identifier. Required for worker_version resources.
     */
    worker_id?: string;
}
export declare namespace AccountTags {
    export { type AccountTagUpdateResponse as AccountTagUpdateResponse, type AccountTagGetResponse as AccountTagGetResponse, type AccountTagUpdateParams as AccountTagUpdateParams, type AccountTagDeleteParams as AccountTagDeleteParams, type AccountTagGetParams as AccountTagGetParams, };
}
//# sourceMappingURL=account-tags.d.mts.map