cloudflare 6.0.0-beta.1 → 6.0.0

package/resources/resource-tagging/account-tags.d.ts

@@ -0,0 +1,1721 @@
+import { APIResource } from "../../resource.js";
+import * as Core from "../../core.js";
+export declare class AccountTags extends APIResource {
+    /**
+     * Creates or updates tags for a specific account-level resource.
+     *
+     * @example
+     * ```ts
+     * const accountTag =
+     *   await client.resourceTagging.accountTags.update({
+     *     account_id: '023e105f4ecef8ad9ca31a8372d0c353',
+     *     resource_id: '023e105f4ecef8ad9ca31a8372d0c353',
+     *     resource_type: 'worker',
+     *     worker_id: '3f72a691-44b3-4c11-8642-c18a88ddaa5e',
+     *   });
+     * ```
+     */
+    update(params: AccountTagUpdateParams, options?: Core.RequestOptions): Core.APIPromise<AccountTagUpdateResponse>;
+    /**
+     * Removes all tags from a specific account-level resource.
+     */
+    delete(params: AccountTagDeleteParams, options?: Core.RequestOptions): Core.APIPromise<void>;
+    /**
+     * Retrieves tags for a specific account-level resource.
+     */
+    get(params: AccountTagGetParams, options?: Core.RequestOptions): Core.APIPromise<AccountTagGetResponse>;
+}
+/**
+ * Response for access_application resources
+ */
+export type AccountTagUpdateResponse = AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccessApplication | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccessApplicationPolicy | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccessGroup | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccount | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAIGateway | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAlertingPolicy | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAlertingWebhook | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAPIGatewayOperation | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCloudflaredTunnel | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCustomCertificate | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCustomHostname | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectD1Database | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectDNSRecord | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectDurableObjectNamespace | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectGatewayList | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectGatewayRule | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectImage | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectKVNamespace | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectManagedClientCertificate | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectQueue | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectR2Bucket | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectResourceShare | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectStreamLiveInput | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectStreamVideo | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectWorker | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectWorkerVersion | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectZone;
+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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'access_application';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'access_application_policy';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'access_group';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'account';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'ai_gateway';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'alerting_policy';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'alerting_webhook';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'api_gateway_operation';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'cloudflared_tunnel';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'custom_certificate';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'custom_hostname';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'd1_database';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'dns_record';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'durable_object_namespace';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'gateway_list';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'gateway_rule';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'image';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'kv_namespace';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'managed_client_certificate';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'queue';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'r2_bucket';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'resource_share';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'stream_live_input';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'stream_video';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'worker';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'worker_version';
+        /**
+         * Worker ID is required only for worker_version resources
+         */
+        worker_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'zone';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: string;
+    }
+}
+/**
+ * Response for access_application resources
+ */
+export type AccountTagGetResponse = AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccessApplication | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccessApplicationPolicy | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccessGroup | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccount | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAIGateway | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAlertingPolicy | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAlertingWebhook | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAPIGatewayOperation | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCloudflaredTunnel | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCustomCertificate | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCustomHostname | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectD1Database | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectDNSRecord | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectDurableObjectNamespace | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectGatewayList | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectGatewayRule | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectImage | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectKVNamespace | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectManagedClientCertificate | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectQueue | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectR2Bucket | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectResourceShare | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectStreamLiveInput | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectStreamVideo | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectWorker | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectWorkerVersion | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectZone;
+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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'access_application';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'access_application_policy';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'access_group';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'account';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'ai_gateway';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'alerting_policy';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'alerting_webhook';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'api_gateway_operation';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'cloudflared_tunnel';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'custom_certificate';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'custom_hostname';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'd1_database';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'dns_record';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'durable_object_namespace';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'gateway_list';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'gateway_rule';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'image';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'kv_namespace';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'managed_client_certificate';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'queue';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'r2_bucket';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'resource_share';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'stream_live_input';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'stream_video';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'worker';
+    }
+    /**
+     * 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'worker_version';
+        /**
+         * Worker ID is required only for worker_version resources
+         */
+        worker_id: 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.
+         */
+        tags: {
+            [key: string]: string;
+        };
+        type: 'zone';
+        /**
+         * Zone ID is required only for zone-level resources
+         */
+        zone_id: 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 base account-level resource types (those with no extra
+         * required fields).
+         */
+        resource_type: 'access_application' | 'access_group' | 'account' | 'ai_gateway' | 'alerting_policy' | 'alerting_webhook' | 'cloudflared_tunnel' | 'd1_database' | 'durable_object_namespace' | 'gateway_list' | 'gateway_rule' | 'image' | 'kv_namespace' | 'queue' | 'r2_bucket' | 'resource_share' | 'stream_live_input' | 'stream_video' | 'worker' | 'worker_version';
+        /**
+         * Body param: Worker ID is required only for worker_version resources
+         */
+        worker_id: string;
+        /**
+         * Body param: Contains key-value pairs of 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' | 'ai_gateway' | 'alerting_policy' | 'alerting_webhook' | 'cloudflared_tunnel' | 'd1_database' | 'durable_object_namespace' | 'gateway_list' | 'gateway_rule' | 'image' | 'kv_namespace' | 'queue' | 'r2_bucket' | 'resource_share' | 'stream_live_input' | 'stream_video' | 'worker';
+        /**
+         * Body param: Contains key-value pairs of 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' | 'ai_gateway' | 'alerting_policy' | 'alerting_webhook' | 'cloudflared_tunnel' | 'd1_database' | 'durable_object_namespace' | 'gateway_list' | 'gateway_rule' | 'image' | 'kv_namespace' | 'queue' | 'r2_bucket' | 'resource_share' | 'stream_live_input' | 'stream_video' | '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.ts.map