import { APIResource } from "../../core/resource.mjs";
import * as AccountTagsAPI from "./account-tags.mjs";
import { AccountTagDeleteParams, AccountTagGetParams, AccountTagGetResponse, AccountTagUpdateParams, AccountTagUpdateResponse, AccountTags, BaseAccountTags } from "./account-tags.mjs";
import * as KeysAPI from "./keys.mjs";
import { BaseKeys, KeyListParams, KeyListResponse, KeyListResponsesCursorPaginationAfter, Keys } from "./keys.mjs";
import * as SummaryAPI from "./summary.mjs";
import { BaseSummary, Summary, SummaryGetParams, SummaryGetResponse } from "./summary.mjs";
import * as ValuesAPI from "./values.mjs";
import { BaseValues, ValueListParams, ValueListResponse, ValueListResponsesCursorPaginationAfter, Values } from "./values.mjs";
import * as ZoneTagsAPI from "./zone-tags.mjs";
import { BaseZoneTags, ZoneTagDeleteParams, ZoneTagGetParams, ZoneTagGetResponse, ZoneTagUpdateParams, ZoneTagUpdateResponse, ZoneTags } from "./zone-tags.mjs";
import { CursorPaginationAfter, type CursorPaginationAfterParams, PagePromise } from "../../core/pagination.mjs";
import { RequestOptions } from "../../internal/request-options.mjs";
export declare class BaseResourceTagging extends APIResource {
    static readonly _key: readonly ['resourceTagging'];
    /**
     * Lists all tagged resources for an account.
     */
    list(params: ResourceTaggingListParams, options?: RequestOptions): PagePromise<ResourceTaggingListResponsesCursorPaginationAfter, ResourceTaggingListResponse>;
}
export declare class ResourceTagging extends BaseResourceTagging {
    accountTags: AccountTagsAPI.AccountTags;
    zoneTags: ZoneTagsAPI.ZoneTags;
    keys: KeysAPI.Keys;
    values: ValuesAPI.Values;
    summary: SummaryAPI.Summary;
}
export type ResourceTaggingListResponsesCursorPaginationAfter = CursorPaginationAfter<ResourceTaggingListResponse>;
/**
 * Response for access_application resources
 */
export type ResourceTaggingListResponse = ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectAccessApplication | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectAccessApplicationPolicy | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectAccessGroup | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectAccount | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectAccountRuleset | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectAIGateway | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectAlertingPolicy | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectAlertingWebhook | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectAPIGatewayOperation | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectCloudflaredTunnel | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectCustomCertificate | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectCustomHostname | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectCwsDeployment | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectCwsPolicy | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectCwsPolicySet | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectCwsWorkload | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectD1Database | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectDNSRecord | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectDurableObjectNamespace | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectGatewayList | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectGatewayRule | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectHealthcheck | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectImage | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectInfrastructureTarget | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectKVNamespace | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectLoadBalancer | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectLoadBalancerMonitor | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectLoadBalancerPool | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectManagedClientCertificate | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectPagesProject | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectQueue | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectR2Bucket | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectResourceShare | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectStreamLiveInput | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectStreamVideo | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectVectorizeIndex | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectWorker | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectWorkerRoute | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectWorkerVersion | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectZone | ResourceTaggingListResponse.ResourceTaggingTaggedResourceObjectZoneRuleset;
export declare namespace ResourceTaggingListResponse {
    /**
     * 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 interface ResourceTaggingListParams extends CursorPaginationAfterParams {
    /**
     * Path param: Identifier.
     */
    account_id: string;
    /**
     * Query param: Filter by resource ID. Can be repeated up to 50 times to filter by
     * multiple IDs. Example: ?id=abc&id=def
     */
    id?: Array<string>;
    /**
     * Query param: Match `tag` keys and values case-insensitively. Stored casing is
     * unchanged. Example: ?tag=environment=production&case_insensitive=true
     */
    case_insensitive?: boolean;
    /**
     * Query param: Filter by resource name. Performs a case-insensitive substring
     * match. Example: ?name=my-zone
     */
    name?: string;
    /**
     * Query param: Filter resources by tag criteria. This parameter can be repeated
     * multiple times, with AND logic between parameters.
     *
     * Supported syntax:
     *
     * - **Key-only**: `tag=<key>` - Resource must have the tag key (e.g.,
     *   `tag=production`)
     * - **Key-value**: `tag=<key>=<value>` - Resource must have the tag with specific
     *   value (e.g., `tag=env=prod`)
     * - **Multiple values (OR)**: `tag=<key>=<v1>,<v2>` - Resource must have tag with
     *   any of the values (e.g., `tag=env=prod,staging`)
     * - **Negate key-only**: `tag=!<key>` - Resource must not have the tag key (e.g.,
     *   `tag=!archived`)
     * - **Negate key-value**: `tag=<key>!=<value>` - Resource must not have the tag
     *   with specific value (e.g., `tag=region!=us-west-1`)
     *
     * Multiple tag parameters are combined with AND logic.
     */
    tag?: Array<string>;
    /**
     * Query param: Filter by resource type. Can be repeated to filter by multiple
     * types (OR logic). Example: ?type=zone&type=worker
     */
    type?: Array<'access_application' | 'access_application_policy' | 'access_group' | 'account' | 'account_ruleset' | 'ai_gateway' | 'alerting_policy' | 'alerting_webhook' | 'api_gateway_operation' | 'cloudflared_tunnel' | 'custom_certificate' | 'custom_hostname' | 'cws_deployment' | 'cws_policy' | 'cws_policy_set' | 'cws_workload' | 'd1_database' | 'dns_record' | 'durable_object_namespace' | 'gateway_list' | 'gateway_rule' | 'healthcheck' | 'image' | 'infrastructure_target' | 'kv_namespace' | 'load_balancer' | 'load_balancer_monitor' | 'load_balancer_pool' | 'managed_client_certificate' | 'pages_project' | 'queue' | 'r2_bucket' | 'resource_share' | 'stream_live_input' | 'stream_video' | 'vectorize_index' | 'worker' | 'worker_route' | 'worker_version' | 'zone' | 'zone_ruleset'>;
}
export declare namespace ResourceTagging {
    export { type ResourceTaggingListResponse as ResourceTaggingListResponse, type ResourceTaggingListResponsesCursorPaginationAfter as ResourceTaggingListResponsesCursorPaginationAfter, type ResourceTaggingListParams as ResourceTaggingListParams, };
    export { AccountTags as AccountTags, BaseAccountTags as BaseAccountTags, type AccountTagUpdateResponse as AccountTagUpdateResponse, type AccountTagGetResponse as AccountTagGetResponse, type AccountTagUpdateParams as AccountTagUpdateParams, type AccountTagDeleteParams as AccountTagDeleteParams, type AccountTagGetParams as AccountTagGetParams, };
    export { ZoneTags as ZoneTags, BaseZoneTags as BaseZoneTags, type ZoneTagUpdateResponse as ZoneTagUpdateResponse, type ZoneTagGetResponse as ZoneTagGetResponse, type ZoneTagUpdateParams as ZoneTagUpdateParams, type ZoneTagDeleteParams as ZoneTagDeleteParams, type ZoneTagGetParams as ZoneTagGetParams, };
    export { Keys as Keys, BaseKeys as BaseKeys, type KeyListResponse as KeyListResponse, type KeyListResponsesCursorPaginationAfter as KeyListResponsesCursorPaginationAfter, type KeyListParams as KeyListParams, };
    export { Values as Values, BaseValues as BaseValues, type ValueListResponse as ValueListResponse, type ValueListResponsesCursorPaginationAfter as ValueListResponsesCursorPaginationAfter, type ValueListParams as ValueListParams, };
    export { Summary as Summary, BaseSummary as BaseSummary, type SummaryGetResponse as SummaryGetResponse, type SummaryGetParams as SummaryGetParams, };
}
//# sourceMappingURL=resource-tagging.d.mts.map