// 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 BaseZoneTags extends APIResource {
  static override readonly _key: readonly ['resourceTagging', 'zoneTags'] = Object.freeze([
    'resourceTagging',
    'zoneTags',
  ] as const);

  /**
   * Creates or updates tags for a specific zone-level resource. Replaces all
   * existing tags for the resource.
   *
   * @example
   * ```ts
   * const zoneTag =
   *   await client.resourceTagging.zoneTags.update({
   *     zone_id: '023e105f4ecef8ad9ca31a8372d0c353',
   *     resource_id: '023e105f4ecef8ad9ca31a8372d0c353',
   *     resource_type: 'zone',
   *   });
   * ```
   */
  update(params: ZoneTagUpdateParams, options?: RequestOptions): APIPromise<ZoneTagUpdateResponse> {
    const { zone_id, 'If-Match': ifMatch, ...body } = params;
    return (
      this._client.put(path`/zones/${zone_id}/tags`, {
        body,
        ...options,
        headers: buildHeaders([
          { ...(ifMatch != null ? { 'If-Match': ifMatch } : undefined) },
          options?.headers,
        ]),
      }) as APIPromise<{ result: ZoneTagUpdateResponse }>
    )._thenUnwrap((obj) => obj.result);
  }

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

  /**
   * Retrieves tags for a specific zone-level resource.
   */
  get(params: ZoneTagGetParams, options?: RequestOptions): APIPromise<ZoneTagGetResponse> {
    const { zone_id, ...query } = params;
    return (
      this._client.get(path`/zones/${zone_id}/tags`, { query, ...options }) as APIPromise<{
        result: ZoneTagGetResponse;
      }>
    )._thenUnwrap((obj) => obj.result);
  }
}
export class ZoneTags extends BaseZoneTags {}

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

export namespace ZoneTagUpdateResponse {
  /**
   * 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 ZoneTagGetResponse =
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAccessApplication
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAccessApplicationPolicy
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAccessGroup
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAccount
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAccountRuleset
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAIGateway
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAlertingPolicy
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAlertingWebhook
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectAPIGatewayOperation
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCloudflaredTunnel
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCustomCertificate
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCustomHostname
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCwsDeployment
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCwsPolicy
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCwsPolicySet
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectCwsWorkload
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectD1Database
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectDNSRecord
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectDurableObjectNamespace
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectGatewayList
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectGatewayRule
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectHealthcheck
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectImage
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectInfrastructureTarget
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectKVNamespace
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectLoadBalancer
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectLoadBalancerMonitor
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectLoadBalancerPool
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectManagedClientCertificate
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectPagesProject
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectQueue
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectR2Bucket
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectResourceShare
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectStreamLiveInput
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectStreamVideo
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectVectorizeIndex
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectWorker
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectWorkerRoute
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectWorkerVersion
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectZone
  | ZoneTagGetResponse.ResourceTaggingTaggedResourceObjectZoneRuleset;

export namespace ZoneTagGetResponse {
  /**
   * 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 ZoneTagUpdateParams =
  | ZoneTagUpdateParams.ResourceTaggingSetTagsRequestZoneLevelBase
  | ZoneTagUpdateParams.ResourceTaggingSetTagsRequestZoneLevelAccessApplicationPolicy;

export declare namespace ZoneTagUpdateParams {
  export interface ResourceTaggingSetTagsRequestZoneLevelBase {
    /**
     * Path param: Zone ID is required only for zone-level resources
     */
    zone_id: string;

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

    /**
     * Body param: Enum for base zone-level resource types (those with no extra
     * required fields).
     */
    resource_type:
      | 'api_gateway_operation'
      | 'custom_certificate'
      | 'custom_hostname'
      | 'dns_record'
      | 'healthcheck'
      | 'load_balancer'
      | 'managed_client_certificate'
      | 'worker_route'
      | 'zone'
      | 'zone_ruleset';

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

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

  export interface ResourceTaggingSetTagsRequestZoneLevelAccessApplicationPolicy {
    /**
     * Path param: Zone ID is required only for zone-level resources
     */
    zone_id: string;

    /**
     * Body param: Access application ID is required only for access_application_policy
     * resources
     */
    access_application_id: string;

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

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

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

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

export interface ZoneTagDeleteParams {
  /**
   * Path param: Zone ID is required only for zone-level resources
   */
  zone_id: string;

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

export interface ZoneTagGetParams {
  /**
   * Path param: Zone ID is required only for zone-level resources
   */
  zone_id: string;

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

  /**
   * Query param: The type of the resource.
   */
  resource_type:
    | 'access_application_policy'
    | 'api_gateway_operation'
    | 'custom_certificate'
    | 'custom_hostname'
    | 'dns_record'
    | 'healthcheck'
    | 'load_balancer'
    | 'managed_client_certificate'
    | 'worker_route'
    | 'zone'
    | 'zone_ruleset';

  /**
   * Query param: Access application ID identifier. Required for
   * access_application_policy resources.
   */
  access_application_id?: string;
}

export declare namespace ZoneTags {
  export {
    type ZoneTagUpdateResponse as ZoneTagUpdateResponse,
    type ZoneTagGetResponse as ZoneTagGetResponse,
    type ZoneTagUpdateParams as ZoneTagUpdateParams,
    type ZoneTagDeleteParams as ZoneTagDeleteParams,
    type ZoneTagGetParams as ZoneTagGetParams,
  };
}