// AUTO-GENERATED by scripts/generate.ts from .generated-specs. Do not edit.
import * as S from "@distilled.cloud/core/schema";
import * as API from "@distilled.cloud/core/api";
import * as T from "../traits.ts";
import {
  CloudflareProtocol,
  CloudflarePaginatedProtocol,
  type CloudflareOpError,
  type CloudflareOpContext,
} from "../protocol.ts";
import { cloudflarePaginate, ResultInfo } from "../pagination.ts";
import { CloudflareError, CloudflareRateLimited } from "../errors.ts";
import * as Retry from "../retry.ts";

export type { CloudflareOpError, CloudflareOpContext };

/** Fallback camelCase→wire mapping for opaque content (mined from the distilled SDK). */
const KEY_DICTIONARY: Record<string, string | ReadonlyArray<string>> = {
  accessApplicationId: "access_application_id",
  resourceId: "resource_id",
  resourceType: "resource_type",
  resultInfo: "result_info",
  workerId: "worker_id",
  zoneId: "zone_id",
};

export class Forbidden
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<Forbidden>()("Forbidden", {
      code: S.Number,
      message: S.String,
    }),
    [{ status: 403 }],
  ) {}

export class TagPreconditionFailed
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<TagPreconditionFailed>()(
      "TagPreconditionFailed",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ status: 412 }],
  ) {}

export class ZoneTagResourceNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<ZoneTagResourceNotFound>()(
      "ZoneTagResourceNotFound",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ status: 404 }],
  ) {}

export interface DeleteAccountTagRequest {
  /** Identifier. */
  accountId: string;
  ifMatch?: string;
  /** Identifier of the resource to remove tags from. */
  resourceId?: string;
  /** Type of the resource to remove tags from. */
  resourceType?: string;
  /** Identifier of the Worker to remove tags from. */
  workerId?: string;
}
export const DeleteAccountTagRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    ifMatch: S.optional(S.String.pipe(T.Header("If-Match"))),
    resourceId: S.optional(S.String.pipe(T.Body("resource_id"))),
    resourceType: S.optional(S.String.pipe(T.Body("resource_type"))),
    workerId: S.optional(S.String.pipe(T.Body("worker_id"))),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/tags",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteAccountTagRequest",
}) as any as S.Schema<DeleteAccountTagRequest>;

export interface DeleteAccountTagResponse {}
export const DeleteAccountTagResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteAccountTagResponse",
}) as any as S.Schema<DeleteAccountTagResponse>;

export interface DeleteZoneTagRequest {
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
  ifMatch?: string;
  /** Identifier of the resource to remove tags from. */
  resourceId?: string;
  /** Type of the resource to remove tags from. */
  resourceType?: string;
  /** Identifier of the Access application to remove tags from. */
  accessApplicationId?: string;
}
export const DeleteZoneTagRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    ifMatch: S.optional(S.String.pipe(T.Header("If-Match"))),
    resourceId: S.optional(S.String.pipe(T.Body("resource_id"))),
    resourceType: S.optional(S.String.pipe(T.Body("resource_type"))),
    accessApplicationId: S.optional(
      S.String.pipe(T.Body("access_application_id")),
    ),
  })
    .pipe(T.Http({ method: "DELETE", uri: "/zones/{zone_id}/tags", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteZoneTagRequest",
}) as any as S.Schema<DeleteZoneTagRequest>;

export interface DeleteZoneTagResponse {}
export const DeleteZoneTagResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteZoneTagResponse",
}) as any as S.Schema<DeleteZoneTagResponse>;

export type AccountTagsGetRequestResourceType =
  | "access_application"
  | "access_group"
  | "account"
  | "ai_gateway"
  | "alerting_policy"
  | "alerting_webhook"
  | "cloudflared_tunnel"
  | "d1_database"
  | "durable_object_namespace"
  | "gateway_list"
  | "gateway_rule"
  | "image"
  | "kv_namespace"
  | "queue"
  | "r2_bucket"
  | "resource_share"
  | "stream_live_input"
  | "stream_video"
  | "worker"
  | "worker_version";
export const AccountTagsGetRequestResourceType = /*@__PURE__*/ S.String;

export interface GetAccountTagRequest {
  /** Identifier. */
  accountId: string;
  /** The ID of the resource to retrieve tags for. */
  resourceId: string;
  /** The type of the resource. */
  resourceType: AccountTagsGetRequestResourceType | (string & {});
  /** Worker identifier. Required for worker_version resources. */
  workerId?: string;
}
export const GetAccountTagRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    resourceId: S.String.pipe(T.Query("resource_id")),
    resourceType: AccountTagsGetRequestResourceType.pipe(
      T.Query("resource_type"),
    ),
    workerId: S.optional(S.String.pipe(T.Query("worker_id"))),
  })
    .pipe(
      T.Http({ method: "GET", uri: "/accounts/{account_id}/tags", code: 200 }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAccountTagRequest",
}) as any as S.Schema<GetAccountTagRequest>;

export type AccountTagsGetResultAccessApplicationTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultAccessApplicationTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsGetResultAccessApplicationTagsMap>;

export type AccountTagsGetResultAccessApplicationType = "access_application";
export const AccountTagsGetResultAccessApplicationType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultAccessApplication {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultAccessApplicationTagsMap;
  type: AccountTagsGetResultAccessApplicationType;
}
export const AccountTagsGetResultAccessApplication = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsGetResultAccessApplicationTagsMap,
      type: AccountTagsGetResultAccessApplicationType,
    }),
).annotate({
  identifier: "AccountTagsGetResultAccessApplication",
}) as any as S.Schema<AccountTagsGetResultAccessApplication>;

export type AccountTagsGetResultAccessApplicationPolicyTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultAccessApplicationPolicyTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsGetResultAccessApplicationPolicyTagsMap>;

export type AccountTagsGetResultAccessApplicationPolicyType =
  "access_application_policy";
export const AccountTagsGetResultAccessApplicationPolicyType =
  /*@__PURE__*/ S.String;

export interface AccountTagsGetResultAccessApplicationPolicy {
  /** Identifies the unique resource. */
  id: string;
  /** Access application ID is required only for access_application_policy resources */
  accessApplicationId: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultAccessApplicationPolicyTagsMap;
  type: AccountTagsGetResultAccessApplicationPolicyType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsGetResultAccessApplicationPolicy =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      accessApplicationId: S.String.pipe(T.Body("access_application_id")),
      etag: S.String,
      name: S.String,
      tags: AccountTagsGetResultAccessApplicationPolicyTagsMap,
      type: AccountTagsGetResultAccessApplicationPolicyType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
  ).annotate({
    identifier: "AccountTagsGetResultAccessApplicationPolicy",
  }) as any as S.Schema<AccountTagsGetResultAccessApplicationPolicy>;

export type AccountTagsGetResultAccessGroupTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultAccessGroupTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultAccessGroupTagsMap>;

export type AccountTagsGetResultAccessGroupType = "access_group";
export const AccountTagsGetResultAccessGroupType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultAccessGroup {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultAccessGroupTagsMap;
  type: AccountTagsGetResultAccessGroupType;
}
export const AccountTagsGetResultAccessGroup = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultAccessGroupTagsMap,
    type: AccountTagsGetResultAccessGroupType,
  }),
).annotate({
  identifier: "AccountTagsGetResultAccessGroup",
}) as any as S.Schema<AccountTagsGetResultAccessGroup>;

export type AccountTagsGetResultAccountTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultAccountTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultAccountTagsMap>;

export type AccountTagsGetResultAccountType = "account";
export const AccountTagsGetResultAccountType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultAccount {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultAccountTagsMap;
  type: AccountTagsGetResultAccountType;
}
export const AccountTagsGetResultAccount = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultAccountTagsMap,
    type: AccountTagsGetResultAccountType,
  }),
).annotate({
  identifier: "AccountTagsGetResultAccount",
}) as any as S.Schema<AccountTagsGetResultAccount>;

export type AccountTagsGetResultAIGatewayTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultAIGatewayTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultAIGatewayTagsMap>;

export type AccountTagsGetResultAIGatewayType = "ai_gateway";
export const AccountTagsGetResultAIGatewayType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultAIGateway {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultAIGatewayTagsMap;
  type: AccountTagsGetResultAIGatewayType;
}
export const AccountTagsGetResultAIGateway = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultAIGatewayTagsMap,
    type: AccountTagsGetResultAIGatewayType,
  }),
).annotate({
  identifier: "AccountTagsGetResultAIGateway",
}) as any as S.Schema<AccountTagsGetResultAIGateway>;

export type AccountTagsGetResultAlertingPolicyTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultAlertingPolicyTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultAlertingPolicyTagsMap>;

export type AccountTagsGetResultAlertingPolicyType = "alerting_policy";
export const AccountTagsGetResultAlertingPolicyType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultAlertingPolicy {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultAlertingPolicyTagsMap;
  type: AccountTagsGetResultAlertingPolicyType;
}
export const AccountTagsGetResultAlertingPolicy = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultAlertingPolicyTagsMap,
    type: AccountTagsGetResultAlertingPolicyType,
  }),
).annotate({
  identifier: "AccountTagsGetResultAlertingPolicy",
}) as any as S.Schema<AccountTagsGetResultAlertingPolicy>;

export type AccountTagsGetResultAlertingWebhookTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultAlertingWebhookTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsGetResultAlertingWebhookTagsMap>;

export type AccountTagsGetResultAlertingWebhookType = "alerting_webhook";
export const AccountTagsGetResultAlertingWebhookType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultAlertingWebhook {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultAlertingWebhookTagsMap;
  type: AccountTagsGetResultAlertingWebhookType;
}
export const AccountTagsGetResultAlertingWebhook = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultAlertingWebhookTagsMap,
    type: AccountTagsGetResultAlertingWebhookType,
  }),
).annotate({
  identifier: "AccountTagsGetResultAlertingWebhook",
}) as any as S.Schema<AccountTagsGetResultAlertingWebhook>;

export type AccountTagsGetResultAPIGatewayOperationTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultAPIGatewayOperationTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsGetResultAPIGatewayOperationTagsMap>;

export type AccountTagsGetResultAPIGatewayOperationType =
  "api_gateway_operation";
export const AccountTagsGetResultAPIGatewayOperationType =
  /*@__PURE__*/ S.String;

export interface AccountTagsGetResultAPIGatewayOperation {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultAPIGatewayOperationTagsMap;
  type: AccountTagsGetResultAPIGatewayOperationType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsGetResultAPIGatewayOperation = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsGetResultAPIGatewayOperationTagsMap,
      type: AccountTagsGetResultAPIGatewayOperationType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
).annotate({
  identifier: "AccountTagsGetResultAPIGatewayOperation",
}) as any as S.Schema<AccountTagsGetResultAPIGatewayOperation>;

export type AccountTagsGetResultCloudflaredTunnelTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultCloudflaredTunnelTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsGetResultCloudflaredTunnelTagsMap>;

export type AccountTagsGetResultCloudflaredTunnelType = "cloudflared_tunnel";
export const AccountTagsGetResultCloudflaredTunnelType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultCloudflaredTunnel {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultCloudflaredTunnelTagsMap;
  type: AccountTagsGetResultCloudflaredTunnelType;
}
export const AccountTagsGetResultCloudflaredTunnel = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsGetResultCloudflaredTunnelTagsMap,
      type: AccountTagsGetResultCloudflaredTunnelType,
    }),
).annotate({
  identifier: "AccountTagsGetResultCloudflaredTunnel",
}) as any as S.Schema<AccountTagsGetResultCloudflaredTunnel>;

export type AccountTagsGetResultCustomCertificateTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultCustomCertificateTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsGetResultCustomCertificateTagsMap>;

export type AccountTagsGetResultCustomCertificateType = "custom_certificate";
export const AccountTagsGetResultCustomCertificateType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultCustomCertificate {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultCustomCertificateTagsMap;
  type: AccountTagsGetResultCustomCertificateType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsGetResultCustomCertificate = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsGetResultCustomCertificateTagsMap,
      type: AccountTagsGetResultCustomCertificateType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
).annotate({
  identifier: "AccountTagsGetResultCustomCertificate",
}) as any as S.Schema<AccountTagsGetResultCustomCertificate>;

export type AccountTagsGetResultCustomHostnameTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultCustomHostnameTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultCustomHostnameTagsMap>;

export type AccountTagsGetResultCustomHostnameType = "custom_hostname";
export const AccountTagsGetResultCustomHostnameType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultCustomHostname {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultCustomHostnameTagsMap;
  type: AccountTagsGetResultCustomHostnameType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsGetResultCustomHostname = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultCustomHostnameTagsMap,
    type: AccountTagsGetResultCustomHostnameType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "AccountTagsGetResultCustomHostname",
}) as any as S.Schema<AccountTagsGetResultCustomHostname>;

export type AccountTagsGetResultD1DatabaseTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultD1DatabaseTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultD1DatabaseTagsMap>;

export type AccountTagsGetResultD1DatabaseType = "d1_database";
export const AccountTagsGetResultD1DatabaseType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultD1Database {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultD1DatabaseTagsMap;
  type: AccountTagsGetResultD1DatabaseType;
}
export const AccountTagsGetResultD1Database = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultD1DatabaseTagsMap,
    type: AccountTagsGetResultD1DatabaseType,
  }),
).annotate({
  identifier: "AccountTagsGetResultD1Database",
}) as any as S.Schema<AccountTagsGetResultD1Database>;

export type AccountTagsGetResultDNSRecordTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultDNSRecordTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultDNSRecordTagsMap>;

export type AccountTagsGetResultDNSRecordType = "dns_record";
export const AccountTagsGetResultDNSRecordType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultDNSRecord {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultDNSRecordTagsMap;
  type: AccountTagsGetResultDNSRecordType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsGetResultDNSRecord = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultDNSRecordTagsMap,
    type: AccountTagsGetResultDNSRecordType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "AccountTagsGetResultDNSRecord",
}) as any as S.Schema<AccountTagsGetResultDNSRecord>;

export type AccountTagsGetResultDurableObjectNamespaceTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultDurableObjectNamespaceTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsGetResultDurableObjectNamespaceTagsMap>;

export type AccountTagsGetResultDurableObjectNamespaceType =
  "durable_object_namespace";
export const AccountTagsGetResultDurableObjectNamespaceType =
  /*@__PURE__*/ S.String;

export interface AccountTagsGetResultDurableObjectNamespace {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultDurableObjectNamespaceTagsMap;
  type: AccountTagsGetResultDurableObjectNamespaceType;
}
export const AccountTagsGetResultDurableObjectNamespace =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsGetResultDurableObjectNamespaceTagsMap,
      type: AccountTagsGetResultDurableObjectNamespaceType,
    }),
  ).annotate({
    identifier: "AccountTagsGetResultDurableObjectNamespace",
  }) as any as S.Schema<AccountTagsGetResultDurableObjectNamespace>;

export type AccountTagsGetResultGatewayListTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultGatewayListTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultGatewayListTagsMap>;

export type AccountTagsGetResultGatewayListType = "gateway_list";
export const AccountTagsGetResultGatewayListType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultGatewayList {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultGatewayListTagsMap;
  type: AccountTagsGetResultGatewayListType;
}
export const AccountTagsGetResultGatewayList = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultGatewayListTagsMap,
    type: AccountTagsGetResultGatewayListType,
  }),
).annotate({
  identifier: "AccountTagsGetResultGatewayList",
}) as any as S.Schema<AccountTagsGetResultGatewayList>;

export type AccountTagsGetResultGatewayRuleTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultGatewayRuleTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultGatewayRuleTagsMap>;

export type AccountTagsGetResultGatewayRuleType = "gateway_rule";
export const AccountTagsGetResultGatewayRuleType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultGatewayRule {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultGatewayRuleTagsMap;
  type: AccountTagsGetResultGatewayRuleType;
}
export const AccountTagsGetResultGatewayRule = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultGatewayRuleTagsMap,
    type: AccountTagsGetResultGatewayRuleType,
  }),
).annotate({
  identifier: "AccountTagsGetResultGatewayRule",
}) as any as S.Schema<AccountTagsGetResultGatewayRule>;

export type AccountTagsGetResultImageTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultImageTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultImageTagsMap>;

export type AccountTagsGetResultImageType = "image";
export const AccountTagsGetResultImageType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultImage {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultImageTagsMap;
  type: AccountTagsGetResultImageType;
}
export const AccountTagsGetResultImage = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultImageTagsMap,
    type: AccountTagsGetResultImageType,
  }),
).annotate({
  identifier: "AccountTagsGetResultImage",
}) as any as S.Schema<AccountTagsGetResultImage>;

export type AccountTagsGetResultKVNamespaceTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultKVNamespaceTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultKVNamespaceTagsMap>;

export type AccountTagsGetResultKVNamespaceType = "kv_namespace";
export const AccountTagsGetResultKVNamespaceType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultKVNamespace {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultKVNamespaceTagsMap;
  type: AccountTagsGetResultKVNamespaceType;
}
export const AccountTagsGetResultKVNamespace = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultKVNamespaceTagsMap,
    type: AccountTagsGetResultKVNamespaceType,
  }),
).annotate({
  identifier: "AccountTagsGetResultKVNamespace",
}) as any as S.Schema<AccountTagsGetResultKVNamespace>;

export type AccountTagsGetResultManagedClientCertificateTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultManagedClientCertificateTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsGetResultManagedClientCertificateTagsMap>;

export type AccountTagsGetResultManagedClientCertificateType =
  "managed_client_certificate";
export const AccountTagsGetResultManagedClientCertificateType =
  /*@__PURE__*/ S.String;

export interface AccountTagsGetResultManagedClientCertificate {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultManagedClientCertificateTagsMap;
  type: AccountTagsGetResultManagedClientCertificateType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsGetResultManagedClientCertificate =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsGetResultManagedClientCertificateTagsMap,
      type: AccountTagsGetResultManagedClientCertificateType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
  ).annotate({
    identifier: "AccountTagsGetResultManagedClientCertificate",
  }) as any as S.Schema<AccountTagsGetResultManagedClientCertificate>;

export type AccountTagsGetResultQueueTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultQueueTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultQueueTagsMap>;

export type AccountTagsGetResultQueueType = "queue";
export const AccountTagsGetResultQueueType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultQueue {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultQueueTagsMap;
  type: AccountTagsGetResultQueueType;
}
export const AccountTagsGetResultQueue = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultQueueTagsMap,
    type: AccountTagsGetResultQueueType,
  }),
).annotate({
  identifier: "AccountTagsGetResultQueue",
}) as any as S.Schema<AccountTagsGetResultQueue>;

export type AccountTagsGetResultR2BucketTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultR2BucketTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultR2BucketTagsMap>;

export type AccountTagsGetResultR2BucketType = "r2_bucket";
export const AccountTagsGetResultR2BucketType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultR2Bucket {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultR2BucketTagsMap;
  type: AccountTagsGetResultR2BucketType;
}
export const AccountTagsGetResultR2Bucket = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultR2BucketTagsMap,
    type: AccountTagsGetResultR2BucketType,
  }),
).annotate({
  identifier: "AccountTagsGetResultR2Bucket",
}) as any as S.Schema<AccountTagsGetResultR2Bucket>;

export type AccountTagsGetResultResourceShareTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultResourceShareTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultResourceShareTagsMap>;

export type AccountTagsGetResultResourceShareType = "resource_share";
export const AccountTagsGetResultResourceShareType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultResourceShare {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultResourceShareTagsMap;
  type: AccountTagsGetResultResourceShareType;
}
export const AccountTagsGetResultResourceShare = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultResourceShareTagsMap,
    type: AccountTagsGetResultResourceShareType,
  }),
).annotate({
  identifier: "AccountTagsGetResultResourceShare",
}) as any as S.Schema<AccountTagsGetResultResourceShare>;

export type AccountTagsGetResultStreamLiveInputTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultStreamLiveInputTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsGetResultStreamLiveInputTagsMap>;

export type AccountTagsGetResultStreamLiveInputType = "stream_live_input";
export const AccountTagsGetResultStreamLiveInputType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultStreamLiveInput {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultStreamLiveInputTagsMap;
  type: AccountTagsGetResultStreamLiveInputType;
}
export const AccountTagsGetResultStreamLiveInput = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultStreamLiveInputTagsMap,
    type: AccountTagsGetResultStreamLiveInputType,
  }),
).annotate({
  identifier: "AccountTagsGetResultStreamLiveInput",
}) as any as S.Schema<AccountTagsGetResultStreamLiveInput>;

export type AccountTagsGetResultStreamVideoTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultStreamVideoTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultStreamVideoTagsMap>;

export type AccountTagsGetResultStreamVideoType = "stream_video";
export const AccountTagsGetResultStreamVideoType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultStreamVideo {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultStreamVideoTagsMap;
  type: AccountTagsGetResultStreamVideoType;
}
export const AccountTagsGetResultStreamVideo = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultStreamVideoTagsMap,
    type: AccountTagsGetResultStreamVideoType,
  }),
).annotate({
  identifier: "AccountTagsGetResultStreamVideo",
}) as any as S.Schema<AccountTagsGetResultStreamVideo>;

export type AccountTagsGetResultWorkerTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultWorkerTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultWorkerTagsMap>;

export type AccountTagsGetResultWorkerType = "worker";
export const AccountTagsGetResultWorkerType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultWorker {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultWorkerTagsMap;
  type: AccountTagsGetResultWorkerType;
}
export const AccountTagsGetResultWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultWorkerTagsMap,
    type: AccountTagsGetResultWorkerType,
  }),
).annotate({
  identifier: "AccountTagsGetResultWorker",
}) as any as S.Schema<AccountTagsGetResultWorker>;

export type AccountTagsGetResultWorkerVersionTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultWorkerVersionTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultWorkerVersionTagsMap>;

export type AccountTagsGetResultWorkerVersionType = "worker_version";
export const AccountTagsGetResultWorkerVersionType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultWorkerVersion {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultWorkerVersionTagsMap;
  type: AccountTagsGetResultWorkerVersionType;
  /** Worker ID is required only for worker_version resources */
  workerId: string;
}
export const AccountTagsGetResultWorkerVersion = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultWorkerVersionTagsMap,
    type: AccountTagsGetResultWorkerVersionType,
    workerId: S.String.pipe(T.Body("worker_id")),
  }),
).annotate({
  identifier: "AccountTagsGetResultWorkerVersion",
}) as any as S.Schema<AccountTagsGetResultWorkerVersion>;

export type AccountTagsGetResultZoneTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsGetResultZoneTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsGetResultZoneTagsMap>;

export type AccountTagsGetResultZoneType = "zone";
export const AccountTagsGetResultZoneType = /*@__PURE__*/ S.String;

export interface AccountTagsGetResultZone {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsGetResultZoneTagsMap;
  type: AccountTagsGetResultZoneType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsGetResultZone = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsGetResultZoneTagsMap,
    type: AccountTagsGetResultZoneType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "AccountTagsGetResultZone",
}) as any as S.Schema<AccountTagsGetResultZone>;

export type AccountTagsGetResult =
  | AccountTagsGetResultAccessApplication
  | AccountTagsGetResultAccessApplicationPolicy
  | AccountTagsGetResultAccessGroup
  | AccountTagsGetResultAccount
  | AccountTagsGetResultAIGateway
  | AccountTagsGetResultAlertingPolicy
  | AccountTagsGetResultAlertingWebhook
  | AccountTagsGetResultAPIGatewayOperation
  | AccountTagsGetResultCloudflaredTunnel
  | AccountTagsGetResultCustomCertificate
  | AccountTagsGetResultCustomHostname
  | AccountTagsGetResultD1Database
  | AccountTagsGetResultDNSRecord
  | AccountTagsGetResultDurableObjectNamespace
  | AccountTagsGetResultGatewayList
  | AccountTagsGetResultGatewayRule
  | AccountTagsGetResultImage
  | AccountTagsGetResultKVNamespace
  | AccountTagsGetResultManagedClientCertificate
  | AccountTagsGetResultQueue
  | AccountTagsGetResultR2Bucket
  | AccountTagsGetResultResourceShare
  | AccountTagsGetResultStreamLiveInput
  | AccountTagsGetResultStreamVideo
  | AccountTagsGetResultWorker
  | AccountTagsGetResultWorkerVersion
  | AccountTagsGetResultZone;
export const AccountTagsGetResult = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["id", "etag", "name", "tags", "type"],
    ["id", "accessApplicationId", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "workerId"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
  ]),
);

export type GetAccountTagResponse = AccountTagsGetResult;
export const GetAccountTagResponse = /*@__PURE__*/ S.suspend(() =>
  AccountTagsGetResult.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "GetAccountTagResponse",
}) as any as S.Schema<GetAccountTagResponse>;

export type ZoneTagsGetRequestResourceType =
  | "access_application_policy"
  | "api_gateway_operation"
  | "custom_certificate"
  | "custom_hostname"
  | "dns_record"
  | "managed_client_certificate"
  | "zone";
export const ZoneTagsGetRequestResourceType = /*@__PURE__*/ S.String;

export interface GetZoneTagRequest {
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
  /** The ID of the resource to retrieve tags for. */
  resourceId: string;
  /** The type of the resource. */
  resourceType: ZoneTagsGetRequestResourceType | (string & {});
  /** Access application ID identifier. Required for access_application_policy resources. */
  accessApplicationId?: string;
}
export const GetZoneTagRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    resourceId: S.String.pipe(T.Query("resource_id")),
    resourceType: ZoneTagsGetRequestResourceType.pipe(T.Query("resource_type")),
    accessApplicationId: S.optional(
      S.String.pipe(T.Query("access_application_id")),
    ),
  })
    .pipe(T.Http({ method: "GET", uri: "/zones/{zone_id}/tags", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetZoneTagRequest",
}) as any as S.Schema<GetZoneTagRequest>;

export type ZoneTagsGetResultAccessApplicationTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultAccessApplicationTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultAccessApplicationTagsMap>;

export type ZoneTagsGetResultAccessApplicationType = "access_application";
export const ZoneTagsGetResultAccessApplicationType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultAccessApplication {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultAccessApplicationTagsMap;
  type: ZoneTagsGetResultAccessApplicationType;
}
export const ZoneTagsGetResultAccessApplication = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultAccessApplicationTagsMap,
    type: ZoneTagsGetResultAccessApplicationType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultAccessApplication",
}) as any as S.Schema<ZoneTagsGetResultAccessApplication>;

export type ZoneTagsGetResultAccessApplicationPolicyTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultAccessApplicationPolicyTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ZoneTagsGetResultAccessApplicationPolicyTagsMap>;

export type ZoneTagsGetResultAccessApplicationPolicyType =
  "access_application_policy";
export const ZoneTagsGetResultAccessApplicationPolicyType =
  /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultAccessApplicationPolicy {
  /** Identifies the unique resource. */
  id: string;
  /** Access application ID is required only for access_application_policy resources */
  accessApplicationId: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultAccessApplicationPolicyTagsMap;
  type: ZoneTagsGetResultAccessApplicationPolicyType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsGetResultAccessApplicationPolicy = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      accessApplicationId: S.String.pipe(T.Body("access_application_id")),
      etag: S.String,
      name: S.String,
      tags: ZoneTagsGetResultAccessApplicationPolicyTagsMap,
      type: ZoneTagsGetResultAccessApplicationPolicyType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
).annotate({
  identifier: "ZoneTagsGetResultAccessApplicationPolicy",
}) as any as S.Schema<ZoneTagsGetResultAccessApplicationPolicy>;

export type ZoneTagsGetResultAccessGroupTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultAccessGroupTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultAccessGroupTagsMap>;

export type ZoneTagsGetResultAccessGroupType = "access_group";
export const ZoneTagsGetResultAccessGroupType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultAccessGroup {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultAccessGroupTagsMap;
  type: ZoneTagsGetResultAccessGroupType;
}
export const ZoneTagsGetResultAccessGroup = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultAccessGroupTagsMap,
    type: ZoneTagsGetResultAccessGroupType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultAccessGroup",
}) as any as S.Schema<ZoneTagsGetResultAccessGroup>;

export type ZoneTagsGetResultAccountTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultAccountTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultAccountTagsMap>;

export type ZoneTagsGetResultAccountType = "account";
export const ZoneTagsGetResultAccountType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultAccount {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultAccountTagsMap;
  type: ZoneTagsGetResultAccountType;
}
export const ZoneTagsGetResultAccount = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultAccountTagsMap,
    type: ZoneTagsGetResultAccountType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultAccount",
}) as any as S.Schema<ZoneTagsGetResultAccount>;

export type ZoneTagsGetResultAIGatewayTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultAIGatewayTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultAIGatewayTagsMap>;

export type ZoneTagsGetResultAIGatewayType = "ai_gateway";
export const ZoneTagsGetResultAIGatewayType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultAIGateway {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultAIGatewayTagsMap;
  type: ZoneTagsGetResultAIGatewayType;
}
export const ZoneTagsGetResultAIGateway = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultAIGatewayTagsMap,
    type: ZoneTagsGetResultAIGatewayType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultAIGateway",
}) as any as S.Schema<ZoneTagsGetResultAIGateway>;

export type ZoneTagsGetResultAlertingPolicyTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultAlertingPolicyTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultAlertingPolicyTagsMap>;

export type ZoneTagsGetResultAlertingPolicyType = "alerting_policy";
export const ZoneTagsGetResultAlertingPolicyType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultAlertingPolicy {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultAlertingPolicyTagsMap;
  type: ZoneTagsGetResultAlertingPolicyType;
}
export const ZoneTagsGetResultAlertingPolicy = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultAlertingPolicyTagsMap,
    type: ZoneTagsGetResultAlertingPolicyType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultAlertingPolicy",
}) as any as S.Schema<ZoneTagsGetResultAlertingPolicy>;

export type ZoneTagsGetResultAlertingWebhookTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultAlertingWebhookTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultAlertingWebhookTagsMap>;

export type ZoneTagsGetResultAlertingWebhookType = "alerting_webhook";
export const ZoneTagsGetResultAlertingWebhookType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultAlertingWebhook {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultAlertingWebhookTagsMap;
  type: ZoneTagsGetResultAlertingWebhookType;
}
export const ZoneTagsGetResultAlertingWebhook = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultAlertingWebhookTagsMap,
    type: ZoneTagsGetResultAlertingWebhookType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultAlertingWebhook",
}) as any as S.Schema<ZoneTagsGetResultAlertingWebhook>;

export type ZoneTagsGetResultAPIGatewayOperationTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultAPIGatewayOperationTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ZoneTagsGetResultAPIGatewayOperationTagsMap>;

export type ZoneTagsGetResultAPIGatewayOperationType = "api_gateway_operation";
export const ZoneTagsGetResultAPIGatewayOperationType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultAPIGatewayOperation {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultAPIGatewayOperationTagsMap;
  type: ZoneTagsGetResultAPIGatewayOperationType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsGetResultAPIGatewayOperation = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: ZoneTagsGetResultAPIGatewayOperationTagsMap,
      type: ZoneTagsGetResultAPIGatewayOperationType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
).annotate({
  identifier: "ZoneTagsGetResultAPIGatewayOperation",
}) as any as S.Schema<ZoneTagsGetResultAPIGatewayOperation>;

export type ZoneTagsGetResultCloudflaredTunnelTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultCloudflaredTunnelTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultCloudflaredTunnelTagsMap>;

export type ZoneTagsGetResultCloudflaredTunnelType = "cloudflared_tunnel";
export const ZoneTagsGetResultCloudflaredTunnelType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultCloudflaredTunnel {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultCloudflaredTunnelTagsMap;
  type: ZoneTagsGetResultCloudflaredTunnelType;
}
export const ZoneTagsGetResultCloudflaredTunnel = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultCloudflaredTunnelTagsMap,
    type: ZoneTagsGetResultCloudflaredTunnelType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultCloudflaredTunnel",
}) as any as S.Schema<ZoneTagsGetResultCloudflaredTunnel>;

export type ZoneTagsGetResultCustomCertificateTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultCustomCertificateTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultCustomCertificateTagsMap>;

export type ZoneTagsGetResultCustomCertificateType = "custom_certificate";
export const ZoneTagsGetResultCustomCertificateType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultCustomCertificate {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultCustomCertificateTagsMap;
  type: ZoneTagsGetResultCustomCertificateType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsGetResultCustomCertificate = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultCustomCertificateTagsMap,
    type: ZoneTagsGetResultCustomCertificateType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "ZoneTagsGetResultCustomCertificate",
}) as any as S.Schema<ZoneTagsGetResultCustomCertificate>;

export type ZoneTagsGetResultCustomHostnameTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultCustomHostnameTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultCustomHostnameTagsMap>;

export type ZoneTagsGetResultCustomHostnameType = "custom_hostname";
export const ZoneTagsGetResultCustomHostnameType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultCustomHostname {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultCustomHostnameTagsMap;
  type: ZoneTagsGetResultCustomHostnameType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsGetResultCustomHostname = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultCustomHostnameTagsMap,
    type: ZoneTagsGetResultCustomHostnameType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "ZoneTagsGetResultCustomHostname",
}) as any as S.Schema<ZoneTagsGetResultCustomHostname>;

export type ZoneTagsGetResultD1DatabaseTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultD1DatabaseTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultD1DatabaseTagsMap>;

export type ZoneTagsGetResultD1DatabaseType = "d1_database";
export const ZoneTagsGetResultD1DatabaseType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultD1Database {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultD1DatabaseTagsMap;
  type: ZoneTagsGetResultD1DatabaseType;
}
export const ZoneTagsGetResultD1Database = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultD1DatabaseTagsMap,
    type: ZoneTagsGetResultD1DatabaseType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultD1Database",
}) as any as S.Schema<ZoneTagsGetResultD1Database>;

export type ZoneTagsGetResultDNSRecordTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultDNSRecordTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultDNSRecordTagsMap>;

export type ZoneTagsGetResultDNSRecordType = "dns_record";
export const ZoneTagsGetResultDNSRecordType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultDNSRecord {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultDNSRecordTagsMap;
  type: ZoneTagsGetResultDNSRecordType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsGetResultDNSRecord = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultDNSRecordTagsMap,
    type: ZoneTagsGetResultDNSRecordType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "ZoneTagsGetResultDNSRecord",
}) as any as S.Schema<ZoneTagsGetResultDNSRecord>;

export type ZoneTagsGetResultDurableObjectNamespaceTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultDurableObjectNamespaceTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ZoneTagsGetResultDurableObjectNamespaceTagsMap>;

export type ZoneTagsGetResultDurableObjectNamespaceType =
  "durable_object_namespace";
export const ZoneTagsGetResultDurableObjectNamespaceType =
  /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultDurableObjectNamespace {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultDurableObjectNamespaceTagsMap;
  type: ZoneTagsGetResultDurableObjectNamespaceType;
}
export const ZoneTagsGetResultDurableObjectNamespace = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: ZoneTagsGetResultDurableObjectNamespaceTagsMap,
      type: ZoneTagsGetResultDurableObjectNamespaceType,
    }),
).annotate({
  identifier: "ZoneTagsGetResultDurableObjectNamespace",
}) as any as S.Schema<ZoneTagsGetResultDurableObjectNamespace>;

export type ZoneTagsGetResultGatewayListTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultGatewayListTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultGatewayListTagsMap>;

export type ZoneTagsGetResultGatewayListType = "gateway_list";
export const ZoneTagsGetResultGatewayListType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultGatewayList {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultGatewayListTagsMap;
  type: ZoneTagsGetResultGatewayListType;
}
export const ZoneTagsGetResultGatewayList = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultGatewayListTagsMap,
    type: ZoneTagsGetResultGatewayListType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultGatewayList",
}) as any as S.Schema<ZoneTagsGetResultGatewayList>;

export type ZoneTagsGetResultGatewayRuleTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultGatewayRuleTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultGatewayRuleTagsMap>;

export type ZoneTagsGetResultGatewayRuleType = "gateway_rule";
export const ZoneTagsGetResultGatewayRuleType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultGatewayRule {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultGatewayRuleTagsMap;
  type: ZoneTagsGetResultGatewayRuleType;
}
export const ZoneTagsGetResultGatewayRule = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultGatewayRuleTagsMap,
    type: ZoneTagsGetResultGatewayRuleType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultGatewayRule",
}) as any as S.Schema<ZoneTagsGetResultGatewayRule>;

export type ZoneTagsGetResultImageTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultImageTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultImageTagsMap>;

export type ZoneTagsGetResultImageType = "image";
export const ZoneTagsGetResultImageType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultImage {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultImageTagsMap;
  type: ZoneTagsGetResultImageType;
}
export const ZoneTagsGetResultImage = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultImageTagsMap,
    type: ZoneTagsGetResultImageType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultImage",
}) as any as S.Schema<ZoneTagsGetResultImage>;

export type ZoneTagsGetResultKVNamespaceTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultKVNamespaceTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultKVNamespaceTagsMap>;

export type ZoneTagsGetResultKVNamespaceType = "kv_namespace";
export const ZoneTagsGetResultKVNamespaceType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultKVNamespace {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultKVNamespaceTagsMap;
  type: ZoneTagsGetResultKVNamespaceType;
}
export const ZoneTagsGetResultKVNamespace = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultKVNamespaceTagsMap,
    type: ZoneTagsGetResultKVNamespaceType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultKVNamespace",
}) as any as S.Schema<ZoneTagsGetResultKVNamespace>;

export type ZoneTagsGetResultManagedClientCertificateTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultManagedClientCertificateTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ZoneTagsGetResultManagedClientCertificateTagsMap>;

export type ZoneTagsGetResultManagedClientCertificateType =
  "managed_client_certificate";
export const ZoneTagsGetResultManagedClientCertificateType =
  /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultManagedClientCertificate {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultManagedClientCertificateTagsMap;
  type: ZoneTagsGetResultManagedClientCertificateType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsGetResultManagedClientCertificate =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: ZoneTagsGetResultManagedClientCertificateTagsMap,
      type: ZoneTagsGetResultManagedClientCertificateType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
  ).annotate({
    identifier: "ZoneTagsGetResultManagedClientCertificate",
  }) as any as S.Schema<ZoneTagsGetResultManagedClientCertificate>;

export type ZoneTagsGetResultQueueTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultQueueTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultQueueTagsMap>;

export type ZoneTagsGetResultQueueType = "queue";
export const ZoneTagsGetResultQueueType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultQueue {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultQueueTagsMap;
  type: ZoneTagsGetResultQueueType;
}
export const ZoneTagsGetResultQueue = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultQueueTagsMap,
    type: ZoneTagsGetResultQueueType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultQueue",
}) as any as S.Schema<ZoneTagsGetResultQueue>;

export type ZoneTagsGetResultR2BucketTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultR2BucketTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultR2BucketTagsMap>;

export type ZoneTagsGetResultR2BucketType = "r2_bucket";
export const ZoneTagsGetResultR2BucketType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultR2Bucket {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultR2BucketTagsMap;
  type: ZoneTagsGetResultR2BucketType;
}
export const ZoneTagsGetResultR2Bucket = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultR2BucketTagsMap,
    type: ZoneTagsGetResultR2BucketType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultR2Bucket",
}) as any as S.Schema<ZoneTagsGetResultR2Bucket>;

export type ZoneTagsGetResultResourceShareTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultResourceShareTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultResourceShareTagsMap>;

export type ZoneTagsGetResultResourceShareType = "resource_share";
export const ZoneTagsGetResultResourceShareType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultResourceShare {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultResourceShareTagsMap;
  type: ZoneTagsGetResultResourceShareType;
}
export const ZoneTagsGetResultResourceShare = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultResourceShareTagsMap,
    type: ZoneTagsGetResultResourceShareType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultResourceShare",
}) as any as S.Schema<ZoneTagsGetResultResourceShare>;

export type ZoneTagsGetResultStreamLiveInputTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultStreamLiveInputTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultStreamLiveInputTagsMap>;

export type ZoneTagsGetResultStreamLiveInputType = "stream_live_input";
export const ZoneTagsGetResultStreamLiveInputType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultStreamLiveInput {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultStreamLiveInputTagsMap;
  type: ZoneTagsGetResultStreamLiveInputType;
}
export const ZoneTagsGetResultStreamLiveInput = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultStreamLiveInputTagsMap,
    type: ZoneTagsGetResultStreamLiveInputType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultStreamLiveInput",
}) as any as S.Schema<ZoneTagsGetResultStreamLiveInput>;

export type ZoneTagsGetResultStreamVideoTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultStreamVideoTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultStreamVideoTagsMap>;

export type ZoneTagsGetResultStreamVideoType = "stream_video";
export const ZoneTagsGetResultStreamVideoType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultStreamVideo {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultStreamVideoTagsMap;
  type: ZoneTagsGetResultStreamVideoType;
}
export const ZoneTagsGetResultStreamVideo = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultStreamVideoTagsMap,
    type: ZoneTagsGetResultStreamVideoType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultStreamVideo",
}) as any as S.Schema<ZoneTagsGetResultStreamVideo>;

export type ZoneTagsGetResultWorkerTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultWorkerTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultWorkerTagsMap>;

export type ZoneTagsGetResultWorkerType = "worker";
export const ZoneTagsGetResultWorkerType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultWorker {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultWorkerTagsMap;
  type: ZoneTagsGetResultWorkerType;
}
export const ZoneTagsGetResultWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultWorkerTagsMap,
    type: ZoneTagsGetResultWorkerType,
  }),
).annotate({
  identifier: "ZoneTagsGetResultWorker",
}) as any as S.Schema<ZoneTagsGetResultWorker>;

export type ZoneTagsGetResultWorkerVersionTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultWorkerVersionTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultWorkerVersionTagsMap>;

export type ZoneTagsGetResultWorkerVersionType = "worker_version";
export const ZoneTagsGetResultWorkerVersionType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultWorkerVersion {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultWorkerVersionTagsMap;
  type: ZoneTagsGetResultWorkerVersionType;
  /** Worker ID is required only for worker_version resources */
  workerId: string;
}
export const ZoneTagsGetResultWorkerVersion = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultWorkerVersionTagsMap,
    type: ZoneTagsGetResultWorkerVersionType,
    workerId: S.String.pipe(T.Body("worker_id")),
  }),
).annotate({
  identifier: "ZoneTagsGetResultWorkerVersion",
}) as any as S.Schema<ZoneTagsGetResultWorkerVersion>;

export type ZoneTagsGetResultZoneTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsGetResultZoneTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsGetResultZoneTagsMap>;

export type ZoneTagsGetResultZoneType = "zone";
export const ZoneTagsGetResultZoneType = /*@__PURE__*/ S.String;

export interface ZoneTagsGetResultZone {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsGetResultZoneTagsMap;
  type: ZoneTagsGetResultZoneType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsGetResultZone = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsGetResultZoneTagsMap,
    type: ZoneTagsGetResultZoneType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "ZoneTagsGetResultZone",
}) as any as S.Schema<ZoneTagsGetResultZone>;

export type ZoneTagsGetResult =
  | ZoneTagsGetResultAccessApplication
  | ZoneTagsGetResultAccessApplicationPolicy
  | ZoneTagsGetResultAccessGroup
  | ZoneTagsGetResultAccount
  | ZoneTagsGetResultAIGateway
  | ZoneTagsGetResultAlertingPolicy
  | ZoneTagsGetResultAlertingWebhook
  | ZoneTagsGetResultAPIGatewayOperation
  | ZoneTagsGetResultCloudflaredTunnel
  | ZoneTagsGetResultCustomCertificate
  | ZoneTagsGetResultCustomHostname
  | ZoneTagsGetResultD1Database
  | ZoneTagsGetResultDNSRecord
  | ZoneTagsGetResultDurableObjectNamespace
  | ZoneTagsGetResultGatewayList
  | ZoneTagsGetResultGatewayRule
  | ZoneTagsGetResultImage
  | ZoneTagsGetResultKVNamespace
  | ZoneTagsGetResultManagedClientCertificate
  | ZoneTagsGetResultQueue
  | ZoneTagsGetResultR2Bucket
  | ZoneTagsGetResultResourceShare
  | ZoneTagsGetResultStreamLiveInput
  | ZoneTagsGetResultStreamVideo
  | ZoneTagsGetResultWorker
  | ZoneTagsGetResultWorkerVersion
  | ZoneTagsGetResultZone;
export const ZoneTagsGetResult = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["id", "etag", "name", "tags", "type"],
    ["id", "accessApplicationId", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "workerId"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
  ]),
);

export type GetZoneTagResponse = ZoneTagsGetResult;
export const GetZoneTagResponse = /*@__PURE__*/ S.suspend(() =>
  ZoneTagsGetResult.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "GetZoneTagResponse",
}) as any as S.Schema<GetZoneTagResponse>;

export interface ListKeysRequest {
  /** Identifier. */
  accountId: string;
  /** Cursor for pagination. */
  cursor?: string;
}
export const ListKeysRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cursor: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/tags/keys",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListKeysRequest",
}) as any as S.Schema<ListKeysRequest>;

export type KeysListResultList = Array<string>;
export const KeysListResultList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<KeysListResultList>;

export interface ListKeysResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: KeysListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListKeysResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: KeysListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListKeysResponse",
}) as any as S.Schema<ListKeysResponse>;

export type ListRequestTagList = Array<string>;
export const ListRequestTagList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<ListRequestTagList>;

export type ListRequestType =
  | "access_application"
  | "access_application_policy"
  | "access_group"
  | "account"
  | "ai_gateway"
  | "alerting_policy"
  | "alerting_webhook"
  | "api_gateway_operation"
  | "cloudflared_tunnel"
  | "custom_certificate"
  | "custom_hostname"
  | "d1_database"
  | "dns_record"
  | "durable_object_namespace"
  | "gateway_list"
  | "gateway_rule"
  | "image"
  | "kv_namespace"
  | "managed_client_certificate"
  | "queue"
  | "r2_bucket"
  | "resource_share"
  | "stream_live_input"
  | "stream_video"
  | "worker"
  | "worker_version"
  | "zone";
export const ListRequestType = /*@__PURE__*/ S.String;

export type ListRequestTypeList = Array<ListRequestType | (string & {})>;
export const ListRequestTypeList = /*@__PURE__*/ S.Array(
  ListRequestType,
) as any as S.Schema<ListRequestTypeList>;

export interface ListResourceTaggingsRequest {
  /** Identifier. */
  accountId: string;
  /** Cursor for pagination. */
  cursor?: string;
  /** Filter resources by tag criteria. This parameter can be repeated multiple times, with AND logic between parameters. */
  tag?: ListRequestTagList;
  /** Filter by resource type. Can be repeated to filter by multiple types (OR logic). Example: ?type=zone&type=worker */
  type?: ListRequestTypeList;
}
export const ListResourceTaggingsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cursor: S.optional(S.String.pipe(T.Query())),
    tag: S.optional(ListRequestTagList.pipe(T.Query())),
    type: S.optional(ListRequestTypeList.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/tags/resources",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListResourceTaggingsRequest",
}) as any as S.Schema<ListResourceTaggingsRequest>;

export type ListResultItemAccessApplicationTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemAccessApplicationTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemAccessApplicationTagsMap>;

export type ListResultItemAccessApplicationType = "access_application";
export const ListResultItemAccessApplicationType = /*@__PURE__*/ S.String;

export interface ListResultItemAccessApplication {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemAccessApplicationTagsMap;
  type: ListResultItemAccessApplicationType;
}
export const ListResultItemAccessApplication = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemAccessApplicationTagsMap,
    type: ListResultItemAccessApplicationType,
  }),
).annotate({
  identifier: "ListResultItemAccessApplication",
}) as any as S.Schema<ListResultItemAccessApplication>;

export type ListResultItemAccessApplicationPolicyTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemAccessApplicationPolicyTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ListResultItemAccessApplicationPolicyTagsMap>;

export type ListResultItemAccessApplicationPolicyType =
  "access_application_policy";
export const ListResultItemAccessApplicationPolicyType = /*@__PURE__*/ S.String;

export interface ListResultItemAccessApplicationPolicy {
  /** Identifies the unique resource. */
  id: string;
  /** Access application ID is required only for access_application_policy resources */
  accessApplicationId: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemAccessApplicationPolicyTagsMap;
  type: ListResultItemAccessApplicationPolicyType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ListResultItemAccessApplicationPolicy = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      accessApplicationId: S.String.pipe(T.Body("access_application_id")),
      etag: S.String,
      name: S.String,
      tags: ListResultItemAccessApplicationPolicyTagsMap,
      type: ListResultItemAccessApplicationPolicyType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
).annotate({
  identifier: "ListResultItemAccessApplicationPolicy",
}) as any as S.Schema<ListResultItemAccessApplicationPolicy>;

export type ListResultItemAccessGroupTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemAccessGroupTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemAccessGroupTagsMap>;

export type ListResultItemAccessGroupType = "access_group";
export const ListResultItemAccessGroupType = /*@__PURE__*/ S.String;

export interface ListResultItemAccessGroup {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemAccessGroupTagsMap;
  type: ListResultItemAccessGroupType;
}
export const ListResultItemAccessGroup = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemAccessGroupTagsMap,
    type: ListResultItemAccessGroupType,
  }),
).annotate({
  identifier: "ListResultItemAccessGroup",
}) as any as S.Schema<ListResultItemAccessGroup>;

export type ListResultItemAccountTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemAccountTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemAccountTagsMap>;

export type ListResultItemAccountType = "account";
export const ListResultItemAccountType = /*@__PURE__*/ S.String;

export interface ListResultItemAccount {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemAccountTagsMap;
  type: ListResultItemAccountType;
}
export const ListResultItemAccount = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemAccountTagsMap,
    type: ListResultItemAccountType,
  }),
).annotate({
  identifier: "ListResultItemAccount",
}) as any as S.Schema<ListResultItemAccount>;

export type ListResultItemAIGatewayTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemAIGatewayTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemAIGatewayTagsMap>;

export type ListResultItemAIGatewayType = "ai_gateway";
export const ListResultItemAIGatewayType = /*@__PURE__*/ S.String;

export interface ListResultItemAIGateway {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemAIGatewayTagsMap;
  type: ListResultItemAIGatewayType;
}
export const ListResultItemAIGateway = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemAIGatewayTagsMap,
    type: ListResultItemAIGatewayType,
  }),
).annotate({
  identifier: "ListResultItemAIGateway",
}) as any as S.Schema<ListResultItemAIGateway>;

export type ListResultItemAlertingPolicyTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemAlertingPolicyTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemAlertingPolicyTagsMap>;

export type ListResultItemAlertingPolicyType = "alerting_policy";
export const ListResultItemAlertingPolicyType = /*@__PURE__*/ S.String;

export interface ListResultItemAlertingPolicy {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemAlertingPolicyTagsMap;
  type: ListResultItemAlertingPolicyType;
}
export const ListResultItemAlertingPolicy = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemAlertingPolicyTagsMap,
    type: ListResultItemAlertingPolicyType,
  }),
).annotate({
  identifier: "ListResultItemAlertingPolicy",
}) as any as S.Schema<ListResultItemAlertingPolicy>;

export type ListResultItemAlertingWebhookTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemAlertingWebhookTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemAlertingWebhookTagsMap>;

export type ListResultItemAlertingWebhookType = "alerting_webhook";
export const ListResultItemAlertingWebhookType = /*@__PURE__*/ S.String;

export interface ListResultItemAlertingWebhook {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemAlertingWebhookTagsMap;
  type: ListResultItemAlertingWebhookType;
}
export const ListResultItemAlertingWebhook = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemAlertingWebhookTagsMap,
    type: ListResultItemAlertingWebhookType,
  }),
).annotate({
  identifier: "ListResultItemAlertingWebhook",
}) as any as S.Schema<ListResultItemAlertingWebhook>;

export type ListResultItemAPIGatewayOperationTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemAPIGatewayOperationTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemAPIGatewayOperationTagsMap>;

export type ListResultItemAPIGatewayOperationType = "api_gateway_operation";
export const ListResultItemAPIGatewayOperationType = /*@__PURE__*/ S.String;

export interface ListResultItemAPIGatewayOperation {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemAPIGatewayOperationTagsMap;
  type: ListResultItemAPIGatewayOperationType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ListResultItemAPIGatewayOperation = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemAPIGatewayOperationTagsMap,
    type: ListResultItemAPIGatewayOperationType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "ListResultItemAPIGatewayOperation",
}) as any as S.Schema<ListResultItemAPIGatewayOperation>;

export type ListResultItemCloudflaredTunnelTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemCloudflaredTunnelTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemCloudflaredTunnelTagsMap>;

export type ListResultItemCloudflaredTunnelType = "cloudflared_tunnel";
export const ListResultItemCloudflaredTunnelType = /*@__PURE__*/ S.String;

export interface ListResultItemCloudflaredTunnel {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemCloudflaredTunnelTagsMap;
  type: ListResultItemCloudflaredTunnelType;
}
export const ListResultItemCloudflaredTunnel = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemCloudflaredTunnelTagsMap,
    type: ListResultItemCloudflaredTunnelType,
  }),
).annotate({
  identifier: "ListResultItemCloudflaredTunnel",
}) as any as S.Schema<ListResultItemCloudflaredTunnel>;

export type ListResultItemCustomCertificateTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemCustomCertificateTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemCustomCertificateTagsMap>;

export type ListResultItemCustomCertificateType = "custom_certificate";
export const ListResultItemCustomCertificateType = /*@__PURE__*/ S.String;

export interface ListResultItemCustomCertificate {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemCustomCertificateTagsMap;
  type: ListResultItemCustomCertificateType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ListResultItemCustomCertificate = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemCustomCertificateTagsMap,
    type: ListResultItemCustomCertificateType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "ListResultItemCustomCertificate",
}) as any as S.Schema<ListResultItemCustomCertificate>;

export type ListResultItemCustomHostnameTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemCustomHostnameTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemCustomHostnameTagsMap>;

export type ListResultItemCustomHostnameType = "custom_hostname";
export const ListResultItemCustomHostnameType = /*@__PURE__*/ S.String;

export interface ListResultItemCustomHostname {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemCustomHostnameTagsMap;
  type: ListResultItemCustomHostnameType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ListResultItemCustomHostname = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemCustomHostnameTagsMap,
    type: ListResultItemCustomHostnameType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "ListResultItemCustomHostname",
}) as any as S.Schema<ListResultItemCustomHostname>;

export type ListResultItemD1DatabaseTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemD1DatabaseTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemD1DatabaseTagsMap>;

export type ListResultItemD1DatabaseType = "d1_database";
export const ListResultItemD1DatabaseType = /*@__PURE__*/ S.String;

export interface ListResultItemD1Database {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemD1DatabaseTagsMap;
  type: ListResultItemD1DatabaseType;
}
export const ListResultItemD1Database = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemD1DatabaseTagsMap,
    type: ListResultItemD1DatabaseType,
  }),
).annotate({
  identifier: "ListResultItemD1Database",
}) as any as S.Schema<ListResultItemD1Database>;

export type ListResultItemDNSRecordTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemDNSRecordTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemDNSRecordTagsMap>;

export type ListResultItemDNSRecordType = "dns_record";
export const ListResultItemDNSRecordType = /*@__PURE__*/ S.String;

export interface ListResultItemDNSRecord {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemDNSRecordTagsMap;
  type: ListResultItemDNSRecordType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ListResultItemDNSRecord = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemDNSRecordTagsMap,
    type: ListResultItemDNSRecordType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "ListResultItemDNSRecord",
}) as any as S.Schema<ListResultItemDNSRecord>;

export type ListResultItemDurableObjectNamespaceTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemDurableObjectNamespaceTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ListResultItemDurableObjectNamespaceTagsMap>;

export type ListResultItemDurableObjectNamespaceType =
  "durable_object_namespace";
export const ListResultItemDurableObjectNamespaceType = /*@__PURE__*/ S.String;

export interface ListResultItemDurableObjectNamespace {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemDurableObjectNamespaceTagsMap;
  type: ListResultItemDurableObjectNamespaceType;
}
export const ListResultItemDurableObjectNamespace = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: ListResultItemDurableObjectNamespaceTagsMap,
      type: ListResultItemDurableObjectNamespaceType,
    }),
).annotate({
  identifier: "ListResultItemDurableObjectNamespace",
}) as any as S.Schema<ListResultItemDurableObjectNamespace>;

export type ListResultItemGatewayListTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemGatewayListTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemGatewayListTagsMap>;

export type ListResultItemGatewayListType = "gateway_list";
export const ListResultItemGatewayListType = /*@__PURE__*/ S.String;

export interface ListResultItemGatewayList {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemGatewayListTagsMap;
  type: ListResultItemGatewayListType;
}
export const ListResultItemGatewayList = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemGatewayListTagsMap,
    type: ListResultItemGatewayListType,
  }),
).annotate({
  identifier: "ListResultItemGatewayList",
}) as any as S.Schema<ListResultItemGatewayList>;

export type ListResultItemGatewayRuleTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemGatewayRuleTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemGatewayRuleTagsMap>;

export type ListResultItemGatewayRuleType = "gateway_rule";
export const ListResultItemGatewayRuleType = /*@__PURE__*/ S.String;

export interface ListResultItemGatewayRule {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemGatewayRuleTagsMap;
  type: ListResultItemGatewayRuleType;
}
export const ListResultItemGatewayRule = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemGatewayRuleTagsMap,
    type: ListResultItemGatewayRuleType,
  }),
).annotate({
  identifier: "ListResultItemGatewayRule",
}) as any as S.Schema<ListResultItemGatewayRule>;

export type ListResultItemImageTagsMap = { [key: string]: string | undefined };
export const ListResultItemImageTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemImageTagsMap>;

export type ListResultItemImageType = "image";
export const ListResultItemImageType = /*@__PURE__*/ S.String;

export interface ListResultItemImage {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemImageTagsMap;
  type: ListResultItemImageType;
}
export const ListResultItemImage = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemImageTagsMap,
    type: ListResultItemImageType,
  }),
).annotate({
  identifier: "ListResultItemImage",
}) as any as S.Schema<ListResultItemImage>;

export type ListResultItemKVNamespaceTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemKVNamespaceTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemKVNamespaceTagsMap>;

export type ListResultItemKVNamespaceType = "kv_namespace";
export const ListResultItemKVNamespaceType = /*@__PURE__*/ S.String;

export interface ListResultItemKVNamespace {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemKVNamespaceTagsMap;
  type: ListResultItemKVNamespaceType;
}
export const ListResultItemKVNamespace = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemKVNamespaceTagsMap,
    type: ListResultItemKVNamespaceType,
  }),
).annotate({
  identifier: "ListResultItemKVNamespace",
}) as any as S.Schema<ListResultItemKVNamespace>;

export type ListResultItemManagedClientCertificateTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemManagedClientCertificateTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ListResultItemManagedClientCertificateTagsMap>;

export type ListResultItemManagedClientCertificateType =
  "managed_client_certificate";
export const ListResultItemManagedClientCertificateType =
  /*@__PURE__*/ S.String;

export interface ListResultItemManagedClientCertificate {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemManagedClientCertificateTagsMap;
  type: ListResultItemManagedClientCertificateType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ListResultItemManagedClientCertificate = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: ListResultItemManagedClientCertificateTagsMap,
      type: ListResultItemManagedClientCertificateType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
).annotate({
  identifier: "ListResultItemManagedClientCertificate",
}) as any as S.Schema<ListResultItemManagedClientCertificate>;

export type ListResultItemQueueTagsMap = { [key: string]: string | undefined };
export const ListResultItemQueueTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemQueueTagsMap>;

export type ListResultItemQueueType = "queue";
export const ListResultItemQueueType = /*@__PURE__*/ S.String;

export interface ListResultItemQueue {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemQueueTagsMap;
  type: ListResultItemQueueType;
}
export const ListResultItemQueue = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemQueueTagsMap,
    type: ListResultItemQueueType,
  }),
).annotate({
  identifier: "ListResultItemQueue",
}) as any as S.Schema<ListResultItemQueue>;

export type ListResultItemR2BucketTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemR2BucketTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemR2BucketTagsMap>;

export type ListResultItemR2BucketType = "r2_bucket";
export const ListResultItemR2BucketType = /*@__PURE__*/ S.String;

export interface ListResultItemR2Bucket {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemR2BucketTagsMap;
  type: ListResultItemR2BucketType;
}
export const ListResultItemR2Bucket = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemR2BucketTagsMap,
    type: ListResultItemR2BucketType,
  }),
).annotate({
  identifier: "ListResultItemR2Bucket",
}) as any as S.Schema<ListResultItemR2Bucket>;

export type ListResultItemResourceShareTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemResourceShareTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemResourceShareTagsMap>;

export type ListResultItemResourceShareType = "resource_share";
export const ListResultItemResourceShareType = /*@__PURE__*/ S.String;

export interface ListResultItemResourceShare {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemResourceShareTagsMap;
  type: ListResultItemResourceShareType;
}
export const ListResultItemResourceShare = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemResourceShareTagsMap,
    type: ListResultItemResourceShareType,
  }),
).annotate({
  identifier: "ListResultItemResourceShare",
}) as any as S.Schema<ListResultItemResourceShare>;

export type ListResultItemStreamLiveInputTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemStreamLiveInputTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemStreamLiveInputTagsMap>;

export type ListResultItemStreamLiveInputType = "stream_live_input";
export const ListResultItemStreamLiveInputType = /*@__PURE__*/ S.String;

export interface ListResultItemStreamLiveInput {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemStreamLiveInputTagsMap;
  type: ListResultItemStreamLiveInputType;
}
export const ListResultItemStreamLiveInput = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemStreamLiveInputTagsMap,
    type: ListResultItemStreamLiveInputType,
  }),
).annotate({
  identifier: "ListResultItemStreamLiveInput",
}) as any as S.Schema<ListResultItemStreamLiveInput>;

export type ListResultItemStreamVideoTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemStreamVideoTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemStreamVideoTagsMap>;

export type ListResultItemStreamVideoType = "stream_video";
export const ListResultItemStreamVideoType = /*@__PURE__*/ S.String;

export interface ListResultItemStreamVideo {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemStreamVideoTagsMap;
  type: ListResultItemStreamVideoType;
}
export const ListResultItemStreamVideo = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemStreamVideoTagsMap,
    type: ListResultItemStreamVideoType,
  }),
).annotate({
  identifier: "ListResultItemStreamVideo",
}) as any as S.Schema<ListResultItemStreamVideo>;

export type ListResultItemWorkerTagsMap = { [key: string]: string | undefined };
export const ListResultItemWorkerTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemWorkerTagsMap>;

export type ListResultItemWorkerType = "worker";
export const ListResultItemWorkerType = /*@__PURE__*/ S.String;

export interface ListResultItemWorker {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemWorkerTagsMap;
  type: ListResultItemWorkerType;
}
export const ListResultItemWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemWorkerTagsMap,
    type: ListResultItemWorkerType,
  }),
).annotate({
  identifier: "ListResultItemWorker",
}) as any as S.Schema<ListResultItemWorker>;

export type ListResultItemWorkerVersionTagsMap = {
  [key: string]: string | undefined;
};
export const ListResultItemWorkerVersionTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemWorkerVersionTagsMap>;

export type ListResultItemWorkerVersionType = "worker_version";
export const ListResultItemWorkerVersionType = /*@__PURE__*/ S.String;

export interface ListResultItemWorkerVersion {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemWorkerVersionTagsMap;
  type: ListResultItemWorkerVersionType;
  /** Worker ID is required only for worker_version resources */
  workerId: string;
}
export const ListResultItemWorkerVersion = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemWorkerVersionTagsMap,
    type: ListResultItemWorkerVersionType,
    workerId: S.String.pipe(T.Body("worker_id")),
  }),
).annotate({
  identifier: "ListResultItemWorkerVersion",
}) as any as S.Schema<ListResultItemWorkerVersion>;

export type ListResultItemZoneTagsMap = { [key: string]: string | undefined };
export const ListResultItemZoneTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ListResultItemZoneTagsMap>;

export type ListResultItemZoneType = "zone";
export const ListResultItemZoneType = /*@__PURE__*/ S.String;

export interface ListResultItemZone {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ListResultItemZoneTagsMap;
  type: ListResultItemZoneType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ListResultItemZone = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ListResultItemZoneTagsMap,
    type: ListResultItemZoneType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "ListResultItemZone",
}) as any as S.Schema<ListResultItemZone>;

export type ListResultItem =
  | ListResultItemAccessApplication
  | ListResultItemAccessApplicationPolicy
  | ListResultItemAccessGroup
  | ListResultItemAccount
  | ListResultItemAIGateway
  | ListResultItemAlertingPolicy
  | ListResultItemAlertingWebhook
  | ListResultItemAPIGatewayOperation
  | ListResultItemCloudflaredTunnel
  | ListResultItemCustomCertificate
  | ListResultItemCustomHostname
  | ListResultItemD1Database
  | ListResultItemDNSRecord
  | ListResultItemDurableObjectNamespace
  | ListResultItemGatewayList
  | ListResultItemGatewayRule
  | ListResultItemImage
  | ListResultItemKVNamespace
  | ListResultItemManagedClientCertificate
  | ListResultItemQueue
  | ListResultItemR2Bucket
  | ListResultItemResourceShare
  | ListResultItemStreamLiveInput
  | ListResultItemStreamVideo
  | ListResultItemWorker
  | ListResultItemWorkerVersion
  | ListResultItemZone;
export const ListResultItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["id", "etag", "name", "tags", "type"],
    ["id", "accessApplicationId", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "workerId"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
  ]),
);

export type ListResultList = Array<ListResultItem>;
export const ListResultList = /*@__PURE__*/ S.Array(
  ListResultItem,
) as any as S.Schema<ListResultList>;

export interface ListResourceTaggingsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: ListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListResourceTaggingsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: ListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListResourceTaggingsResponse",
}) as any as S.Schema<ListResourceTaggingsResponse>;

export type ValuesListRequestType =
  | "access_application"
  | "access_application_policy"
  | "access_group"
  | "account"
  | "ai_gateway"
  | "alerting_policy"
  | "alerting_webhook"
  | "api_gateway_operation"
  | "cloudflared_tunnel"
  | "custom_certificate"
  | "custom_hostname"
  | "d1_database"
  | "dns_record"
  | "durable_object_namespace"
  | "gateway_list"
  | "gateway_rule"
  | "image"
  | "kv_namespace"
  | "managed_client_certificate"
  | "queue"
  | "r2_bucket"
  | "resource_share"
  | "stream_live_input"
  | "stream_video"
  | "worker"
  | "worker_version"
  | "zone";
export const ValuesListRequestType = /*@__PURE__*/ S.String;

export interface ListValuesRequest {
  /** Identifier. */
  accountId: string;
  tagKey: string;
  /** Cursor for pagination. */
  cursor?: string;
  /** Filter by resource type. */
  type?: ValuesListRequestType | (string & {});
}
export const ListValuesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    tagKey: S.String.pipe(T.Label("tag_key")),
    cursor: S.optional(S.String.pipe(T.Query())),
    type: S.optional(ValuesListRequestType.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/tags/values/{tag_key}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListValuesRequest",
}) as any as S.Schema<ListValuesRequest>;

export type ValuesListResultList = Array<string>;
export const ValuesListResultList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<ValuesListResultList>;

export interface ListValuesResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: ValuesListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListValuesResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: ValuesListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListValuesResponse",
}) as any as S.Schema<ListValuesResponse>;

export type AccountTagsUpdateRequestResourceTypeResourceTaggingSetTagsRequestAccountLevelWorkerVersion =
  | "access_application"
  | "access_group"
  | "account"
  | "ai_gateway"
  | "alerting_policy"
  | "alerting_webhook"
  | "cloudflared_tunnel"
  | "d1_database"
  | "durable_object_namespace"
  | "gateway_list"
  | "gateway_rule"
  | "image"
  | "kv_namespace"
  | "queue"
  | "r2_bucket"
  | "resource_share"
  | "stream_live_input"
  | "stream_video"
  | "worker"
  | "worker_version";
export const AccountTagsUpdateRequestResourceTypeResourceTaggingSetTagsRequestAccountLevelWorkerVersion =
  /*@__PURE__*/ S.String;

export type AccountTagsUpdateRequestResourceTypeResourceTaggingSetTagsRequestAccountLevelBase =
  | "access_application"
  | "access_group"
  | "account"
  | "ai_gateway"
  | "alerting_policy"
  | "alerting_webhook"
  | "cloudflared_tunnel"
  | "d1_database"
  | "durable_object_namespace"
  | "gateway_list"
  | "gateway_rule"
  | "image"
  | "kv_namespace"
  | "queue"
  | "r2_bucket"
  | "resource_share"
  | "stream_live_input"
  | "stream_video"
  | "worker";
export const AccountTagsUpdateRequestResourceTypeResourceTaggingSetTagsRequestAccountLevelBase =
  /*@__PURE__*/ S.String;

export type AccountTagsUpdateRequestResourceType =
  | AccountTagsUpdateRequestResourceTypeResourceTaggingSetTagsRequestAccountLevelWorkerVersion
  | (string & {})
  | AccountTagsUpdateRequestResourceTypeResourceTaggingSetTagsRequestAccountLevelBase
  | (string & {});
export const AccountTagsUpdateRequestResourceType =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export type AccountTagsUpdateRequestTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateRequestTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateRequestTagsMap>;

export interface PutAccountTagRequest {
  /** Identifier. */
  accountId: string;
  /** Identifies the unique resource. */
  resourceId: string;
  /** Enum for base account-level resource types (those with no extra required fields). */
  resourceType: AccountTagsUpdateRequestResourceType;
  /** Worker ID is required only for worker_version resources */
  workerId?: string;
  /** Contains key-value pairs of tags. */
  tags?: AccountTagsUpdateRequestTagsMap;
  ifMatch?: string;
}
export const PutAccountTagRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    resourceId: S.String.pipe(T.Body("resource_id")),
    resourceType: AccountTagsUpdateRequestResourceType.pipe(
      T.Body("resource_type"),
    ),
    workerId: S.optional(S.String.pipe(T.Body("worker_id"))),
    tags: S.optional(AccountTagsUpdateRequestTagsMap),
    ifMatch: S.optional(S.String.pipe(T.Header("If-Match"))),
  })
    .pipe(
      T.Http({ method: "PUT", uri: "/accounts/{account_id}/tags", code: 200 }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutAccountTagRequest",
}) as any as S.Schema<PutAccountTagRequest>;

export type AccountTagsUpdateResultAccessApplicationTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultAccessApplicationTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsUpdateResultAccessApplicationTagsMap>;

export type AccountTagsUpdateResultAccessApplicationType = "access_application";
export const AccountTagsUpdateResultAccessApplicationType =
  /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultAccessApplication {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultAccessApplicationTagsMap;
  type: AccountTagsUpdateResultAccessApplicationType;
}
export const AccountTagsUpdateResultAccessApplication = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsUpdateResultAccessApplicationTagsMap,
      type: AccountTagsUpdateResultAccessApplicationType,
    }),
).annotate({
  identifier: "AccountTagsUpdateResultAccessApplication",
}) as any as S.Schema<AccountTagsUpdateResultAccessApplication>;

export type AccountTagsUpdateResultAccessApplicationPolicyTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultAccessApplicationPolicyTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsUpdateResultAccessApplicationPolicyTagsMap>;

export type AccountTagsUpdateResultAccessApplicationPolicyType =
  "access_application_policy";
export const AccountTagsUpdateResultAccessApplicationPolicyType =
  /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultAccessApplicationPolicy {
  /** Identifies the unique resource. */
  id: string;
  /** Access application ID is required only for access_application_policy resources */
  accessApplicationId: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultAccessApplicationPolicyTagsMap;
  type: AccountTagsUpdateResultAccessApplicationPolicyType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsUpdateResultAccessApplicationPolicy =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      accessApplicationId: S.String.pipe(T.Body("access_application_id")),
      etag: S.String,
      name: S.String,
      tags: AccountTagsUpdateResultAccessApplicationPolicyTagsMap,
      type: AccountTagsUpdateResultAccessApplicationPolicyType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
  ).annotate({
    identifier: "AccountTagsUpdateResultAccessApplicationPolicy",
  }) as any as S.Schema<AccountTagsUpdateResultAccessApplicationPolicy>;

export type AccountTagsUpdateResultAccessGroupTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultAccessGroupTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultAccessGroupTagsMap>;

export type AccountTagsUpdateResultAccessGroupType = "access_group";
export const AccountTagsUpdateResultAccessGroupType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultAccessGroup {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultAccessGroupTagsMap;
  type: AccountTagsUpdateResultAccessGroupType;
}
export const AccountTagsUpdateResultAccessGroup = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultAccessGroupTagsMap,
    type: AccountTagsUpdateResultAccessGroupType,
  }),
).annotate({
  identifier: "AccountTagsUpdateResultAccessGroup",
}) as any as S.Schema<AccountTagsUpdateResultAccessGroup>;

export type AccountTagsUpdateResultAccountTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultAccountTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultAccountTagsMap>;

export type AccountTagsUpdateResultAccountType = "account";
export const AccountTagsUpdateResultAccountType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultAccount {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultAccountTagsMap;
  type: AccountTagsUpdateResultAccountType;
}
export const AccountTagsUpdateResultAccount = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultAccountTagsMap,
    type: AccountTagsUpdateResultAccountType,
  }),
).annotate({
  identifier: "AccountTagsUpdateResultAccount",
}) as any as S.Schema<AccountTagsUpdateResultAccount>;

export type AccountTagsUpdateResultAIGatewayTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultAIGatewayTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultAIGatewayTagsMap>;

export type AccountTagsUpdateResultAIGatewayType = "ai_gateway";
export const AccountTagsUpdateResultAIGatewayType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultAIGateway {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultAIGatewayTagsMap;
  type: AccountTagsUpdateResultAIGatewayType;
}
export const AccountTagsUpdateResultAIGateway = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultAIGatewayTagsMap,
    type: AccountTagsUpdateResultAIGatewayType,
  }),
).annotate({
  identifier: "AccountTagsUpdateResultAIGateway",
}) as any as S.Schema<AccountTagsUpdateResultAIGateway>;

export type AccountTagsUpdateResultAlertingPolicyTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultAlertingPolicyTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsUpdateResultAlertingPolicyTagsMap>;

export type AccountTagsUpdateResultAlertingPolicyType = "alerting_policy";
export const AccountTagsUpdateResultAlertingPolicyType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultAlertingPolicy {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultAlertingPolicyTagsMap;
  type: AccountTagsUpdateResultAlertingPolicyType;
}
export const AccountTagsUpdateResultAlertingPolicy = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsUpdateResultAlertingPolicyTagsMap,
      type: AccountTagsUpdateResultAlertingPolicyType,
    }),
).annotate({
  identifier: "AccountTagsUpdateResultAlertingPolicy",
}) as any as S.Schema<AccountTagsUpdateResultAlertingPolicy>;

export type AccountTagsUpdateResultAlertingWebhookTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultAlertingWebhookTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsUpdateResultAlertingWebhookTagsMap>;

export type AccountTagsUpdateResultAlertingWebhookType = "alerting_webhook";
export const AccountTagsUpdateResultAlertingWebhookType =
  /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultAlertingWebhook {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultAlertingWebhookTagsMap;
  type: AccountTagsUpdateResultAlertingWebhookType;
}
export const AccountTagsUpdateResultAlertingWebhook = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsUpdateResultAlertingWebhookTagsMap,
      type: AccountTagsUpdateResultAlertingWebhookType,
    }),
).annotate({
  identifier: "AccountTagsUpdateResultAlertingWebhook",
}) as any as S.Schema<AccountTagsUpdateResultAlertingWebhook>;

export type AccountTagsUpdateResultAPIGatewayOperationTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultAPIGatewayOperationTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsUpdateResultAPIGatewayOperationTagsMap>;

export type AccountTagsUpdateResultAPIGatewayOperationType =
  "api_gateway_operation";
export const AccountTagsUpdateResultAPIGatewayOperationType =
  /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultAPIGatewayOperation {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultAPIGatewayOperationTagsMap;
  type: AccountTagsUpdateResultAPIGatewayOperationType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsUpdateResultAPIGatewayOperation =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsUpdateResultAPIGatewayOperationTagsMap,
      type: AccountTagsUpdateResultAPIGatewayOperationType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
  ).annotate({
    identifier: "AccountTagsUpdateResultAPIGatewayOperation",
  }) as any as S.Schema<AccountTagsUpdateResultAPIGatewayOperation>;

export type AccountTagsUpdateResultCloudflaredTunnelTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultCloudflaredTunnelTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsUpdateResultCloudflaredTunnelTagsMap>;

export type AccountTagsUpdateResultCloudflaredTunnelType = "cloudflared_tunnel";
export const AccountTagsUpdateResultCloudflaredTunnelType =
  /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultCloudflaredTunnel {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultCloudflaredTunnelTagsMap;
  type: AccountTagsUpdateResultCloudflaredTunnelType;
}
export const AccountTagsUpdateResultCloudflaredTunnel = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsUpdateResultCloudflaredTunnelTagsMap,
      type: AccountTagsUpdateResultCloudflaredTunnelType,
    }),
).annotate({
  identifier: "AccountTagsUpdateResultCloudflaredTunnel",
}) as any as S.Schema<AccountTagsUpdateResultCloudflaredTunnel>;

export type AccountTagsUpdateResultCustomCertificateTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultCustomCertificateTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsUpdateResultCustomCertificateTagsMap>;

export type AccountTagsUpdateResultCustomCertificateType = "custom_certificate";
export const AccountTagsUpdateResultCustomCertificateType =
  /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultCustomCertificate {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultCustomCertificateTagsMap;
  type: AccountTagsUpdateResultCustomCertificateType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsUpdateResultCustomCertificate = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsUpdateResultCustomCertificateTagsMap,
      type: AccountTagsUpdateResultCustomCertificateType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
).annotate({
  identifier: "AccountTagsUpdateResultCustomCertificate",
}) as any as S.Schema<AccountTagsUpdateResultCustomCertificate>;

export type AccountTagsUpdateResultCustomHostnameTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultCustomHostnameTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsUpdateResultCustomHostnameTagsMap>;

export type AccountTagsUpdateResultCustomHostnameType = "custom_hostname";
export const AccountTagsUpdateResultCustomHostnameType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultCustomHostname {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultCustomHostnameTagsMap;
  type: AccountTagsUpdateResultCustomHostnameType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsUpdateResultCustomHostname = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsUpdateResultCustomHostnameTagsMap,
      type: AccountTagsUpdateResultCustomHostnameType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
).annotate({
  identifier: "AccountTagsUpdateResultCustomHostname",
}) as any as S.Schema<AccountTagsUpdateResultCustomHostname>;

export type AccountTagsUpdateResultD1DatabaseTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultD1DatabaseTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultD1DatabaseTagsMap>;

export type AccountTagsUpdateResultD1DatabaseType = "d1_database";
export const AccountTagsUpdateResultD1DatabaseType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultD1Database {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultD1DatabaseTagsMap;
  type: AccountTagsUpdateResultD1DatabaseType;
}
export const AccountTagsUpdateResultD1Database = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultD1DatabaseTagsMap,
    type: AccountTagsUpdateResultD1DatabaseType,
  }),
).annotate({
  identifier: "AccountTagsUpdateResultD1Database",
}) as any as S.Schema<AccountTagsUpdateResultD1Database>;

export type AccountTagsUpdateResultDNSRecordTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultDNSRecordTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultDNSRecordTagsMap>;

export type AccountTagsUpdateResultDNSRecordType = "dns_record";
export const AccountTagsUpdateResultDNSRecordType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultDNSRecord {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultDNSRecordTagsMap;
  type: AccountTagsUpdateResultDNSRecordType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsUpdateResultDNSRecord = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultDNSRecordTagsMap,
    type: AccountTagsUpdateResultDNSRecordType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "AccountTagsUpdateResultDNSRecord",
}) as any as S.Schema<AccountTagsUpdateResultDNSRecord>;

export type AccountTagsUpdateResultDurableObjectNamespaceTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultDurableObjectNamespaceTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsUpdateResultDurableObjectNamespaceTagsMap>;

export type AccountTagsUpdateResultDurableObjectNamespaceType =
  "durable_object_namespace";
export const AccountTagsUpdateResultDurableObjectNamespaceType =
  /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultDurableObjectNamespace {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultDurableObjectNamespaceTagsMap;
  type: AccountTagsUpdateResultDurableObjectNamespaceType;
}
export const AccountTagsUpdateResultDurableObjectNamespace =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsUpdateResultDurableObjectNamespaceTagsMap,
      type: AccountTagsUpdateResultDurableObjectNamespaceType,
    }),
  ).annotate({
    identifier: "AccountTagsUpdateResultDurableObjectNamespace",
  }) as any as S.Schema<AccountTagsUpdateResultDurableObjectNamespace>;

export type AccountTagsUpdateResultGatewayListTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultGatewayListTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultGatewayListTagsMap>;

export type AccountTagsUpdateResultGatewayListType = "gateway_list";
export const AccountTagsUpdateResultGatewayListType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultGatewayList {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultGatewayListTagsMap;
  type: AccountTagsUpdateResultGatewayListType;
}
export const AccountTagsUpdateResultGatewayList = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultGatewayListTagsMap,
    type: AccountTagsUpdateResultGatewayListType,
  }),
).annotate({
  identifier: "AccountTagsUpdateResultGatewayList",
}) as any as S.Schema<AccountTagsUpdateResultGatewayList>;

export type AccountTagsUpdateResultGatewayRuleTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultGatewayRuleTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultGatewayRuleTagsMap>;

export type AccountTagsUpdateResultGatewayRuleType = "gateway_rule";
export const AccountTagsUpdateResultGatewayRuleType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultGatewayRule {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultGatewayRuleTagsMap;
  type: AccountTagsUpdateResultGatewayRuleType;
}
export const AccountTagsUpdateResultGatewayRule = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultGatewayRuleTagsMap,
    type: AccountTagsUpdateResultGatewayRuleType,
  }),
).annotate({
  identifier: "AccountTagsUpdateResultGatewayRule",
}) as any as S.Schema<AccountTagsUpdateResultGatewayRule>;

export type AccountTagsUpdateResultImageTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultImageTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultImageTagsMap>;

export type AccountTagsUpdateResultImageType = "image";
export const AccountTagsUpdateResultImageType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultImage {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultImageTagsMap;
  type: AccountTagsUpdateResultImageType;
}
export const AccountTagsUpdateResultImage = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultImageTagsMap,
    type: AccountTagsUpdateResultImageType,
  }),
).annotate({
  identifier: "AccountTagsUpdateResultImage",
}) as any as S.Schema<AccountTagsUpdateResultImage>;

export type AccountTagsUpdateResultKVNamespaceTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultKVNamespaceTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultKVNamespaceTagsMap>;

export type AccountTagsUpdateResultKVNamespaceType = "kv_namespace";
export const AccountTagsUpdateResultKVNamespaceType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultKVNamespace {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultKVNamespaceTagsMap;
  type: AccountTagsUpdateResultKVNamespaceType;
}
export const AccountTagsUpdateResultKVNamespace = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultKVNamespaceTagsMap,
    type: AccountTagsUpdateResultKVNamespaceType,
  }),
).annotate({
  identifier: "AccountTagsUpdateResultKVNamespace",
}) as any as S.Schema<AccountTagsUpdateResultKVNamespace>;

export type AccountTagsUpdateResultManagedClientCertificateTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultManagedClientCertificateTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsUpdateResultManagedClientCertificateTagsMap>;

export type AccountTagsUpdateResultManagedClientCertificateType =
  "managed_client_certificate";
export const AccountTagsUpdateResultManagedClientCertificateType =
  /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultManagedClientCertificate {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultManagedClientCertificateTagsMap;
  type: AccountTagsUpdateResultManagedClientCertificateType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsUpdateResultManagedClientCertificate =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsUpdateResultManagedClientCertificateTagsMap,
      type: AccountTagsUpdateResultManagedClientCertificateType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
  ).annotate({
    identifier: "AccountTagsUpdateResultManagedClientCertificate",
  }) as any as S.Schema<AccountTagsUpdateResultManagedClientCertificate>;

export type AccountTagsUpdateResultQueueTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultQueueTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultQueueTagsMap>;

export type AccountTagsUpdateResultQueueType = "queue";
export const AccountTagsUpdateResultQueueType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultQueue {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultQueueTagsMap;
  type: AccountTagsUpdateResultQueueType;
}
export const AccountTagsUpdateResultQueue = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultQueueTagsMap,
    type: AccountTagsUpdateResultQueueType,
  }),
).annotate({
  identifier: "AccountTagsUpdateResultQueue",
}) as any as S.Schema<AccountTagsUpdateResultQueue>;

export type AccountTagsUpdateResultR2BucketTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultR2BucketTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultR2BucketTagsMap>;

export type AccountTagsUpdateResultR2BucketType = "r2_bucket";
export const AccountTagsUpdateResultR2BucketType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultR2Bucket {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultR2BucketTagsMap;
  type: AccountTagsUpdateResultR2BucketType;
}
export const AccountTagsUpdateResultR2Bucket = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultR2BucketTagsMap,
    type: AccountTagsUpdateResultR2BucketType,
  }),
).annotate({
  identifier: "AccountTagsUpdateResultR2Bucket",
}) as any as S.Schema<AccountTagsUpdateResultR2Bucket>;

export type AccountTagsUpdateResultResourceShareTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultResourceShareTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsUpdateResultResourceShareTagsMap>;

export type AccountTagsUpdateResultResourceShareType = "resource_share";
export const AccountTagsUpdateResultResourceShareType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultResourceShare {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultResourceShareTagsMap;
  type: AccountTagsUpdateResultResourceShareType;
}
export const AccountTagsUpdateResultResourceShare = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsUpdateResultResourceShareTagsMap,
      type: AccountTagsUpdateResultResourceShareType,
    }),
).annotate({
  identifier: "AccountTagsUpdateResultResourceShare",
}) as any as S.Schema<AccountTagsUpdateResultResourceShare>;

export type AccountTagsUpdateResultStreamLiveInputTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultStreamLiveInputTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsUpdateResultStreamLiveInputTagsMap>;

export type AccountTagsUpdateResultStreamLiveInputType = "stream_live_input";
export const AccountTagsUpdateResultStreamLiveInputType =
  /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultStreamLiveInput {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultStreamLiveInputTagsMap;
  type: AccountTagsUpdateResultStreamLiveInputType;
}
export const AccountTagsUpdateResultStreamLiveInput = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsUpdateResultStreamLiveInputTagsMap,
      type: AccountTagsUpdateResultStreamLiveInputType,
    }),
).annotate({
  identifier: "AccountTagsUpdateResultStreamLiveInput",
}) as any as S.Schema<AccountTagsUpdateResultStreamLiveInput>;

export type AccountTagsUpdateResultStreamVideoTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultStreamVideoTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultStreamVideoTagsMap>;

export type AccountTagsUpdateResultStreamVideoType = "stream_video";
export const AccountTagsUpdateResultStreamVideoType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultStreamVideo {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultStreamVideoTagsMap;
  type: AccountTagsUpdateResultStreamVideoType;
}
export const AccountTagsUpdateResultStreamVideo = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultStreamVideoTagsMap,
    type: AccountTagsUpdateResultStreamVideoType,
  }),
).annotate({
  identifier: "AccountTagsUpdateResultStreamVideo",
}) as any as S.Schema<AccountTagsUpdateResultStreamVideo>;

export type AccountTagsUpdateResultWorkerTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultWorkerTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultWorkerTagsMap>;

export type AccountTagsUpdateResultWorkerType = "worker";
export const AccountTagsUpdateResultWorkerType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultWorker {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultWorkerTagsMap;
  type: AccountTagsUpdateResultWorkerType;
}
export const AccountTagsUpdateResultWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultWorkerTagsMap,
    type: AccountTagsUpdateResultWorkerType,
  }),
).annotate({
  identifier: "AccountTagsUpdateResultWorker",
}) as any as S.Schema<AccountTagsUpdateResultWorker>;

export type AccountTagsUpdateResultWorkerVersionTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultWorkerVersionTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<AccountTagsUpdateResultWorkerVersionTagsMap>;

export type AccountTagsUpdateResultWorkerVersionType = "worker_version";
export const AccountTagsUpdateResultWorkerVersionType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultWorkerVersion {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultWorkerVersionTagsMap;
  type: AccountTagsUpdateResultWorkerVersionType;
  /** Worker ID is required only for worker_version resources */
  workerId: string;
}
export const AccountTagsUpdateResultWorkerVersion = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: AccountTagsUpdateResultWorkerVersionTagsMap,
      type: AccountTagsUpdateResultWorkerVersionType,
      workerId: S.String.pipe(T.Body("worker_id")),
    }),
).annotate({
  identifier: "AccountTagsUpdateResultWorkerVersion",
}) as any as S.Schema<AccountTagsUpdateResultWorkerVersion>;

export type AccountTagsUpdateResultZoneTagsMap = {
  [key: string]: string | undefined;
};
export const AccountTagsUpdateResultZoneTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<AccountTagsUpdateResultZoneTagsMap>;

export type AccountTagsUpdateResultZoneType = "zone";
export const AccountTagsUpdateResultZoneType = /*@__PURE__*/ S.String;

export interface AccountTagsUpdateResultZone {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: AccountTagsUpdateResultZoneTagsMap;
  type: AccountTagsUpdateResultZoneType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const AccountTagsUpdateResultZone = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: AccountTagsUpdateResultZoneTagsMap,
    type: AccountTagsUpdateResultZoneType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "AccountTagsUpdateResultZone",
}) as any as S.Schema<AccountTagsUpdateResultZone>;

export type AccountTagsUpdateResult =
  | AccountTagsUpdateResultAccessApplication
  | AccountTagsUpdateResultAccessApplicationPolicy
  | AccountTagsUpdateResultAccessGroup
  | AccountTagsUpdateResultAccount
  | AccountTagsUpdateResultAIGateway
  | AccountTagsUpdateResultAlertingPolicy
  | AccountTagsUpdateResultAlertingWebhook
  | AccountTagsUpdateResultAPIGatewayOperation
  | AccountTagsUpdateResultCloudflaredTunnel
  | AccountTagsUpdateResultCustomCertificate
  | AccountTagsUpdateResultCustomHostname
  | AccountTagsUpdateResultD1Database
  | AccountTagsUpdateResultDNSRecord
  | AccountTagsUpdateResultDurableObjectNamespace
  | AccountTagsUpdateResultGatewayList
  | AccountTagsUpdateResultGatewayRule
  | AccountTagsUpdateResultImage
  | AccountTagsUpdateResultKVNamespace
  | AccountTagsUpdateResultManagedClientCertificate
  | AccountTagsUpdateResultQueue
  | AccountTagsUpdateResultR2Bucket
  | AccountTagsUpdateResultResourceShare
  | AccountTagsUpdateResultStreamLiveInput
  | AccountTagsUpdateResultStreamVideo
  | AccountTagsUpdateResultWorker
  | AccountTagsUpdateResultWorkerVersion
  | AccountTagsUpdateResultZone;
export const AccountTagsUpdateResult = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["id", "etag", "name", "tags", "type"],
    ["id", "accessApplicationId", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "workerId"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
  ]),
);

export type PutAccountTagResponse = AccountTagsUpdateResult;
export const PutAccountTagResponse = /*@__PURE__*/ S.suspend(() =>
  AccountTagsUpdateResult.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "PutAccountTagResponse",
}) as any as S.Schema<PutAccountTagResponse>;

export type ZoneTagsUpdateRequestResourceTypeResourceTaggingSetTagsRequestZoneLevelBase =
  | "api_gateway_operation"
  | "custom_certificate"
  | "custom_hostname"
  | "dns_record"
  | "managed_client_certificate"
  | "zone";
export const ZoneTagsUpdateRequestResourceTypeResourceTaggingSetTagsRequestZoneLevelBase =
  /*@__PURE__*/ S.String;

export type ZoneTagsUpdateRequestResourceTypeResourceTaggingSetTagsRequestZoneLevelAccessApplicationPolicy =
  | "api_gateway_operation"
  | "custom_certificate"
  | "custom_hostname"
  | "dns_record"
  | "managed_client_certificate"
  | "zone"
  | "access_application_policy";
export const ZoneTagsUpdateRequestResourceTypeResourceTaggingSetTagsRequestZoneLevelAccessApplicationPolicy =
  /*@__PURE__*/ S.String;

export type ZoneTagsUpdateRequestResourceType =
  | ZoneTagsUpdateRequestResourceTypeResourceTaggingSetTagsRequestZoneLevelBase
  | (string & {})
  | ZoneTagsUpdateRequestResourceTypeResourceTaggingSetTagsRequestZoneLevelAccessApplicationPolicy
  | (string & {});
export const ZoneTagsUpdateRequestResourceType = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([[], []]),
);

export type ZoneTagsUpdateRequestTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateRequestTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateRequestTagsMap>;

export interface PutZoneTagRequest {
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
  /** Identifies the unique resource. */
  resourceId: string;
  /** Enum for base zone-level resource types (those with no extra required fields). */
  resourceType: ZoneTagsUpdateRequestResourceType;
  /** Contains key-value pairs of tags. */
  tags?: ZoneTagsUpdateRequestTagsMap;
  /** Access application ID is required only for access_application_policy resources */
  accessApplicationId?: string;
  ifMatch?: string;
}
export const PutZoneTagRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    resourceId: S.String.pipe(T.Body("resource_id")),
    resourceType: ZoneTagsUpdateRequestResourceType.pipe(
      T.Body("resource_type"),
    ),
    tags: S.optional(ZoneTagsUpdateRequestTagsMap),
    accessApplicationId: S.optional(
      S.String.pipe(T.Body("access_application_id")),
    ),
    ifMatch: S.optional(S.String.pipe(T.Header("If-Match"))),
  })
    .pipe(T.Http({ method: "PUT", uri: "/zones/{zone_id}/tags", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutZoneTagRequest",
}) as any as S.Schema<PutZoneTagRequest>;

export type ZoneTagsUpdateResultAccessApplicationTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultAccessApplicationTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ZoneTagsUpdateResultAccessApplicationTagsMap>;

export type ZoneTagsUpdateResultAccessApplicationType = "access_application";
export const ZoneTagsUpdateResultAccessApplicationType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultAccessApplication {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultAccessApplicationTagsMap;
  type: ZoneTagsUpdateResultAccessApplicationType;
}
export const ZoneTagsUpdateResultAccessApplication = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: ZoneTagsUpdateResultAccessApplicationTagsMap,
      type: ZoneTagsUpdateResultAccessApplicationType,
    }),
).annotate({
  identifier: "ZoneTagsUpdateResultAccessApplication",
}) as any as S.Schema<ZoneTagsUpdateResultAccessApplication>;

export type ZoneTagsUpdateResultAccessApplicationPolicyTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultAccessApplicationPolicyTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ZoneTagsUpdateResultAccessApplicationPolicyTagsMap>;

export type ZoneTagsUpdateResultAccessApplicationPolicyType =
  "access_application_policy";
export const ZoneTagsUpdateResultAccessApplicationPolicyType =
  /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultAccessApplicationPolicy {
  /** Identifies the unique resource. */
  id: string;
  /** Access application ID is required only for access_application_policy resources */
  accessApplicationId: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultAccessApplicationPolicyTagsMap;
  type: ZoneTagsUpdateResultAccessApplicationPolicyType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsUpdateResultAccessApplicationPolicy =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      accessApplicationId: S.String.pipe(T.Body("access_application_id")),
      etag: S.String,
      name: S.String,
      tags: ZoneTagsUpdateResultAccessApplicationPolicyTagsMap,
      type: ZoneTagsUpdateResultAccessApplicationPolicyType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
  ).annotate({
    identifier: "ZoneTagsUpdateResultAccessApplicationPolicy",
  }) as any as S.Schema<ZoneTagsUpdateResultAccessApplicationPolicy>;

export type ZoneTagsUpdateResultAccessGroupTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultAccessGroupTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultAccessGroupTagsMap>;

export type ZoneTagsUpdateResultAccessGroupType = "access_group";
export const ZoneTagsUpdateResultAccessGroupType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultAccessGroup {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultAccessGroupTagsMap;
  type: ZoneTagsUpdateResultAccessGroupType;
}
export const ZoneTagsUpdateResultAccessGroup = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultAccessGroupTagsMap,
    type: ZoneTagsUpdateResultAccessGroupType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultAccessGroup",
}) as any as S.Schema<ZoneTagsUpdateResultAccessGroup>;

export type ZoneTagsUpdateResultAccountTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultAccountTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultAccountTagsMap>;

export type ZoneTagsUpdateResultAccountType = "account";
export const ZoneTagsUpdateResultAccountType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultAccount {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultAccountTagsMap;
  type: ZoneTagsUpdateResultAccountType;
}
export const ZoneTagsUpdateResultAccount = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultAccountTagsMap,
    type: ZoneTagsUpdateResultAccountType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultAccount",
}) as any as S.Schema<ZoneTagsUpdateResultAccount>;

export type ZoneTagsUpdateResultAIGatewayTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultAIGatewayTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultAIGatewayTagsMap>;

export type ZoneTagsUpdateResultAIGatewayType = "ai_gateway";
export const ZoneTagsUpdateResultAIGatewayType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultAIGateway {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultAIGatewayTagsMap;
  type: ZoneTagsUpdateResultAIGatewayType;
}
export const ZoneTagsUpdateResultAIGateway = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultAIGatewayTagsMap,
    type: ZoneTagsUpdateResultAIGatewayType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultAIGateway",
}) as any as S.Schema<ZoneTagsUpdateResultAIGateway>;

export type ZoneTagsUpdateResultAlertingPolicyTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultAlertingPolicyTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultAlertingPolicyTagsMap>;

export type ZoneTagsUpdateResultAlertingPolicyType = "alerting_policy";
export const ZoneTagsUpdateResultAlertingPolicyType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultAlertingPolicy {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultAlertingPolicyTagsMap;
  type: ZoneTagsUpdateResultAlertingPolicyType;
}
export const ZoneTagsUpdateResultAlertingPolicy = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultAlertingPolicyTagsMap,
    type: ZoneTagsUpdateResultAlertingPolicyType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultAlertingPolicy",
}) as any as S.Schema<ZoneTagsUpdateResultAlertingPolicy>;

export type ZoneTagsUpdateResultAlertingWebhookTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultAlertingWebhookTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ZoneTagsUpdateResultAlertingWebhookTagsMap>;

export type ZoneTagsUpdateResultAlertingWebhookType = "alerting_webhook";
export const ZoneTagsUpdateResultAlertingWebhookType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultAlertingWebhook {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultAlertingWebhookTagsMap;
  type: ZoneTagsUpdateResultAlertingWebhookType;
}
export const ZoneTagsUpdateResultAlertingWebhook = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultAlertingWebhookTagsMap,
    type: ZoneTagsUpdateResultAlertingWebhookType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultAlertingWebhook",
}) as any as S.Schema<ZoneTagsUpdateResultAlertingWebhook>;

export type ZoneTagsUpdateResultAPIGatewayOperationTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultAPIGatewayOperationTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ZoneTagsUpdateResultAPIGatewayOperationTagsMap>;

export type ZoneTagsUpdateResultAPIGatewayOperationType =
  "api_gateway_operation";
export const ZoneTagsUpdateResultAPIGatewayOperationType =
  /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultAPIGatewayOperation {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultAPIGatewayOperationTagsMap;
  type: ZoneTagsUpdateResultAPIGatewayOperationType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsUpdateResultAPIGatewayOperation = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: ZoneTagsUpdateResultAPIGatewayOperationTagsMap,
      type: ZoneTagsUpdateResultAPIGatewayOperationType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
).annotate({
  identifier: "ZoneTagsUpdateResultAPIGatewayOperation",
}) as any as S.Schema<ZoneTagsUpdateResultAPIGatewayOperation>;

export type ZoneTagsUpdateResultCloudflaredTunnelTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultCloudflaredTunnelTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ZoneTagsUpdateResultCloudflaredTunnelTagsMap>;

export type ZoneTagsUpdateResultCloudflaredTunnelType = "cloudflared_tunnel";
export const ZoneTagsUpdateResultCloudflaredTunnelType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultCloudflaredTunnel {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultCloudflaredTunnelTagsMap;
  type: ZoneTagsUpdateResultCloudflaredTunnelType;
}
export const ZoneTagsUpdateResultCloudflaredTunnel = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: ZoneTagsUpdateResultCloudflaredTunnelTagsMap,
      type: ZoneTagsUpdateResultCloudflaredTunnelType,
    }),
).annotate({
  identifier: "ZoneTagsUpdateResultCloudflaredTunnel",
}) as any as S.Schema<ZoneTagsUpdateResultCloudflaredTunnel>;

export type ZoneTagsUpdateResultCustomCertificateTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultCustomCertificateTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ZoneTagsUpdateResultCustomCertificateTagsMap>;

export type ZoneTagsUpdateResultCustomCertificateType = "custom_certificate";
export const ZoneTagsUpdateResultCustomCertificateType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultCustomCertificate {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultCustomCertificateTagsMap;
  type: ZoneTagsUpdateResultCustomCertificateType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsUpdateResultCustomCertificate = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: ZoneTagsUpdateResultCustomCertificateTagsMap,
      type: ZoneTagsUpdateResultCustomCertificateType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
).annotate({
  identifier: "ZoneTagsUpdateResultCustomCertificate",
}) as any as S.Schema<ZoneTagsUpdateResultCustomCertificate>;

export type ZoneTagsUpdateResultCustomHostnameTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultCustomHostnameTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultCustomHostnameTagsMap>;

export type ZoneTagsUpdateResultCustomHostnameType = "custom_hostname";
export const ZoneTagsUpdateResultCustomHostnameType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultCustomHostname {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultCustomHostnameTagsMap;
  type: ZoneTagsUpdateResultCustomHostnameType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsUpdateResultCustomHostname = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultCustomHostnameTagsMap,
    type: ZoneTagsUpdateResultCustomHostnameType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultCustomHostname",
}) as any as S.Schema<ZoneTagsUpdateResultCustomHostname>;

export type ZoneTagsUpdateResultD1DatabaseTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultD1DatabaseTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultD1DatabaseTagsMap>;

export type ZoneTagsUpdateResultD1DatabaseType = "d1_database";
export const ZoneTagsUpdateResultD1DatabaseType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultD1Database {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultD1DatabaseTagsMap;
  type: ZoneTagsUpdateResultD1DatabaseType;
}
export const ZoneTagsUpdateResultD1Database = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultD1DatabaseTagsMap,
    type: ZoneTagsUpdateResultD1DatabaseType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultD1Database",
}) as any as S.Schema<ZoneTagsUpdateResultD1Database>;

export type ZoneTagsUpdateResultDNSRecordTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultDNSRecordTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultDNSRecordTagsMap>;

export type ZoneTagsUpdateResultDNSRecordType = "dns_record";
export const ZoneTagsUpdateResultDNSRecordType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultDNSRecord {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultDNSRecordTagsMap;
  type: ZoneTagsUpdateResultDNSRecordType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsUpdateResultDNSRecord = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultDNSRecordTagsMap,
    type: ZoneTagsUpdateResultDNSRecordType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultDNSRecord",
}) as any as S.Schema<ZoneTagsUpdateResultDNSRecord>;

export type ZoneTagsUpdateResultDurableObjectNamespaceTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultDurableObjectNamespaceTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ZoneTagsUpdateResultDurableObjectNamespaceTagsMap>;

export type ZoneTagsUpdateResultDurableObjectNamespaceType =
  "durable_object_namespace";
export const ZoneTagsUpdateResultDurableObjectNamespaceType =
  /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultDurableObjectNamespace {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultDurableObjectNamespaceTagsMap;
  type: ZoneTagsUpdateResultDurableObjectNamespaceType;
}
export const ZoneTagsUpdateResultDurableObjectNamespace =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: ZoneTagsUpdateResultDurableObjectNamespaceTagsMap,
      type: ZoneTagsUpdateResultDurableObjectNamespaceType,
    }),
  ).annotate({
    identifier: "ZoneTagsUpdateResultDurableObjectNamespace",
  }) as any as S.Schema<ZoneTagsUpdateResultDurableObjectNamespace>;

export type ZoneTagsUpdateResultGatewayListTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultGatewayListTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultGatewayListTagsMap>;

export type ZoneTagsUpdateResultGatewayListType = "gateway_list";
export const ZoneTagsUpdateResultGatewayListType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultGatewayList {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultGatewayListTagsMap;
  type: ZoneTagsUpdateResultGatewayListType;
}
export const ZoneTagsUpdateResultGatewayList = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultGatewayListTagsMap,
    type: ZoneTagsUpdateResultGatewayListType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultGatewayList",
}) as any as S.Schema<ZoneTagsUpdateResultGatewayList>;

export type ZoneTagsUpdateResultGatewayRuleTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultGatewayRuleTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultGatewayRuleTagsMap>;

export type ZoneTagsUpdateResultGatewayRuleType = "gateway_rule";
export const ZoneTagsUpdateResultGatewayRuleType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultGatewayRule {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultGatewayRuleTagsMap;
  type: ZoneTagsUpdateResultGatewayRuleType;
}
export const ZoneTagsUpdateResultGatewayRule = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultGatewayRuleTagsMap,
    type: ZoneTagsUpdateResultGatewayRuleType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultGatewayRule",
}) as any as S.Schema<ZoneTagsUpdateResultGatewayRule>;

export type ZoneTagsUpdateResultImageTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultImageTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultImageTagsMap>;

export type ZoneTagsUpdateResultImageType = "image";
export const ZoneTagsUpdateResultImageType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultImage {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultImageTagsMap;
  type: ZoneTagsUpdateResultImageType;
}
export const ZoneTagsUpdateResultImage = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultImageTagsMap,
    type: ZoneTagsUpdateResultImageType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultImage",
}) as any as S.Schema<ZoneTagsUpdateResultImage>;

export type ZoneTagsUpdateResultKVNamespaceTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultKVNamespaceTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultKVNamespaceTagsMap>;

export type ZoneTagsUpdateResultKVNamespaceType = "kv_namespace";
export const ZoneTagsUpdateResultKVNamespaceType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultKVNamespace {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultKVNamespaceTagsMap;
  type: ZoneTagsUpdateResultKVNamespaceType;
}
export const ZoneTagsUpdateResultKVNamespace = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultKVNamespaceTagsMap,
    type: ZoneTagsUpdateResultKVNamespaceType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultKVNamespace",
}) as any as S.Schema<ZoneTagsUpdateResultKVNamespace>;

export type ZoneTagsUpdateResultManagedClientCertificateTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultManagedClientCertificateTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ZoneTagsUpdateResultManagedClientCertificateTagsMap>;

export type ZoneTagsUpdateResultManagedClientCertificateType =
  "managed_client_certificate";
export const ZoneTagsUpdateResultManagedClientCertificateType =
  /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultManagedClientCertificate {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultManagedClientCertificateTagsMap;
  type: ZoneTagsUpdateResultManagedClientCertificateType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsUpdateResultManagedClientCertificate =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      etag: S.String,
      name: S.String,
      tags: ZoneTagsUpdateResultManagedClientCertificateTagsMap,
      type: ZoneTagsUpdateResultManagedClientCertificateType,
      zoneId: S.String.pipe(T.Body("zone_id")),
    }),
  ).annotate({
    identifier: "ZoneTagsUpdateResultManagedClientCertificate",
  }) as any as S.Schema<ZoneTagsUpdateResultManagedClientCertificate>;

export type ZoneTagsUpdateResultQueueTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultQueueTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultQueueTagsMap>;

export type ZoneTagsUpdateResultQueueType = "queue";
export const ZoneTagsUpdateResultQueueType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultQueue {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultQueueTagsMap;
  type: ZoneTagsUpdateResultQueueType;
}
export const ZoneTagsUpdateResultQueue = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultQueueTagsMap,
    type: ZoneTagsUpdateResultQueueType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultQueue",
}) as any as S.Schema<ZoneTagsUpdateResultQueue>;

export type ZoneTagsUpdateResultR2BucketTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultR2BucketTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultR2BucketTagsMap>;

export type ZoneTagsUpdateResultR2BucketType = "r2_bucket";
export const ZoneTagsUpdateResultR2BucketType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultR2Bucket {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultR2BucketTagsMap;
  type: ZoneTagsUpdateResultR2BucketType;
}
export const ZoneTagsUpdateResultR2Bucket = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultR2BucketTagsMap,
    type: ZoneTagsUpdateResultR2BucketType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultR2Bucket",
}) as any as S.Schema<ZoneTagsUpdateResultR2Bucket>;

export type ZoneTagsUpdateResultResourceShareTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultResourceShareTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultResourceShareTagsMap>;

export type ZoneTagsUpdateResultResourceShareType = "resource_share";
export const ZoneTagsUpdateResultResourceShareType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultResourceShare {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultResourceShareTagsMap;
  type: ZoneTagsUpdateResultResourceShareType;
}
export const ZoneTagsUpdateResultResourceShare = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultResourceShareTagsMap,
    type: ZoneTagsUpdateResultResourceShareType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultResourceShare",
}) as any as S.Schema<ZoneTagsUpdateResultResourceShare>;

export type ZoneTagsUpdateResultStreamLiveInputTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultStreamLiveInputTagsMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ZoneTagsUpdateResultStreamLiveInputTagsMap>;

export type ZoneTagsUpdateResultStreamLiveInputType = "stream_live_input";
export const ZoneTagsUpdateResultStreamLiveInputType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultStreamLiveInput {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultStreamLiveInputTagsMap;
  type: ZoneTagsUpdateResultStreamLiveInputType;
}
export const ZoneTagsUpdateResultStreamLiveInput = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultStreamLiveInputTagsMap,
    type: ZoneTagsUpdateResultStreamLiveInputType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultStreamLiveInput",
}) as any as S.Schema<ZoneTagsUpdateResultStreamLiveInput>;

export type ZoneTagsUpdateResultStreamVideoTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultStreamVideoTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultStreamVideoTagsMap>;

export type ZoneTagsUpdateResultStreamVideoType = "stream_video";
export const ZoneTagsUpdateResultStreamVideoType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultStreamVideo {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultStreamVideoTagsMap;
  type: ZoneTagsUpdateResultStreamVideoType;
}
export const ZoneTagsUpdateResultStreamVideo = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultStreamVideoTagsMap,
    type: ZoneTagsUpdateResultStreamVideoType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultStreamVideo",
}) as any as S.Schema<ZoneTagsUpdateResultStreamVideo>;

export type ZoneTagsUpdateResultWorkerTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultWorkerTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultWorkerTagsMap>;

export type ZoneTagsUpdateResultWorkerType = "worker";
export const ZoneTagsUpdateResultWorkerType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultWorker {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultWorkerTagsMap;
  type: ZoneTagsUpdateResultWorkerType;
}
export const ZoneTagsUpdateResultWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultWorkerTagsMap,
    type: ZoneTagsUpdateResultWorkerType,
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultWorker",
}) as any as S.Schema<ZoneTagsUpdateResultWorker>;

export type ZoneTagsUpdateResultWorkerVersionTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultWorkerVersionTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultWorkerVersionTagsMap>;

export type ZoneTagsUpdateResultWorkerVersionType = "worker_version";
export const ZoneTagsUpdateResultWorkerVersionType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultWorkerVersion {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultWorkerVersionTagsMap;
  type: ZoneTagsUpdateResultWorkerVersionType;
  /** Worker ID is required only for worker_version resources */
  workerId: string;
}
export const ZoneTagsUpdateResultWorkerVersion = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultWorkerVersionTagsMap,
    type: ZoneTagsUpdateResultWorkerVersionType,
    workerId: S.String.pipe(T.Body("worker_id")),
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultWorkerVersion",
}) as any as S.Schema<ZoneTagsUpdateResultWorkerVersion>;

export type ZoneTagsUpdateResultZoneTagsMap = {
  [key: string]: string | undefined;
};
export const ZoneTagsUpdateResultZoneTagsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ZoneTagsUpdateResultZoneTagsMap>;

export type ZoneTagsUpdateResultZoneType = "zone";
export const ZoneTagsUpdateResultZoneType = /*@__PURE__*/ S.String;

export interface ZoneTagsUpdateResultZone {
  /** Identifies the unique resource. */
  id: string;
  /** ETag identifier for optimistic concurrency control. Formatted as "v1:<hash>" where */
  etag: string;
  /** Human-readable name of the resource. */
  name: string;
  /** Contains key-value pairs of tags. */
  tags: ZoneTagsUpdateResultZoneTagsMap;
  type: ZoneTagsUpdateResultZoneType;
  /** Zone ID is required only for zone-level resources */
  zoneId: string;
}
export const ZoneTagsUpdateResultZone = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    etag: S.String,
    name: S.String,
    tags: ZoneTagsUpdateResultZoneTagsMap,
    type: ZoneTagsUpdateResultZoneType,
    zoneId: S.String.pipe(T.Body("zone_id")),
  }),
).annotate({
  identifier: "ZoneTagsUpdateResultZone",
}) as any as S.Schema<ZoneTagsUpdateResultZone>;

export type ZoneTagsUpdateResult =
  | ZoneTagsUpdateResultAccessApplication
  | ZoneTagsUpdateResultAccessApplicationPolicy
  | ZoneTagsUpdateResultAccessGroup
  | ZoneTagsUpdateResultAccount
  | ZoneTagsUpdateResultAIGateway
  | ZoneTagsUpdateResultAlertingPolicy
  | ZoneTagsUpdateResultAlertingWebhook
  | ZoneTagsUpdateResultAPIGatewayOperation
  | ZoneTagsUpdateResultCloudflaredTunnel
  | ZoneTagsUpdateResultCustomCertificate
  | ZoneTagsUpdateResultCustomHostname
  | ZoneTagsUpdateResultD1Database
  | ZoneTagsUpdateResultDNSRecord
  | ZoneTagsUpdateResultDurableObjectNamespace
  | ZoneTagsUpdateResultGatewayList
  | ZoneTagsUpdateResultGatewayRule
  | ZoneTagsUpdateResultImage
  | ZoneTagsUpdateResultKVNamespace
  | ZoneTagsUpdateResultManagedClientCertificate
  | ZoneTagsUpdateResultQueue
  | ZoneTagsUpdateResultR2Bucket
  | ZoneTagsUpdateResultResourceShare
  | ZoneTagsUpdateResultStreamLiveInput
  | ZoneTagsUpdateResultStreamVideo
  | ZoneTagsUpdateResultWorker
  | ZoneTagsUpdateResultWorkerVersion
  | ZoneTagsUpdateResultZone;
export const ZoneTagsUpdateResult = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["id", "etag", "name", "tags", "type"],
    ["id", "accessApplicationId", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type"],
    ["id", "etag", "name", "tags", "type", "workerId"],
    ["id", "etag", "name", "tags", "type", "zoneId"],
  ]),
);

export type PutZoneTagResponse = ZoneTagsUpdateResult;
export const PutZoneTagResponse = /*@__PURE__*/ S.suspend(() =>
  ZoneTagsUpdateResult.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "PutZoneTagResponse",
}) as any as S.Schema<PutZoneTagResponse>;

export type DeleteAccountTagError = Forbidden | CloudflareOpError;
/** Removes all tags from a specific account-level resource. */
export const deleteAccountTag: API.OperationMethod<
  DeleteAccountTagRequest,
  DeleteAccountTagResponse,
  DeleteAccountTagError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteAccountTagRequest,
  output: DeleteAccountTagResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteZoneTagError = Forbidden | CloudflareOpError;
/** Removes all tags from a specific zone-level resource. */
export const deleteZoneTag: API.OperationMethod<
  DeleteZoneTagRequest,
  DeleteZoneTagResponse,
  DeleteZoneTagError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteZoneTagRequest,
  output: DeleteZoneTagResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetAccountTagError = Forbidden | CloudflareOpError;
/** Retrieves tags for a specific account-level resource. */
export const getAccountTag: API.OperationMethod<
  GetAccountTagRequest,
  GetAccountTagResponse,
  GetAccountTagError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetAccountTagRequest,
  output: GetAccountTagResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetZoneTagError =
  | ZoneTagResourceNotFound
  | Forbidden
  | CloudflareOpError;
/** Retrieves tags for a specific zone-level resource. */
export const getZoneTag: API.OperationMethod<
  GetZoneTagRequest,
  GetZoneTagResponse,
  GetZoneTagError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetZoneTagRequest,
  output: GetZoneTagResponse,
  errors: [
    ZoneTagResourceNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListKeysError = CloudflareOpError;
/** Lists all distinct tag keys used across resources in an account. */
export const listKeys: API.PaginatedOperationMethod<
  ListKeysRequest,
  ListKeysResponse,
  ListKeysError,
  CloudflareOpContext,
  string
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListKeysRequest,
    output: ListKeysResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "cursor",
      inputToken: "cursor",
      outputToken: "resultInfo.cursors.after",
      items: "result",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListResourceTaggingsError = CloudflareOpError;
/** Lists all tagged resources for an account. */
export const listResourceTaggings: API.PaginatedOperationMethod<
  ListResourceTaggingsRequest,
  ListResourceTaggingsResponse,
  ListResourceTaggingsError,
  CloudflareOpContext,
  ListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListResourceTaggingsRequest,
    output: ListResourceTaggingsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "cursor",
      inputToken: "cursor",
      outputToken: "resultInfo.cursors.after",
      items: "result",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListValuesError = CloudflareOpError;
/** Lists all distinct values for a given tag key, optionally filtered by resource type. */
export const listValues: API.PaginatedOperationMethod<
  ListValuesRequest,
  ListValuesResponse,
  ListValuesError,
  CloudflareOpContext,
  string
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListValuesRequest,
    output: ListValuesResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "cursor",
      inputToken: "cursor",
      outputToken: "resultInfo.cursors.after",
      items: "result",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type PutAccountTagError =
  | Forbidden
  | TagPreconditionFailed
  | CloudflareOpError;
/** Creates or updates tags for a specific account-level resource. */
export const putAccountTag: API.OperationMethod<
  PutAccountTagRequest,
  PutAccountTagResponse,
  PutAccountTagError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PutAccountTagRequest,
  output: PutAccountTagResponse,
  errors: [
    Forbidden,
    TagPreconditionFailed,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PutZoneTagError =
  | ZoneTagResourceNotFound
  | Forbidden
  | TagPreconditionFailed
  | CloudflareOpError;
/** Creates or updates tags for a specific zone-level resource. Replaces all existing tags for the resource. */
export const putZoneTag: API.OperationMethod<
  PutZoneTagRequest,
  PutZoneTagResponse,
  PutZoneTagError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PutZoneTagRequest,
  output: PutZoneTagResponse,
  errors: [
    ZoneTagResourceNotFound,
    Forbidden,
    TagPreconditionFailed,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));