// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

import { APIResource } from '../../core/resource';
import { APIPromise } from '../../core/api-promise';
import { buildHeaders } from '../../internal/headers';
import { RequestOptions } from '../../internal/request-options';
import { path } from '../../internal/utils/path';

export class BaseAccountTags extends APIResource {
  static override readonly _key: readonly ['resourceTagging', 'accountTags'] = Object.freeze([
    'resourceTagging',
    'accountTags',
  ] as const);

  /**
   * Creates or updates tags for a specific account-level resource. Replaces all
   * existing tags for the resource.
   *
   * @example
   * ```ts
   * const accountTag =
   *   await client.resourceTagging.accountTags.update({
   *     account_id: '023e105f4ecef8ad9ca31a8372d0c353',
   *     resource_id: '023e105f4ecef8ad9ca31a8372d0c353',
   *     resource_type: 'worker_version',
   *     worker_id: '3f72a691-44b3-4c11-8642-c18a88ddaa5e',
   *   });
   * ```
   */
  update(params: AccountTagUpdateParams, options?: RequestOptions): APIPromise<AccountTagUpdateResponse> {
    const { account_id, 'If-Match': ifMatch, ...body } = params;
    return (
      this._client.put(path`/accounts/${account_id}/tags`, {
        body,
        ...options,
        headers: buildHeaders([
          { ...(ifMatch != null ? { 'If-Match': ifMatch } : undefined) },
          options?.headers,
        ]),
      }) as APIPromise<{ result: AccountTagUpdateResponse }>
    )._thenUnwrap((obj) => obj.result);
  }

  /**
   * Removes all tags from a specific account-level resource.
   */
  delete(params: AccountTagDeleteParams, options?: RequestOptions): APIPromise<void> {
    const { account_id, 'If-Match': ifMatch } = params;
    return this._client.delete(path`/accounts/${account_id}/tags`, {
      ...options,
      headers: buildHeaders([
        { Accept: '*/*', ...(ifMatch != null ? { 'If-Match': ifMatch } : undefined) },
        options?.headers,
      ]),
    });
  }

  /**
   * Retrieves tags for a specific account-level resource.
   */
  get(params: AccountTagGetParams, options?: RequestOptions): APIPromise<AccountTagGetResponse> {
    const { account_id, ...query } = params;
    return (
      this._client.get(path`/accounts/${account_id}/tags`, { query, ...options }) as APIPromise<{
        result: AccountTagGetResponse;
      }>
    )._thenUnwrap((obj) => obj.result);
  }
}
export class AccountTags extends BaseAccountTags {}

/**
 * Response for access_application resources
 */
export type AccountTagUpdateResponse =
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccessApplication
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccessApplicationPolicy
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccessGroup
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccount
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAccountRuleset
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAIGateway
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAlertingPolicy
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAlertingWebhook
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectAPIGatewayOperation
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCloudflaredTunnel
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCustomCertificate
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCustomHostname
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCwsDeployment
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCwsPolicy
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCwsPolicySet
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectCwsWorkload
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectD1Database
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectDNSRecord
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectDurableObjectNamespace
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectGatewayList
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectGatewayRule
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectHealthcheck
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectImage
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectInfrastructureTarget
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectKVNamespace
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectLoadBalancer
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectLoadBalancerMonitor
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectLoadBalancerPool
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectManagedClientCertificate
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectPagesProject
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectQueue
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectR2Bucket
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectResourceShare
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectStreamLiveInput
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectStreamVideo
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectVectorizeIndex
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectWorker
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectWorkerRoute
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectWorkerVersion
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectZone
  | AccountTagUpdateResponse.ResourceTaggingTaggedResourceObjectZoneRuleset;

export namespace AccountTagUpdateResponse {
  /**
   * Response for access_application resources
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export interface ResourceTaggingTaggedResourceObjectZoneRuleset {
    /**
     * Identifies the unique resource.
     */
    id: string;

    /**
     * ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
     * where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
     * tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
     * should treat ETags as opaque strings and pass them back via the If-Match header
     * on write operations.
     */
    etag: string;

    /**
     * Human-readable name of the resource.
     */
    name: string;

    /**
     * Contains key-value pairs of tags. Keys may contain at most 256 characters.
     * Values may contain at most 1024 characters and may be empty for key-only tags.
     */
    tags: { [key: string]: string };

    type: 'zone_ruleset';

    /**
     * Zone ID is required only for zone-level resources
     */
    zone_id: string;

    /**
     * Monotonic version of the resource's tags: the timestamp assigned when the tags
     * were last written. Returned by read endpoints, by 2PC prepare (the version that
     * will be assigned on commit, unless a concurrent write lands first, in which case
     * a newer version is assigned), and by 2PC commit (the authoritative committed
     * version). Omitted for untagged resources and delete commits: a deleted resource
     * has no current version, and deletions are ordered by event order rather than by
     * version.
     */
    tags_updated_at?: string;
  }
}

/**
 * Response for access_application resources
 */
export type AccountTagGetResponse =
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccessApplication
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccessApplicationPolicy
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccessGroup
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccount
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAccountRuleset
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAIGateway
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAlertingPolicy
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAlertingWebhook
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectAPIGatewayOperation
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCloudflaredTunnel
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCustomCertificate
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCustomHostname
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCwsDeployment
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCwsPolicy
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCwsPolicySet
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectCwsWorkload
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectD1Database
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectDNSRecord
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectDurableObjectNamespace
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectGatewayList
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectGatewayRule
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectHealthcheck
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectImage
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectInfrastructureTarget
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectKVNamespace
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectLoadBalancer
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectLoadBalancerMonitor
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectLoadBalancerPool
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectManagedClientCertificate
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectPagesProject
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectQueue
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectR2Bucket
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectResourceShare
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectStreamLiveInput
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectStreamVideo
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectVectorizeIndex
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectWorker
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectWorkerRoute
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectWorkerVersion
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectZone
  | AccountTagGetResponse.ResourceTaggingTaggedResourceObjectZoneRuleset;

export namespace AccountTagGetResponse {
  /**
   * Response for access_application resources
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export interface ResourceTaggingTaggedResourceObjectZoneRuleset {
    /**
     * Identifies the unique resource.
     */
    id: string;

    /**
     * ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>"
     * where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the
     * tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients
     * should treat ETags as opaque strings and pass them back via the If-Match header
     * on write operations.
     */
    etag: string;

    /**
     * Human-readable name of the resource.
     */
    name: string;

    /**
     * Contains key-value pairs of tags. Keys may contain at most 256 characters.
     * Values may contain at most 1024 characters and may be empty for key-only tags.
     */
    tags: { [key: string]: string };

    type: 'zone_ruleset';

    /**
     * Zone ID is required only for zone-level resources
     */
    zone_id: string;

    /**
     * Monotonic version of the resource's tags: the timestamp assigned when the tags
     * were last written. Returned by read endpoints, by 2PC prepare (the version that
     * will be assigned on commit, unless a concurrent write lands first, in which case
     * a newer version is assigned), and by 2PC commit (the authoritative committed
     * version). Omitted for untagged resources and delete commits: a deleted resource
     * has no current version, and deletions are ordered by event order rather than by
     * version.
     */
    tags_updated_at?: string;
  }
}

export type AccountTagUpdateParams =
  | AccountTagUpdateParams.ResourceTaggingSetTagsRequestAccountLevelWorkerVersion
  | AccountTagUpdateParams.ResourceTaggingSetTagsRequestAccountLevelBase;

export declare namespace AccountTagUpdateParams {
  export interface ResourceTaggingSetTagsRequestAccountLevelWorkerVersion {
    /**
     * Path param: Identifier.
     */
    account_id: string;

    /**
     * Body param: Identifies the unique resource.
     */
    resource_id: string;

    /**
     * Body param: Enum for worker_version resource type.
     */
    resource_type: 'worker_version';

    /**
     * Body param: Worker ID is required only for worker_version resources
     */
    worker_id: string;

    /**
     * Body param: Contains key-value pairs of tags. Keys may contain at most 256
     * characters. Values may contain at most 1024 characters and may be empty for
     * key-only tags.
     */
    tags?: { [key: string]: string };

    /**
     * Header param: ETag value for optimistic concurrency control. When provided, the
     * server will verify the current resource ETag matches before applying the write.
     * Returns 412 Precondition Failed if the resource has been modified since the ETag
     * was obtained. Omit this header for unconditional writes.
     */
    'If-Match'?: string;
  }

  export interface ResourceTaggingSetTagsRequestAccountLevelBase {
    /**
     * Path param: Identifier.
     */
    account_id: string;

    /**
     * Body param: Identifies the unique resource.
     */
    resource_id: string;

    /**
     * Body param: Enum for base account-level resource types (those with no extra
     * required fields).
     */
    resource_type:
      | 'access_application'
      | 'access_group'
      | 'account'
      | 'account_ruleset'
      | 'ai_gateway'
      | 'alerting_policy'
      | 'alerting_webhook'
      | 'cloudflared_tunnel'
      | 'cws_deployment'
      | 'cws_policy'
      | 'cws_policy_set'
      | 'cws_workload'
      | 'd1_database'
      | 'durable_object_namespace'
      | 'gateway_list'
      | 'gateway_rule'
      | 'image'
      | 'infrastructure_target'
      | 'kv_namespace'
      | 'load_balancer_monitor'
      | 'load_balancer_pool'
      | 'pages_project'
      | 'queue'
      | 'r2_bucket'
      | 'resource_share'
      | 'stream_live_input'
      | 'stream_video'
      | 'vectorize_index'
      | 'worker';

    /**
     * Body param: Contains key-value pairs of tags. Keys may contain at most 256
     * characters. Values may contain at most 1024 characters and may be empty for
     * key-only tags.
     */
    tags?: { [key: string]: string };

    /**
     * Header param: ETag value for optimistic concurrency control. When provided, the
     * server will verify the current resource ETag matches before applying the write.
     * Returns 412 Precondition Failed if the resource has been modified since the ETag
     * was obtained. Omit this header for unconditional writes.
     */
    'If-Match'?: string;
  }
}

export interface AccountTagDeleteParams {
  /**
   * Path param: Identifier.
   */
  account_id: string;

  /**
   * Header param: ETag value for optimistic concurrency control. When provided, the
   * server will verify the current resource ETag matches before applying the write.
   * Returns 412 Precondition Failed if the resource has been modified since the ETag
   * was obtained. Omit this header for unconditional writes.
   */
  'If-Match'?: string;
}

export interface AccountTagGetParams {
  /**
   * Path param: Identifier.
   */
  account_id: string;

  /**
   * Query param: The ID of the resource to retrieve tags for.
   */
  resource_id: string;

  /**
   * Query param: The type of the resource.
   */
  resource_type:
    | 'access_application'
    | 'access_group'
    | 'account'
    | 'account_ruleset'
    | 'ai_gateway'
    | 'alerting_policy'
    | 'alerting_webhook'
    | 'cloudflared_tunnel'
    | 'cws_deployment'
    | 'cws_policy'
    | 'cws_policy_set'
    | 'cws_workload'
    | 'd1_database'
    | 'durable_object_namespace'
    | 'gateway_list'
    | 'gateway_rule'
    | 'image'
    | 'infrastructure_target'
    | 'kv_namespace'
    | 'load_balancer_monitor'
    | 'load_balancer_pool'
    | 'pages_project'
    | 'queue'
    | 'r2_bucket'
    | 'resource_share'
    | 'stream_live_input'
    | 'stream_video'
    | 'vectorize_index'
    | 'worker'
    | 'worker_version';

  /**
   * Query param: Worker identifier. Required for worker_version resources.
   */
  worker_id?: string;
}

export declare namespace AccountTags {
  export {
    type AccountTagUpdateResponse as AccountTagUpdateResponse,
    type AccountTagGetResponse as AccountTagGetResponse,
    type AccountTagUpdateParams as AccountTagUpdateParams,
    type AccountTagDeleteParams as AccountTagDeleteParams,
    type AccountTagGetParams as AccountTagGetParams,
  };
}