// 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>> = {
  endTs: "end_ts",
  modifiedOn: "modified_on",
  obtainedCodes: "obtained_codes",
  originIp: "origin_ip",
  perPage: "per_page",
  purgeEverything: "purge_everything",
  resultInfo: "result_info",
  startTs: "start_ts",
  totalCount: "total_count",
};

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

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

export class SettingUnavailableForPlan
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<SettingUnavailableForPlan>()(
      "SettingUnavailableForPlan",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [
      { status: 403, message: { includes: "not available for your plan" } },
      { code: 1135, message: { includes: "not available for your plan" } },
    ],
  ) {}

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

export class VariantsNotConfigured
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<VariantsNotConfigured>()(
      "VariantsNotConfigured",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ status: 404, message: { includes: "zone setting does not exist" } }],
  ) {}

export interface BulkDeleteOriginCloudRegionsRequest {
  /** Identifier. */
  zoneId: string;
}
export const BulkDeleteOriginCloudRegionsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/zones/{zone_id}/origin/cloud_regions/batch",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "BulkDeleteOriginCloudRegionsRequest",
}) as any as S.Schema<BulkDeleteOriginCloudRegionsRequest>;

export interface OriginCloudRegionsBulkDeleteResponseFailedItem {
  /** The origin IP address for this item. */
  originIp: string;
  /** Error message explaining why the item failed. Present only on failed items. */
  error?: string | null;
  /** Cloud vendor region identifier. Present on succeeded items (the new value for upsert, the deleted value for delete). */
  region?: string | null;
  /** Cloud vendor identifier. Present on succeeded items (the new value for upsert, the deleted value for delete). */
  vendor?: string | null;
}
export const OriginCloudRegionsBulkDeleteResponseFailedItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      originIp: S.String.pipe(T.Body("origin_ip")),
      error: S.optional(S.NullOr(S.String)),
      region: S.optional(S.NullOr(S.String)),
      vendor: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "OriginCloudRegionsBulkDeleteResponseFailedItem",
  }) as any as S.Schema<OriginCloudRegionsBulkDeleteResponseFailedItem>;

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

export type OriginCloudRegionsBulkDeleteResponseSucceededItem =
  OriginCloudRegionsBulkDeleteResponseFailedItem;
export const OriginCloudRegionsBulkDeleteResponseSucceededItem =
  OriginCloudRegionsBulkDeleteResponseFailedItem;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface BulkDeleteOriginCloudRegionsResponse {
  /** Items that could not be applied, with error details. */
  failed: OriginCloudRegionsBulkDeleteResponseFailedList;
  /** Items that were successfully applied. */
  succeeded: OriginCloudRegionsBulkDeleteResponseSucceededList;
}
export const BulkDeleteOriginCloudRegionsResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      failed: OriginCloudRegionsBulkDeleteResponseFailedList,
      succeeded: OriginCloudRegionsBulkDeleteResponseSucceededList,
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "BulkDeleteOriginCloudRegionsResponse",
}) as any as S.Schema<BulkDeleteOriginCloudRegionsResponse>;

export type OriginCloudRegionsBulkUpdateRequestBodyItemVendor =
  | "aws"
  | "azure"
  | "gcp"
  | "oci";
export const OriginCloudRegionsBulkUpdateRequestBodyItemVendor =
  /*@__PURE__*/ S.String;

export interface OriginCloudRegionsBulkUpdateRequestBodyItem {
  /** Origin IP address (IPv4 or IPv6). For the single PUT endpoint (`PUT /origin/cloud_regions/{origin_ip}`), this field must match the path parameter or the request will be rejected with a 400 error. For the batch PUT endpoint, this field identifies which mapping to upsert. */
  originIp: string;
  /** Cloud vendor region identifier. Must be a valid region for the specified vendor as returned by the supported_regions endpoint. */
  region: string;
  /** Cloud vendor hosting the origin. Must be one of the supported vendors. */
  vendor: OriginCloudRegionsBulkUpdateRequestBodyItemVendor | (string & {});
}
export const OriginCloudRegionsBulkUpdateRequestBodyItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      originIp: S.String.pipe(T.Body("origin_ip")),
      region: S.String,
      vendor: OriginCloudRegionsBulkUpdateRequestBodyItemVendor,
    }),
  ).annotate({
    identifier: "OriginCloudRegionsBulkUpdateRequestBodyItem",
  }) as any as S.Schema<OriginCloudRegionsBulkUpdateRequestBodyItem>;

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

export interface BulkPutOriginCloudRegionsRequest {
  /** Identifier. */
  zoneId: string;
  body: OriginCloudRegionsBulkUpdateRequestBodyList;
}
export const BulkPutOriginCloudRegionsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    body: OriginCloudRegionsBulkUpdateRequestBodyList.pipe(T.HttpBody()),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/zones/{zone_id}/origin/cloud_regions/batch",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "BulkPutOriginCloudRegionsRequest",
}) as any as S.Schema<BulkPutOriginCloudRegionsRequest>;

export type OriginCloudRegionsBulkUpdateResponseFailedItem =
  OriginCloudRegionsBulkDeleteResponseFailedItem;
export const OriginCloudRegionsBulkUpdateResponseFailedItem =
  OriginCloudRegionsBulkDeleteResponseFailedItem;

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

export type OriginCloudRegionsBulkUpdateResponseSucceededItem =
  OriginCloudRegionsBulkDeleteResponseFailedItem;
export const OriginCloudRegionsBulkUpdateResponseSucceededItem =
  OriginCloudRegionsBulkDeleteResponseFailedItem;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface BulkPutOriginCloudRegionsResponse {
  /** Items that could not be applied, with error details. */
  failed: OriginCloudRegionsBulkUpdateResponseFailedList;
  /** Items that were successfully applied. */
  succeeded: OriginCloudRegionsBulkUpdateResponseSucceededList;
}
export const BulkPutOriginCloudRegionsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    failed: OriginCloudRegionsBulkUpdateResponseFailedList,
    succeeded: OriginCloudRegionsBulkUpdateResponseSucceededList,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "BulkPutOriginCloudRegionsResponse",
}) as any as S.Schema<BulkPutOriginCloudRegionsResponse>;

export interface ClearCacheReserveRequest {
  /** Identifier. */
  zoneId: string;
}
export const ClearCacheReserveRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/zones/{zone_id}/cache/cache_reserve_clear",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ClearCacheReserveRequest",
}) as any as S.Schema<ClearCacheReserveRequest>;

export type CacheReserveClearResponseId = "cache_reserve_clear";
export const CacheReserveClearResponseId = /*@__PURE__*/ S.String;

export type CacheReserveClearResponseState = "In-progress" | "Completed";
export const CacheReserveClearResponseState = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface ClearCacheReserveResponse {
  /** ID of the zone setting. */
  id: CacheReserveClearResponseId;
  /** The time that the latest Cache Reserve Clear operation started. */
  startTs: string;
  /** The current state of the Cache Reserve Clear operation. */
  state: CacheReserveClearResponseState;
  /** The time that the latest Cache Reserve Clear operation completed. */
  endTs?: string | null;
  /** Last time this setting was modified. */
  modifiedOn?: string | null;
}
export const ClearCacheReserveResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: CacheReserveClearResponseId,
    startTs: S.String.pipe(T.Body("start_ts")),
    state: CacheReserveClearResponseState,
    endTs: S.optional(S.NullOr(S.String).pipe(T.Body("end_ts"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ClearCacheReserveResponse",
}) as any as S.Schema<ClearCacheReserveResponse>;

export type SmartTieredCacheCreateRequestValue = "on" | "off";
export const SmartTieredCacheCreateRequestValue = /*@__PURE__*/ S.String;

export interface CreateSmartTieredCacheRequest {
  /** Identifier. */
  zoneId: string;
  /** Enable or disable the Smart Tiered Cache. */
  value: SmartTieredCacheCreateRequestValue | (string & {});
}
export const CreateSmartTieredCacheRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    value: SmartTieredCacheCreateRequestValue,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/zones/{zone_id}/cache/tiered_cache_smart_topology_enable",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateSmartTieredCacheRequest",
}) as any as S.Schema<CreateSmartTieredCacheRequest>;

export type SmartTieredCacheCreateResponseId =
  "tiered_cache_smart_topology_enable";
export const SmartTieredCacheCreateResponseId = /*@__PURE__*/ S.String;

export type SmartTieredCacheCreateResponseValue = "on" | "off";
export const SmartTieredCacheCreateResponseValue = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateSmartTieredCacheResponse {
  /** The identifier of the caching setting. */
  id: SmartTieredCacheCreateResponseId;
  /** Whether the setting is editable. */
  editable: boolean;
  /** Value of the Smart Tiered Cache zone setting. */
  value: SmartTieredCacheCreateResponseValue;
  /** Last time this setting was modified. */
  modifiedOn?: string | null;
}
export const CreateSmartTieredCacheResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: SmartTieredCacheCreateResponseId,
    editable: S.Boolean,
    value: SmartTieredCacheCreateResponseValue,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateSmartTieredCacheResponse",
}) as any as S.Schema<CreateSmartTieredCacheResponse>;

export interface DeleteOriginCloudRegionRequest {
  /** Identifier. */
  zoneId: string;
  originIP: string;
}
export const DeleteOriginCloudRegionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    originIP: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/zones/{zone_id}/origin/cloud_regions/{originIP}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteOriginCloudRegionRequest",
}) as any as S.Schema<DeleteOriginCloudRegionRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteOriginCloudRegionResponse {
  /** The origin IP address whose mapping was deleted. */
  originIp: string;
}
export const DeleteOriginCloudRegionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    originIp: S.String.pipe(T.Body("origin_ip")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteOriginCloudRegionResponse",
}) as any as S.Schema<DeleteOriginCloudRegionResponse>;

export interface DeleteSmartTieredCacheRequest {
  /** Identifier. */
  zoneId: string;
}
export const DeleteSmartTieredCacheRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/zones/{zone_id}/cache/tiered_cache_smart_topology_enable",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteSmartTieredCacheRequest",
}) as any as S.Schema<DeleteSmartTieredCacheRequest>;

export type SmartTieredCacheDeleteResponseId =
  "tiered_cache_smart_topology_enable";
export const SmartTieredCacheDeleteResponseId = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteSmartTieredCacheResponse {
  /** The identifier of the caching setting. */
  id: SmartTieredCacheDeleteResponseId;
  /** Whether the setting is editable. */
  editable: boolean;
  /** Last time this setting was modified. */
  modifiedOn?: string | null;
}
export const DeleteSmartTieredCacheResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: SmartTieredCacheDeleteResponseId,
    editable: S.Boolean,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteSmartTieredCacheResponse",
}) as any as S.Schema<DeleteSmartTieredCacheResponse>;

export interface DeleteVariantRequest {
  /** Identifier. */
  zoneId: string;
}
export const DeleteVariantRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/zones/{zone_id}/cache/variants",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteVariantRequest",
}) as any as S.Schema<DeleteVariantRequest>;

export type VariantsDeleteResponseId = "variants";
export const VariantsDeleteResponseId = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteVariantResponse {
  /** The identifier of the caching setting. */
  id: VariantsDeleteResponseId;
  /** Whether the setting is editable. */
  editable: boolean;
  /** Last time this setting was modified. */
  modifiedOn?: string | null;
}
export const DeleteVariantResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: VariantsDeleteResponseId,
    editable: S.Boolean,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteVariantResponse",
}) as any as S.Schema<DeleteVariantResponse>;

export interface GetCacheReserveRequest {
  /** Identifier. */
  zoneId: string;
}
export const GetCacheReserveRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/cache/cache_reserve",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetCacheReserveRequest",
}) as any as S.Schema<GetCacheReserveRequest>;

export type CacheReserveGetResponseId = "cache_reserve";
export const CacheReserveGetResponseId = /*@__PURE__*/ S.String;

export type CacheReserveGetResponseValue = "on" | "off";
export const CacheReserveGetResponseValue = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetCacheReserveResponse {
  /** The identifier of the caching setting. */
  id: CacheReserveGetResponseId;
  /** Whether the setting is editable. */
  editable: boolean;
  /** Value of the Cache Reserve zone setting. */
  value: CacheReserveGetResponseValue;
  /** Last time this setting was modified. */
  modifiedOn?: string | null;
}
export const GetCacheReserveResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: CacheReserveGetResponseId,
    editable: S.Boolean,
    value: CacheReserveGetResponseValue,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetCacheReserveResponse",
}) as any as S.Schema<GetCacheReserveResponse>;

export interface GetOriginCloudRegionRequest {
  /** Identifier. */
  zoneId: string;
  originIP: string;
}
export const GetOriginCloudRegionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    originIP: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/origin/cloud_regions/{originIP}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetOriginCloudRegionRequest",
}) as any as S.Schema<GetOriginCloudRegionRequest>;

export type OriginCloudRegionsGetResponseVendor =
  | "aws"
  | "azure"
  | "gcp"
  | "oci";
export const OriginCloudRegionsGetResponseVendor = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetOriginCloudRegionResponse {
  /** The origin IP address (IPv4 or IPv6). Normalized to canonical form (RFC 5952 for IPv6). */
  originIp: string;
  /** Cloud vendor region identifier. */
  region: string;
  /** Cloud vendor hosting the origin. */
  vendor: OriginCloudRegionsGetResponseVendor;
  /** Time this mapping was last modified. */
  modifiedOn?: string | null;
}
export const GetOriginCloudRegionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    originIp: S.String.pipe(T.Body("origin_ip")),
    region: S.String,
    vendor: OriginCloudRegionsGetResponseVendor,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetOriginCloudRegionResponse",
}) as any as S.Schema<GetOriginCloudRegionResponse>;

export interface GetRegionalTieredCacheRequest {
  /** Identifier. */
  zoneId: string;
}
export const GetRegionalTieredCacheRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/cache/regional_tiered_cache",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetRegionalTieredCacheRequest",
}) as any as S.Schema<GetRegionalTieredCacheRequest>;

export type RegionalTieredCacheGetResponseId = "tc_regional";
export const RegionalTieredCacheGetResponseId = /*@__PURE__*/ S.String;

export type RegionalTieredCacheGetResponseValue = "on" | "off";
export const RegionalTieredCacheGetResponseValue = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetRegionalTieredCacheResponse {
  /** The identifier of the caching setting. */
  id: RegionalTieredCacheGetResponseId;
  /** Whether the setting is editable. */
  editable: boolean;
  /** Value of the Regional Tiered Cache zone setting. */
  value: RegionalTieredCacheGetResponseValue;
  /** Last time this setting was modified. */
  modifiedOn?: string | null;
}
export const GetRegionalTieredCacheResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: RegionalTieredCacheGetResponseId,
    editable: S.Boolean,
    value: RegionalTieredCacheGetResponseValue,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetRegionalTieredCacheResponse",
}) as any as S.Schema<GetRegionalTieredCacheResponse>;

export interface GetSmartTieredCacheRequest {
  /** Identifier. */
  zoneId: string;
}
export const GetSmartTieredCacheRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/cache/tiered_cache_smart_topology_enable",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSmartTieredCacheRequest",
}) as any as S.Schema<GetSmartTieredCacheRequest>;

export type SmartTieredCacheGetResponseId =
  "tiered_cache_smart_topology_enable";
export const SmartTieredCacheGetResponseId = /*@__PURE__*/ S.String;

export type SmartTieredCacheGetResponseValue = "on" | "off";
export const SmartTieredCacheGetResponseValue = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetSmartTieredCacheResponse {
  /** The identifier of the caching setting. */
  id: SmartTieredCacheGetResponseId;
  /** Whether the setting is editable. */
  editable: boolean;
  /** Value of the Smart Tiered Cache zone setting. */
  value: SmartTieredCacheGetResponseValue;
  /** Last time this setting was modified. */
  modifiedOn?: string | null;
}
export const GetSmartTieredCacheResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: SmartTieredCacheGetResponseId,
    editable: S.Boolean,
    value: SmartTieredCacheGetResponseValue,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSmartTieredCacheResponse",
}) as any as S.Schema<GetSmartTieredCacheResponse>;

export interface GetVariantRequest {
  /** Identifier. */
  zoneId: string;
}
export const GetVariantRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/cache/variants",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetVariantRequest",
}) as any as S.Schema<GetVariantRequest>;

export type VariantsGetResponseId = "variants";
export const VariantsGetResponseId = /*@__PURE__*/ S.String;

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

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

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

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

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

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

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

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

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

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

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

export interface VariantsGetResponseValue {
  /** List of strings with the MIME types of all the variants that should be served for avif. */
  avif?: VariantsGetResponseValueAvifList | null;
  /** List of strings with the MIME types of all the variants that should be served for bmp. */
  bmp?: VariantsGetResponseValueBmpList | null;
  /** List of strings with the MIME types of all the variants that should be served for gif. */
  gif?: VariantsGetResponseValueGifList | null;
  /** List of strings with the MIME types of all the variants that should be served for jp2. */
  jp2?: VariantsGetResponseValueJp2List | null;
  /** List of strings with the MIME types of all the variants that should be served for jpeg. */
  jpeg?: VariantsGetResponseValueJpegList | null;
  /** List of strings with the MIME types of all the variants that should be served for jpg. */
  jpg?: VariantsGetResponseValueJpgList | null;
  /** List of strings with the MIME types of all the variants that should be served for jpg2. */
  jpg2?: VariantsGetResponseValueJpg2List | null;
  /** List of strings with the MIME types of all the variants that should be served for png. */
  png?: VariantsGetResponseValuePngList | null;
  /** List of strings with the MIME types of all the variants that should be served for tif. */
  tif?: VariantsGetResponseValueTifList | null;
  /** List of strings with the MIME types of all the variants that should be served for tiff. */
  tiff?: VariantsGetResponseValueTiffList | null;
  /** List of strings with the MIME types of all the variants that should be served for webp. */
  webp?: VariantsGetResponseValueWebpList | null;
}
export const VariantsGetResponseValue = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    avif: S.optional(S.NullOr(VariantsGetResponseValueAvifList)),
    bmp: S.optional(S.NullOr(VariantsGetResponseValueBmpList)),
    gif: S.optional(S.NullOr(VariantsGetResponseValueGifList)),
    jp2: S.optional(S.NullOr(VariantsGetResponseValueJp2List)),
    jpeg: S.optional(S.NullOr(VariantsGetResponseValueJpegList)),
    jpg: S.optional(S.NullOr(VariantsGetResponseValueJpgList)),
    jpg2: S.optional(S.NullOr(VariantsGetResponseValueJpg2List)),
    png: S.optional(S.NullOr(VariantsGetResponseValuePngList)),
    tif: S.optional(S.NullOr(VariantsGetResponseValueTifList)),
    tiff: S.optional(S.NullOr(VariantsGetResponseValueTiffList)),
    webp: S.optional(S.NullOr(VariantsGetResponseValueWebpList)),
  }),
).annotate({
  identifier: "VariantsGetResponseValue",
}) as any as S.Schema<VariantsGetResponseValue>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetVariantResponse {
  /** The identifier of the caching setting. */
  id: VariantsGetResponseId;
  /** Whether the setting is editable. */
  editable: boolean;
  /** Value of the zone setting. */
  value: VariantsGetResponseValue;
  /** Last time this setting was modified. */
  modifiedOn?: string | null;
}
export const GetVariantResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: VariantsGetResponseId,
    editable: S.Boolean,
    value: VariantsGetResponseValue,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetVariantResponse",
}) as any as S.Schema<GetVariantResponse>;

export interface ListOriginCloudRegionsRequest {
  /** Identifier. */
  zoneId: string;
  /** Page number of paginated results. */
  page?: number;
  /** Number of items per page. */
  perPage?: number;
}
export const ListOriginCloudRegionsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/origin/cloud_regions",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListOriginCloudRegionsRequest",
}) as any as S.Schema<ListOriginCloudRegionsRequest>;

export type OriginCloudRegionsListResultItemVendor =
  | "aws"
  | "azure"
  | "gcp"
  | "oci";
export const OriginCloudRegionsListResultItemVendor = /*@__PURE__*/ S.String;

export interface OriginCloudRegionsListResultItem {
  /** The origin IP address (IPv4 or IPv6). Normalized to canonical form (RFC 5952 for IPv6). */
  originIp: string;
  /** Cloud vendor region identifier. */
  region: string;
  /** Cloud vendor hosting the origin. */
  vendor: OriginCloudRegionsListResultItemVendor;
  /** Time this mapping was last modified. */
  modifiedOn?: string | null;
}
export const OriginCloudRegionsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    originIp: S.String.pipe(T.Body("origin_ip")),
    region: S.String,
    vendor: OriginCloudRegionsListResultItemVendor,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }),
).annotate({
  identifier: "OriginCloudRegionsListResultItem",
}) as any as S.Schema<OriginCloudRegionsListResultItem>;

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

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

export interface OriginCloudRegionsBulkDeleteV1Request {
  /** Identifier. */
  zoneId: string;
}
export const OriginCloudRegionsBulkDeleteV1Request = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      zoneId: S.String.pipe(T.Label("zone_id")),
    })
      .pipe(
        T.Http({
          method: "DELETE",
          uri: "/zones/{zone_id}/cache/origin_cloud_regions/batch",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsBulkDeleteV1Request",
}) as any as S.Schema<OriginCloudRegionsBulkDeleteV1Request>;

export type OriginCloudRegionsBulkDeleteV1ResponseId =
  "origin_public_cloud_region";
export const OriginCloudRegionsBulkDeleteV1ResponseId = /*@__PURE__*/ S.String;

export interface OriginCloudRegionsBulkDeleteV1ResponseValueFailedItem {
  /** The origin IP address for this item. */
  originIp: string;
  /** Error message explaining why the item failed. Present only on failed items. */
  error?: string | null;
  /** Cloud vendor region identifier. Present on succeeded items for patch operations. */
  region?: string | null;
  /** Cloud vendor identifier. Present on succeeded items for patch operations. */
  vendor?: string | null;
}
export const OriginCloudRegionsBulkDeleteV1ResponseValueFailedItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      originIp: S.String.pipe(T.Body("origin-ip")),
      error: S.optional(S.NullOr(S.String)),
      region: S.optional(S.NullOr(S.String)),
      vendor: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "OriginCloudRegionsBulkDeleteV1ResponseValueFailedItem",
  }) as any as S.Schema<OriginCloudRegionsBulkDeleteV1ResponseValueFailedItem>;

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

export type OriginCloudRegionsBulkDeleteV1ResponseValueSucceededItem =
  OriginCloudRegionsBulkDeleteV1ResponseValueFailedItem;
export const OriginCloudRegionsBulkDeleteV1ResponseValueSucceededItem =
  OriginCloudRegionsBulkDeleteV1ResponseValueFailedItem;

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

export interface OriginCloudRegionsBulkDeleteV1ResponseValue {
  /** Items that could not be applied, with error details. */
  failed: OriginCloudRegionsBulkDeleteV1ResponseValueFailedList;
  /** Items that were successfully applied. */
  succeeded: OriginCloudRegionsBulkDeleteV1ResponseValueSucceededList;
}
export const OriginCloudRegionsBulkDeleteV1ResponseValue =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      failed: OriginCloudRegionsBulkDeleteV1ResponseValueFailedList,
      succeeded: OriginCloudRegionsBulkDeleteV1ResponseValueSucceededList,
    }),
  ).annotate({
    identifier: "OriginCloudRegionsBulkDeleteV1ResponseValue",
  }) as any as S.Schema<OriginCloudRegionsBulkDeleteV1ResponseValue>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface OriginCloudRegionsBulkDeleteV1Response {
  id: OriginCloudRegionsBulkDeleteV1ResponseId;
  /** Whether the setting can be modified by the current user. */
  editable: boolean;
  value: OriginCloudRegionsBulkDeleteV1ResponseValue;
  /** Time the mapping set was last modified. Null when no items were successfully applied. */
  modifiedOn?: string | null;
}
export const OriginCloudRegionsBulkDeleteV1Response = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: OriginCloudRegionsBulkDeleteV1ResponseId,
      editable: S.Boolean,
      value: OriginCloudRegionsBulkDeleteV1ResponseValue,
      modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsBulkDeleteV1Response",
}) as any as S.Schema<OriginCloudRegionsBulkDeleteV1Response>;

export type OriginCloudRegionsBulkEditV1RequestBodyItemVendor =
  | "aws"
  | "azure"
  | "gcp"
  | "oci";
export const OriginCloudRegionsBulkEditV1RequestBodyItemVendor =
  /*@__PURE__*/ S.String;

export interface OriginCloudRegionsBulkEditV1RequestBodyItem {
  /** Origin IP address (IPv4 or IPv6). Normalized to canonical form before storage (RFC 5952 for IPv6). */
  ip: string;
  /** Cloud vendor region identifier. Must be a valid region for the specified vendor as returned by the supported_regions endpoint. */
  region: string;
  /** Cloud vendor hosting the origin. Must be one of the supported vendors. */
  vendor: OriginCloudRegionsBulkEditV1RequestBodyItemVendor | (string & {});
}
export const OriginCloudRegionsBulkEditV1RequestBodyItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      ip: S.String,
      region: S.String,
      vendor: OriginCloudRegionsBulkEditV1RequestBodyItemVendor,
    }),
  ).annotate({
    identifier: "OriginCloudRegionsBulkEditV1RequestBodyItem",
  }) as any as S.Schema<OriginCloudRegionsBulkEditV1RequestBodyItem>;

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

export interface OriginCloudRegionsBulkEditV1Request {
  /** Identifier. */
  zoneId: string;
  body: OriginCloudRegionsBulkEditV1RequestBodyList;
}
export const OriginCloudRegionsBulkEditV1Request = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    body: OriginCloudRegionsBulkEditV1RequestBodyList.pipe(T.HttpBody()),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/zones/{zone_id}/cache/origin_cloud_regions/batch",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsBulkEditV1Request",
}) as any as S.Schema<OriginCloudRegionsBulkEditV1Request>;

export type OriginCloudRegionsBulkEditV1ResponseId =
  "origin_public_cloud_region";
export const OriginCloudRegionsBulkEditV1ResponseId = /*@__PURE__*/ S.String;

export type OriginCloudRegionsBulkEditV1ResponseValueFailedItem =
  OriginCloudRegionsBulkDeleteV1ResponseValueFailedItem;
export const OriginCloudRegionsBulkEditV1ResponseValueFailedItem =
  OriginCloudRegionsBulkDeleteV1ResponseValueFailedItem;

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

export type OriginCloudRegionsBulkEditV1ResponseValueSucceededItem =
  OriginCloudRegionsBulkDeleteV1ResponseValueFailedItem;
export const OriginCloudRegionsBulkEditV1ResponseValueSucceededItem =
  OriginCloudRegionsBulkDeleteV1ResponseValueFailedItem;

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

export interface OriginCloudRegionsBulkEditV1ResponseValue {
  /** Items that could not be applied, with error details. */
  failed: OriginCloudRegionsBulkEditV1ResponseValueFailedList;
  /** Items that were successfully applied. */
  succeeded: OriginCloudRegionsBulkEditV1ResponseValueSucceededList;
}
export const OriginCloudRegionsBulkEditV1ResponseValue =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      failed: OriginCloudRegionsBulkEditV1ResponseValueFailedList,
      succeeded: OriginCloudRegionsBulkEditV1ResponseValueSucceededList,
    }),
  ).annotate({
    identifier: "OriginCloudRegionsBulkEditV1ResponseValue",
  }) as any as S.Schema<OriginCloudRegionsBulkEditV1ResponseValue>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface OriginCloudRegionsBulkEditV1Response {
  id: OriginCloudRegionsBulkEditV1ResponseId;
  /** Whether the setting can be modified by the current user. */
  editable: boolean;
  value: OriginCloudRegionsBulkEditV1ResponseValue;
  /** Time the mapping set was last modified. Null when no items were successfully applied. */
  modifiedOn?: string | null;
}
export const OriginCloudRegionsBulkEditV1Response = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: OriginCloudRegionsBulkEditV1ResponseId,
      editable: S.Boolean,
      value: OriginCloudRegionsBulkEditV1ResponseValue,
      modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsBulkEditV1Response",
}) as any as S.Schema<OriginCloudRegionsBulkEditV1Response>;

export type OriginCloudRegionsCreateV1RequestVendor =
  | "aws"
  | "azure"
  | "gcp"
  | "oci";
export const OriginCloudRegionsCreateV1RequestVendor = /*@__PURE__*/ S.String;

export interface OriginCloudRegionsCreateV1Request {
  /** Identifier. */
  zoneId: string;
  /** Origin IP address (IPv4 or IPv6). Normalized to canonical form before storage (RFC 5952 for IPv6). */
  ip: string;
  /** Cloud vendor region identifier. Must be a valid region for the specified vendor as returned by the supported_regions endpoint. */
  region: string;
  /** Cloud vendor hosting the origin. Must be one of the supported vendors. */
  vendor: OriginCloudRegionsCreateV1RequestVendor | (string & {});
}
export const OriginCloudRegionsCreateV1Request = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    ip: S.String,
    region: S.String,
    vendor: OriginCloudRegionsCreateV1RequestVendor,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/zones/{zone_id}/cache/origin_cloud_regions",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsCreateV1Request",
}) as any as S.Schema<OriginCloudRegionsCreateV1Request>;

export type OriginCloudRegionsCreateV1ResponseId = "origin_public_cloud_region";
export const OriginCloudRegionsCreateV1ResponseId = /*@__PURE__*/ S.String;

export type OriginCloudRegionsCreateV1ResponseValueVendor =
  | "aws"
  | "azure"
  | "gcp"
  | "oci";
export const OriginCloudRegionsCreateV1ResponseValueVendor =
  /*@__PURE__*/ S.String;

export interface OriginCloudRegionsCreateV1ResponseValue {
  /** The origin IP address (IPv4 or IPv6, canonicalized). */
  originIp: string;
  /** Cloud vendor region identifier. */
  region: string;
  /** Cloud vendor hosting the origin. */
  vendor: OriginCloudRegionsCreateV1ResponseValueVendor;
  /** Time this mapping was last modified. */
  modifiedOn?: string | null;
}
export const OriginCloudRegionsCreateV1ResponseValue = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      originIp: S.String.pipe(T.Body("origin-ip")),
      region: S.String,
      vendor: OriginCloudRegionsCreateV1ResponseValueVendor,
      modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    }),
).annotate({
  identifier: "OriginCloudRegionsCreateV1ResponseValue",
}) as any as S.Schema<OriginCloudRegionsCreateV1ResponseValue>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface OriginCloudRegionsCreateV1Response {
  id: OriginCloudRegionsCreateV1ResponseId;
  /** Whether the setting can be modified by the current user. */
  editable: boolean;
  /** A single origin IP-to-cloud-region mapping. */
  value: OriginCloudRegionsCreateV1ResponseValue;
  /** Time the mapping was last modified. */
  modifiedOn?: string | null;
}
export const OriginCloudRegionsCreateV1Response = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: OriginCloudRegionsCreateV1ResponseId,
    editable: S.Boolean,
    value: OriginCloudRegionsCreateV1ResponseValue,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsCreateV1Response",
}) as any as S.Schema<OriginCloudRegionsCreateV1Response>;

export interface OriginCloudRegionsDeleteV1Request {
  /** Identifier. */
  zoneId: string;
  originIp: string;
}
export const OriginCloudRegionsDeleteV1Request = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    originIp: S.String.pipe(T.Label("origin_ip")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/zones/{zone_id}/cache/origin_cloud_regions/{origin_ip}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsDeleteV1Request",
}) as any as S.Schema<OriginCloudRegionsDeleteV1Request>;

export type OriginCloudRegionsDeleteV1ResponseId = "origin_public_cloud_region";
export const OriginCloudRegionsDeleteV1ResponseId = /*@__PURE__*/ S.String;

export type OriginCloudRegionsDeleteV1ResponseValueVendor =
  | "aws"
  | "azure"
  | "gcp"
  | "oci";
export const OriginCloudRegionsDeleteV1ResponseValueVendor =
  /*@__PURE__*/ S.String;

export interface OriginCloudRegionsDeleteV1ResponseValue {
  /** The origin IP address (IPv4 or IPv6, canonicalized). */
  originIp: string;
  /** Cloud vendor region identifier. */
  region: string;
  /** Cloud vendor hosting the origin. */
  vendor: OriginCloudRegionsDeleteV1ResponseValueVendor;
  /** Time this mapping was last modified. */
  modifiedOn?: string | null;
}
export const OriginCloudRegionsDeleteV1ResponseValue = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      originIp: S.String.pipe(T.Body("origin-ip")),
      region: S.String,
      vendor: OriginCloudRegionsDeleteV1ResponseValueVendor,
      modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    }),
).annotate({
  identifier: "OriginCloudRegionsDeleteV1ResponseValue",
}) as any as S.Schema<OriginCloudRegionsDeleteV1ResponseValue>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface OriginCloudRegionsDeleteV1Response {
  id: OriginCloudRegionsDeleteV1ResponseId;
  /** Whether the setting can be modified by the current user. */
  editable: boolean;
  /** A single origin IP-to-cloud-region mapping. */
  value: OriginCloudRegionsDeleteV1ResponseValue;
  /** Time the mapping was last modified. */
  modifiedOn?: string | null;
}
export const OriginCloudRegionsDeleteV1Response = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: OriginCloudRegionsDeleteV1ResponseId,
    editable: S.Boolean,
    value: OriginCloudRegionsDeleteV1ResponseValue,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsDeleteV1Response",
}) as any as S.Schema<OriginCloudRegionsDeleteV1Response>;

export type OriginCloudRegionsEditV1RequestVendor =
  | "aws"
  | "azure"
  | "gcp"
  | "oci";
export const OriginCloudRegionsEditV1RequestVendor = /*@__PURE__*/ S.String;

export interface OriginCloudRegionsEditV1Request {
  /** Identifier. */
  zoneId: string;
  /** Origin IP address (IPv4 or IPv6). Normalized to canonical form before storage (RFC 5952 for IPv6). */
  ip: string;
  /** Cloud vendor region identifier. Must be a valid region for the specified vendor as returned by the supported_regions endpoint. */
  region: string;
  /** Cloud vendor hosting the origin. Must be one of the supported vendors. */
  vendor: OriginCloudRegionsEditV1RequestVendor | (string & {});
}
export const OriginCloudRegionsEditV1Request = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    ip: S.String,
    region: S.String,
    vendor: OriginCloudRegionsEditV1RequestVendor,
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/zones/{zone_id}/cache/origin_cloud_regions",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsEditV1Request",
}) as any as S.Schema<OriginCloudRegionsEditV1Request>;

export type OriginCloudRegionsEditV1ResponseId = "origin_public_cloud_region";
export const OriginCloudRegionsEditV1ResponseId = /*@__PURE__*/ S.String;

export type OriginCloudRegionsEditV1ResponseValueItemVendor =
  | "aws"
  | "azure"
  | "gcp"
  | "oci";
export const OriginCloudRegionsEditV1ResponseValueItemVendor =
  /*@__PURE__*/ S.String;

export interface OriginCloudRegionsEditV1ResponseValueItem {
  /** The origin IP address (IPv4 or IPv6, canonicalized). */
  originIp: string;
  /** Cloud vendor region identifier. */
  region: string;
  /** Cloud vendor hosting the origin. */
  vendor: OriginCloudRegionsEditV1ResponseValueItemVendor;
  /** Time this mapping was last modified. */
  modifiedOn?: string | null;
}
export const OriginCloudRegionsEditV1ResponseValueItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      originIp: S.String.pipe(T.Body("origin-ip")),
      region: S.String,
      vendor: OriginCloudRegionsEditV1ResponseValueItemVendor,
      modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    }),
  ).annotate({
    identifier: "OriginCloudRegionsEditV1ResponseValueItem",
  }) as any as S.Schema<OriginCloudRegionsEditV1ResponseValueItem>;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface OriginCloudRegionsEditV1Response {
  id: OriginCloudRegionsEditV1ResponseId;
  /** Whether the setting can be modified by the current user. */
  editable: boolean;
  value: OriginCloudRegionsEditV1ResponseValueList;
  /** Time the mapping set was last modified. Null when no mappings exist. */
  modifiedOn?: string | null;
}
export const OriginCloudRegionsEditV1Response = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: OriginCloudRegionsEditV1ResponseId,
    editable: S.Boolean,
    value: OriginCloudRegionsEditV1ResponseValueList,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsEditV1Response",
}) as any as S.Schema<OriginCloudRegionsEditV1Response>;

export interface OriginCloudRegionsGetV1Request {
  /** Identifier. */
  zoneId: string;
  originIp: string;
}
export const OriginCloudRegionsGetV1Request = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    originIp: S.String.pipe(T.Label("origin_ip")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/cache/origin_cloud_regions/{origin_ip}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsGetV1Request",
}) as any as S.Schema<OriginCloudRegionsGetV1Request>;

export type OriginCloudRegionsGetV1ResponseId = "origin_public_cloud_region";
export const OriginCloudRegionsGetV1ResponseId = /*@__PURE__*/ S.String;

export type OriginCloudRegionsGetV1ResponseValueVendor =
  | "aws"
  | "azure"
  | "gcp"
  | "oci";
export const OriginCloudRegionsGetV1ResponseValueVendor =
  /*@__PURE__*/ S.String;

export interface OriginCloudRegionsGetV1ResponseValue {
  /** The origin IP address (IPv4 or IPv6, canonicalized). */
  originIp: string;
  /** Cloud vendor region identifier. */
  region: string;
  /** Cloud vendor hosting the origin. */
  vendor: OriginCloudRegionsGetV1ResponseValueVendor;
  /** Time this mapping was last modified. */
  modifiedOn?: string | null;
}
export const OriginCloudRegionsGetV1ResponseValue = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      originIp: S.String.pipe(T.Body("origin-ip")),
      region: S.String,
      vendor: OriginCloudRegionsGetV1ResponseValueVendor,
      modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    }),
).annotate({
  identifier: "OriginCloudRegionsGetV1ResponseValue",
}) as any as S.Schema<OriginCloudRegionsGetV1ResponseValue>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface OriginCloudRegionsGetV1Response {
  id: OriginCloudRegionsGetV1ResponseId;
  /** Whether the setting can be modified by the current user. */
  editable: boolean;
  /** A single origin IP-to-cloud-region mapping. */
  value: OriginCloudRegionsGetV1ResponseValue;
  /** Time the mapping was last modified. */
  modifiedOn?: string | null;
}
export const OriginCloudRegionsGetV1Response = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: OriginCloudRegionsGetV1ResponseId,
    editable: S.Boolean,
    value: OriginCloudRegionsGetV1ResponseValue,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsGetV1Response",
}) as any as S.Schema<OriginCloudRegionsGetV1Response>;

export interface OriginCloudRegionsListV1Request {
  /** Identifier. */
  zoneId: string;
}
export const OriginCloudRegionsListV1Request = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/cache/origin_cloud_regions",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsListV1Request",
}) as any as S.Schema<OriginCloudRegionsListV1Request>;

export type OriginCloudRegionsListV1ResponseId = "origin_public_cloud_region";
export const OriginCloudRegionsListV1ResponseId = /*@__PURE__*/ S.String;

export type OriginCloudRegionsListV1ResponseValueItemVendor =
  | "aws"
  | "azure"
  | "gcp"
  | "oci";
export const OriginCloudRegionsListV1ResponseValueItemVendor =
  /*@__PURE__*/ S.String;

export interface OriginCloudRegionsListV1ResponseValueItem {
  /** The origin IP address (IPv4 or IPv6, canonicalized). */
  originIp: string;
  /** Cloud vendor region identifier. */
  region: string;
  /** Cloud vendor hosting the origin. */
  vendor: OriginCloudRegionsListV1ResponseValueItemVendor;
  /** Time this mapping was last modified. */
  modifiedOn?: string | null;
}
export const OriginCloudRegionsListV1ResponseValueItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      originIp: S.String.pipe(T.Body("origin-ip")),
      region: S.String,
      vendor: OriginCloudRegionsListV1ResponseValueItemVendor,
      modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    }),
  ).annotate({
    identifier: "OriginCloudRegionsListV1ResponseValueItem",
  }) as any as S.Schema<OriginCloudRegionsListV1ResponseValueItem>;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface OriginCloudRegionsListV1Response {
  id: OriginCloudRegionsListV1ResponseId;
  /** Whether the setting can be modified by the current user. */
  editable: boolean;
  value: OriginCloudRegionsListV1ResponseValueList;
  /** Time the mapping set was last modified. Null when no mappings exist. */
  modifiedOn?: string | null;
}
export const OriginCloudRegionsListV1Response = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: OriginCloudRegionsListV1ResponseId,
    editable: S.Boolean,
    value: OriginCloudRegionsListV1ResponseValueList,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "OriginCloudRegionsListV1Response",
}) as any as S.Schema<OriginCloudRegionsListV1Response>;

export interface OriginCloudRegionsSupportedRegionsV1Request {
  /** Identifier. */
  zoneId: string;
}
export const OriginCloudRegionsSupportedRegionsV1Request =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      zoneId: S.String.pipe(T.Label("zone_id")),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/zones/{zone_id}/cache/origin_cloud_regions/supported_regions",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "OriginCloudRegionsSupportedRegionsV1Request",
  }) as any as S.Schema<OriginCloudRegionsSupportedRegionsV1Request>;

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

export interface OriginCloudRegionsSupportedRegionsV1ResponseVendorsValueItem {
  /** Cloud vendor region identifier. */
  name: string;
  /** Cloudflare Tiered Cache upper-tier colocation codes co-located with this cloud region. Requests from zones with a matching origin mapping will be routed through these colos. */
  upperTierColos: OriginCloudRegionsSupportedRegionsV1ResponseVendorsValueItemUpperTierColosList;
}
export const OriginCloudRegionsSupportedRegionsV1ResponseVendorsValueItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      name: S.String,
      upperTierColos:
        OriginCloudRegionsSupportedRegionsV1ResponseVendorsValueItemUpperTierColosList.pipe(
          T.Body("upper_tier_colos"),
        ),
    }),
  ).annotate({
    identifier: "OriginCloudRegionsSupportedRegionsV1ResponseVendorsValueItem",
  }) as any as S.Schema<OriginCloudRegionsSupportedRegionsV1ResponseVendorsValueItem>;

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

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface OriginCloudRegionsSupportedRegionsV1Response {
  /** Whether Cloudflare airport codes (IATA colo identifiers) were successfully resolved for the `upper_tier_colos` field on each region. When `false`, the `upper_tier_colos` arrays may be empty or incomplete. */
  obtainedCodes: boolean;
  /** Map of vendor name to list of supported regions. */
  vendors: OriginCloudRegionsSupportedRegionsV1ResponseVendorsMap;
}
export const OriginCloudRegionsSupportedRegionsV1Response =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      obtainedCodes: S.Boolean.pipe(T.Body("obtained_codes")),
      vendors: OriginCloudRegionsSupportedRegionsV1ResponseVendorsMap,
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "OriginCloudRegionsSupportedRegionsV1Response",
  }) as any as S.Schema<OriginCloudRegionsSupportedRegionsV1Response>;

export type CacheReserveEditRequestValue = "on" | "off";
export const CacheReserveEditRequestValue = /*@__PURE__*/ S.String;

export interface PatchCacheReserveRequest {
  /** Identifier. */
  zoneId: string;
  /** Value of the Cache Reserve zone setting. */
  value: CacheReserveEditRequestValue | (string & {});
}
export const PatchCacheReserveRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    value: CacheReserveEditRequestValue,
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/zones/{zone_id}/cache/cache_reserve",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchCacheReserveRequest",
}) as any as S.Schema<PatchCacheReserveRequest>;

export type CacheReserveEditResponseId = "cache_reserve";
export const CacheReserveEditResponseId = /*@__PURE__*/ S.String;

export type CacheReserveEditResponseValue = "on" | "off";
export const CacheReserveEditResponseValue = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchCacheReserveResponse {
  /** The identifier of the caching setting. */
  id: CacheReserveEditResponseId;
  /** Whether the setting is editable. */
  editable: boolean;
  /** Value of the Cache Reserve zone setting. */
  value: CacheReserveEditResponseValue;
  /** Last time this setting was modified. */
  modifiedOn?: string | null;
}
export const PatchCacheReserveResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: CacheReserveEditResponseId,
    editable: S.Boolean,
    value: CacheReserveEditResponseValue,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchCacheReserveResponse",
}) as any as S.Schema<PatchCacheReserveResponse>;

export type RegionalTieredCacheEditRequestValue = "on" | "off";
export const RegionalTieredCacheEditRequestValue = /*@__PURE__*/ S.String;

export interface PatchRegionalTieredCacheRequest {
  /** Identifier. */
  zoneId: string;
  /** Value of the Regional Tiered Cache zone setting. */
  value: RegionalTieredCacheEditRequestValue | (string & {});
}
export const PatchRegionalTieredCacheRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    value: RegionalTieredCacheEditRequestValue,
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/zones/{zone_id}/cache/regional_tiered_cache",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchRegionalTieredCacheRequest",
}) as any as S.Schema<PatchRegionalTieredCacheRequest>;

export type RegionalTieredCacheEditResponseId = "tc_regional";
export const RegionalTieredCacheEditResponseId = /*@__PURE__*/ S.String;

export type RegionalTieredCacheEditResponseValue = "on" | "off";
export const RegionalTieredCacheEditResponseValue = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchRegionalTieredCacheResponse {
  /** The identifier of the caching setting. */
  id: RegionalTieredCacheEditResponseId;
  /** Whether the setting is editable. */
  editable: boolean;
  /** Value of the Regional Tiered Cache zone setting. */
  value: RegionalTieredCacheEditResponseValue;
  /** Last time this setting was modified. */
  modifiedOn?: string | null;
}
export const PatchRegionalTieredCacheResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: RegionalTieredCacheEditResponseId,
    editable: S.Boolean,
    value: RegionalTieredCacheEditResponseValue,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchRegionalTieredCacheResponse",
}) as any as S.Schema<PatchRegionalTieredCacheResponse>;

export type SmartTieredCacheEditRequestValue = "on" | "off";
export const SmartTieredCacheEditRequestValue = /*@__PURE__*/ S.String;

export interface PatchSmartTieredCacheRequest {
  /** Identifier. */
  zoneId: string;
  /** Enable or disable the Smart Tiered Cache. */
  value: SmartTieredCacheEditRequestValue | (string & {});
}
export const PatchSmartTieredCacheRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    value: SmartTieredCacheEditRequestValue,
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/zones/{zone_id}/cache/tiered_cache_smart_topology_enable",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchSmartTieredCacheRequest",
}) as any as S.Schema<PatchSmartTieredCacheRequest>;

export type SmartTieredCacheEditResponseId =
  "tiered_cache_smart_topology_enable";
export const SmartTieredCacheEditResponseId = /*@__PURE__*/ S.String;

export type SmartTieredCacheEditResponseValue = "on" | "off";
export const SmartTieredCacheEditResponseValue = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchSmartTieredCacheResponse {
  /** The identifier of the caching setting. */
  id: SmartTieredCacheEditResponseId;
  /** Whether the setting is editable. */
  editable: boolean;
  /** Value of the Smart Tiered Cache zone setting. */
  value: SmartTieredCacheEditResponseValue;
  /** Last time this setting was modified. */
  modifiedOn?: string | null;
}
export const PatchSmartTieredCacheResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: SmartTieredCacheEditResponseId,
    editable: S.Boolean,
    value: SmartTieredCacheEditResponseValue,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchSmartTieredCacheResponse",
}) as any as S.Schema<PatchSmartTieredCacheResponse>;

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

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

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

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

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

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

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

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

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

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

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

export interface VariantsEditRequestValue {
  /** List of strings with the MIME types of all the variants that should be served for avif. */
  avif?: VariantsEditRequestValueAvifList;
  /** List of strings with the MIME types of all the variants that should be served for bmp. */
  bmp?: VariantsEditRequestValueBmpList;
  /** List of strings with the MIME types of all the variants that should be served for gif. */
  gif?: VariantsEditRequestValueGifList;
  /** List of strings with the MIME types of all the variants that should be served for jp2. */
  jp2?: VariantsEditRequestValueJp2List;
  /** List of strings with the MIME types of all the variants that should be served for jpeg. */
  jpeg?: VariantsEditRequestValueJpegList;
  /** List of strings with the MIME types of all the variants that should be served for jpg. */
  jpg?: VariantsEditRequestValueJpgList;
  /** List of strings with the MIME types of all the variants that should be served for jpg2. */
  jpg2?: VariantsEditRequestValueJpg2List;
  /** List of strings with the MIME types of all the variants that should be served for png. */
  png?: VariantsEditRequestValuePngList;
  /** List of strings with the MIME types of all the variants that should be served for tif. */
  tif?: VariantsEditRequestValueTifList;
  /** List of strings with the MIME types of all the variants that should be served for tiff. */
  tiff?: VariantsEditRequestValueTiffList;
  /** List of strings with the MIME types of all the variants that should be served for webp. */
  webp?: VariantsEditRequestValueWebpList;
}
export const VariantsEditRequestValue = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    avif: S.optional(VariantsEditRequestValueAvifList),
    bmp: S.optional(VariantsEditRequestValueBmpList),
    gif: S.optional(VariantsEditRequestValueGifList),
    jp2: S.optional(VariantsEditRequestValueJp2List),
    jpeg: S.optional(VariantsEditRequestValueJpegList),
    jpg: S.optional(VariantsEditRequestValueJpgList),
    jpg2: S.optional(VariantsEditRequestValueJpg2List),
    png: S.optional(VariantsEditRequestValuePngList),
    tif: S.optional(VariantsEditRequestValueTifList),
    tiff: S.optional(VariantsEditRequestValueTiffList),
    webp: S.optional(VariantsEditRequestValueWebpList),
  }),
).annotate({
  identifier: "VariantsEditRequestValue",
}) as any as S.Schema<VariantsEditRequestValue>;

export interface PatchVariantRequest {
  /** Identifier. */
  zoneId: string;
  /** Value of the zone setting. */
  value: VariantsEditRequestValue;
}
export const PatchVariantRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    value: VariantsEditRequestValue,
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/zones/{zone_id}/cache/variants",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchVariantRequest",
}) as any as S.Schema<PatchVariantRequest>;

export type VariantsEditResponseId = "variants";
export const VariantsEditResponseId = /*@__PURE__*/ S.String;

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

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

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

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

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

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

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

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

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

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

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

export interface VariantsEditResponseValue {
  /** List of strings with the MIME types of all the variants that should be served for avif. */
  avif?: VariantsEditResponseValueAvifList | null;
  /** List of strings with the MIME types of all the variants that should be served for bmp. */
  bmp?: VariantsEditResponseValueBmpList | null;
  /** List of strings with the MIME types of all the variants that should be served for gif. */
  gif?: VariantsEditResponseValueGifList | null;
  /** List of strings with the MIME types of all the variants that should be served for jp2. */
  jp2?: VariantsEditResponseValueJp2List | null;
  /** List of strings with the MIME types of all the variants that should be served for jpeg. */
  jpeg?: VariantsEditResponseValueJpegList | null;
  /** List of strings with the MIME types of all the variants that should be served for jpg. */
  jpg?: VariantsEditResponseValueJpgList | null;
  /** List of strings with the MIME types of all the variants that should be served for jpg2. */
  jpg2?: VariantsEditResponseValueJpg2List | null;
  /** List of strings with the MIME types of all the variants that should be served for png. */
  png?: VariantsEditResponseValuePngList | null;
  /** List of strings with the MIME types of all the variants that should be served for tif. */
  tif?: VariantsEditResponseValueTifList | null;
  /** List of strings with the MIME types of all the variants that should be served for tiff. */
  tiff?: VariantsEditResponseValueTiffList | null;
  /** List of strings with the MIME types of all the variants that should be served for webp. */
  webp?: VariantsEditResponseValueWebpList | null;
}
export const VariantsEditResponseValue = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    avif: S.optional(S.NullOr(VariantsEditResponseValueAvifList)),
    bmp: S.optional(S.NullOr(VariantsEditResponseValueBmpList)),
    gif: S.optional(S.NullOr(VariantsEditResponseValueGifList)),
    jp2: S.optional(S.NullOr(VariantsEditResponseValueJp2List)),
    jpeg: S.optional(S.NullOr(VariantsEditResponseValueJpegList)),
    jpg: S.optional(S.NullOr(VariantsEditResponseValueJpgList)),
    jpg2: S.optional(S.NullOr(VariantsEditResponseValueJpg2List)),
    png: S.optional(S.NullOr(VariantsEditResponseValuePngList)),
    tif: S.optional(S.NullOr(VariantsEditResponseValueTifList)),
    tiff: S.optional(S.NullOr(VariantsEditResponseValueTiffList)),
    webp: S.optional(S.NullOr(VariantsEditResponseValueWebpList)),
  }),
).annotate({
  identifier: "VariantsEditResponseValue",
}) as any as S.Schema<VariantsEditResponseValue>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchVariantResponse {
  /** The identifier of the caching setting. */
  id: VariantsEditResponseId;
  /** Whether the setting is editable. */
  editable: boolean;
  /** Value of the zone setting. */
  value: VariantsEditResponseValue;
  /** Last time this setting was modified. */
  modifiedOn?: string | null;
}
export const PatchVariantResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: VariantsEditResponseId,
    editable: S.Boolean,
    value: VariantsEditResponseValue,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchVariantResponse",
}) as any as S.Schema<PatchVariantResponse>;

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

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

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

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

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

export interface PurgeRequestFilesCachePurgeSingleFileWithURLAndHeadersItem {
  headers?: PurgeRequestFilesCachePurgeSingleFileWithURLAndHeadersItemHeadersMap;
  url?: string;
}
export const PurgeRequestFilesCachePurgeSingleFileWithURLAndHeadersItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      headers: S.optional(
        PurgeRequestFilesCachePurgeSingleFileWithURLAndHeadersItemHeadersMap,
      ),
      url: S.optional(S.String),
    }),
  ).annotate({
    identifier: "PurgeRequestFilesCachePurgeSingleFileWithURLAndHeadersItem",
  }) as any as S.Schema<PurgeRequestFilesCachePurgeSingleFileWithURLAndHeadersItem>;

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

export type PurgeRequestFiles =
  | PurgeRequestFilesCachePurgeSingleFileList
  | PurgeRequestFilesCachePurgeSingleFileWithURLAndHeadersList;
export const PurgeRequestFiles = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([[], []]),
);

export interface PurgeCacheRequest {
  zoneId: string;
  /** For more information on cache tags and purging by tags, please refer to [purge by cache-tags documentation page](https://developers.cloudflare.com/cache/how-to/purge-cache/purge-by-tags/). */
  tags?: PurgeRequestTagsList;
  /** For more information purging by hostnames, please refer to [purge by hostname documentation page](https://developers.cloudflare.com/cache/how-to/purge-cache/purge-by-hostname/). */
  hosts?: PurgeRequestHostsList;
  /** For more information on purging by prefixes, please refer to [purge by prefix documentation page](https://developers.cloudflare.com/cache/how-to/purge-cache/purge_by_prefix/). */
  prefixes?: PurgeRequestPrefixesList;
  /** For more information, please refer to [purge everything documentation page](https://developers.cloudflare.com/cache/how-to/purge-cache/purge-everything/). */
  purgeEverything?: boolean;
  /** For more information on purging files, please refer to [purge by single-file documentation page](https://developers.cloudflare.com/cache/how-to/purge-cache/purge-by-single-file/). */
  files?: PurgeRequestFiles;
}
export const PurgeCacheRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    tags: S.optional(PurgeRequestTagsList),
    hosts: S.optional(PurgeRequestHostsList),
    prefixes: S.optional(PurgeRequestPrefixesList),
    purgeEverything: S.optional(S.Boolean.pipe(T.Body("purge_everything"))),
    files: S.optional(PurgeRequestFiles),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/zones/{zone_id}/purge_cache",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PurgeCacheRequest",
}) as any as S.Schema<PurgeCacheRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PurgeCacheResponse {
  id: string;
}
export const PurgeCacheResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PurgeCacheResponse",
}) as any as S.Schema<PurgeCacheResponse>;

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

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

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

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

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

export interface PurgeEnvironmentRequestFilesCachePurgeSingleFileWithURLAndHeadersItem {
  headers?: PurgeEnvironmentRequestFilesCachePurgeSingleFileWithURLAndHeadersItemHeadersMap;
  url?: string;
}
export const PurgeEnvironmentRequestFilesCachePurgeSingleFileWithURLAndHeadersItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      headers: S.optional(
        PurgeEnvironmentRequestFilesCachePurgeSingleFileWithURLAndHeadersItemHeadersMap,
      ),
      url: S.optional(S.String),
    }),
  ).annotate({
    identifier:
      "PurgeEnvironmentRequestFilesCachePurgeSingleFileWithURLAndHeadersItem",
  }) as any as S.Schema<PurgeEnvironmentRequestFilesCachePurgeSingleFileWithURLAndHeadersItem>;

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

export type PurgeEnvironmentRequestFiles =
  | PurgeEnvironmentRequestFilesCachePurgeSingleFileList
  | PurgeEnvironmentRequestFilesCachePurgeSingleFileWithURLAndHeadersList;
export const PurgeEnvironmentRequestFiles = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([[], []]),
);

export interface PurgeEnvironmentCacheRequest {
  zoneId: string;
  environmentId: string;
  /** For more information on cache tags and purging by tags, please refer to [purge by cache-tags documentation page](https://developers.cloudflare.com/cache/how-to/purge-cache/purge-by-tags/). */
  tags?: PurgeEnvironmentRequestTagsList;
  /** For more information purging by hostnames, please refer to [purge by hostname documentation page](https://developers.cloudflare.com/cache/how-to/purge-cache/purge-by-hostname/). */
  hosts?: PurgeEnvironmentRequestHostsList;
  /** For more information on purging by prefixes, please refer to [purge by prefix documentation page](https://developers.cloudflare.com/cache/how-to/purge-cache/purge_by_prefix/). */
  prefixes?: PurgeEnvironmentRequestPrefixesList;
  /** For more information, please refer to [purge everything documentation page](https://developers.cloudflare.com/cache/how-to/purge-cache/purge-everything/). */
  purgeEverything?: boolean;
  /** For more information on purging files, please refer to [purge by single-file documentation page](https://developers.cloudflare.com/cache/how-to/purge-cache/purge-by-single-file/). */
  files?: PurgeEnvironmentRequestFiles;
}
export const PurgeEnvironmentCacheRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    environmentId: S.String.pipe(T.Label("environment_id")),
    tags: S.optional(PurgeEnvironmentRequestTagsList),
    hosts: S.optional(PurgeEnvironmentRequestHostsList),
    prefixes: S.optional(PurgeEnvironmentRequestPrefixesList),
    purgeEverything: S.optional(S.Boolean.pipe(T.Body("purge_everything"))),
    files: S.optional(PurgeEnvironmentRequestFiles),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/zones/{zone_id}/environments/{environment_id}/purge_cache",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PurgeEnvironmentCacheRequest",
}) as any as S.Schema<PurgeEnvironmentCacheRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PurgeEnvironmentCacheResponse {
  id: string;
}
export const PurgeEnvironmentCacheResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PurgeEnvironmentCacheResponse",
}) as any as S.Schema<PurgeEnvironmentCacheResponse>;

export type OriginCloudRegionsUpdateRequestVendor =
  | "aws"
  | "azure"
  | "gcp"
  | "oci";
export const OriginCloudRegionsUpdateRequestVendor = /*@__PURE__*/ S.String;

export interface PutOriginCloudRegionRequest {
  /** Identifier. */
  zoneId: string;
  /** Cloud vendor region identifier. Must be a valid region for the specified vendor as returned by the supported_regions endpoint. */
  region: string;
  /** Cloud vendor hosting the origin. Must be one of the supported vendors. */
  vendor: OriginCloudRegionsUpdateRequestVendor | (string & {});
  originIP: string;
  /** Origin IP address (IPv4 or IPv6). For the single PUT endpoint (`PUT /origin/cloud_regions/{origin_ip}`), this field must match the path parameter or the request will be rejected with a 400 error. For the batch PUT endpoint, this field identifies which mapping to upsert. */
  originIp: string;
}
export const PutOriginCloudRegionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    region: S.String,
    vendor: OriginCloudRegionsUpdateRequestVendor,
    originIP: S.String.pipe(T.Label()),
    originIp: S.String.pipe(T.Body("origin_ip")),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/zones/{zone_id}/origin/cloud_regions/{originIP}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutOriginCloudRegionRequest",
}) as any as S.Schema<PutOriginCloudRegionRequest>;

export type OriginCloudRegionsUpdateResponseVendor =
  | "aws"
  | "azure"
  | "gcp"
  | "oci";
export const OriginCloudRegionsUpdateResponseVendor = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PutOriginCloudRegionResponse {
  /** The origin IP address (IPv4 or IPv6). Normalized to canonical form (RFC 5952 for IPv6). */
  originIp: string;
  /** Cloud vendor region identifier. */
  region: string;
  /** Cloud vendor hosting the origin. */
  vendor: OriginCloudRegionsUpdateResponseVendor;
  /** Time this mapping was last modified. */
  modifiedOn?: string | null;
}
export const PutOriginCloudRegionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    originIp: S.String.pipe(T.Body("origin_ip")),
    region: S.String,
    vendor: OriginCloudRegionsUpdateResponseVendor,
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutOriginCloudRegionResponse",
}) as any as S.Schema<PutOriginCloudRegionResponse>;

export interface StatusCacheReserveRequest {
  /** Identifier. */
  zoneId: string;
}
export const StatusCacheReserveRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/cache/cache_reserve_clear",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "StatusCacheReserveRequest",
}) as any as S.Schema<StatusCacheReserveRequest>;

export type CacheReserveStatusResponseId = "cache_reserve_clear";
export const CacheReserveStatusResponseId = /*@__PURE__*/ S.String;

export type CacheReserveStatusResponseState = "In-progress" | "Completed";
export const CacheReserveStatusResponseState = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface StatusCacheReserveResponse {
  /** ID of the zone setting. */
  id: CacheReserveStatusResponseId;
  /** The time that the latest Cache Reserve Clear operation started. */
  startTs: string;
  /** The current state of the Cache Reserve Clear operation. */
  state: CacheReserveStatusResponseState;
  /** The time that the latest Cache Reserve Clear operation completed. */
  endTs?: string | null;
  /** Last time this setting was modified. */
  modifiedOn?: string | null;
}
export const StatusCacheReserveResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: CacheReserveStatusResponseId,
    startTs: S.String.pipe(T.Body("start_ts")),
    state: CacheReserveStatusResponseState,
    endTs: S.optional(S.NullOr(S.String).pipe(T.Body("end_ts"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "StatusCacheReserveResponse",
}) as any as S.Schema<StatusCacheReserveResponse>;

export interface SupportedRegionsOriginCloudRegionRequest {
  /** Identifier. */
  zoneId: string;
}
export const SupportedRegionsOriginCloudRegionRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      zoneId: S.String.pipe(T.Label("zone_id")),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/zones/{zone_id}/origin/cloud_regions/supported_regions",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "SupportedRegionsOriginCloudRegionRequest",
}) as any as S.Schema<SupportedRegionsOriginCloudRegionRequest>;

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

export interface OriginCloudRegionsSupportedRegionsResponseVendorsValueItem {
  /** Cloud vendor region identifier. */
  name: string;
  /** Cloudflare Tiered Cache upper-tier colocation codes co-located with this cloud region. Requests from zones with a matching origin mapping will be routed through these colos. */
  upperTierColos: OriginCloudRegionsSupportedRegionsResponseVendorsValueItemUpperTierColosList;
}
export const OriginCloudRegionsSupportedRegionsResponseVendorsValueItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      name: S.String,
      upperTierColos:
        OriginCloudRegionsSupportedRegionsResponseVendorsValueItemUpperTierColosList.pipe(
          T.Body("upper_tier_colos"),
        ),
    }),
  ).annotate({
    identifier: "OriginCloudRegionsSupportedRegionsResponseVendorsValueItem",
  }) as any as S.Schema<OriginCloudRegionsSupportedRegionsResponseVendorsValueItem>;

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

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface SupportedRegionsOriginCloudRegionResponse {
  /** Whether Cloudflare airport codes (IATA colo identifiers) were successfully resolved for the `upper_tier_colos` field on each region. When `false`, the `upper_tier_colos` arrays may be empty or incomplete. */
  obtainedCodes: boolean;
  /** Map of vendor name to list of supported regions. */
  vendors: OriginCloudRegionsSupportedRegionsResponseVendorsMap;
}
export const SupportedRegionsOriginCloudRegionResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      obtainedCodes: S.Boolean.pipe(T.Body("obtained_codes")),
      vendors: OriginCloudRegionsSupportedRegionsResponseVendorsMap,
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
  ).annotate({
    identifier: "SupportedRegionsOriginCloudRegionResponse",
  }) as any as S.Schema<SupportedRegionsOriginCloudRegionResponse>;

export type BulkDeleteOriginCloudRegionsError = CloudflareOpError;
/** Removes up to 100 IP-to-cloud-region mappings in a single request. Each IP is validated independently — successfully deleted items are returned in the `succeeded` array and IPs that could not be found or are invalid are returned in the `failed` array. */
export const bulkDeleteOriginCloudRegions: API.OperationMethod<
  BulkDeleteOriginCloudRegionsRequest,
  BulkDeleteOriginCloudRegionsResponse,
  BulkDeleteOriginCloudRegionsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: BulkDeleteOriginCloudRegionsRequest,
  output: BulkDeleteOriginCloudRegionsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type BulkPutOriginCloudRegionsError = CloudflareOpError;
/** Upserts up to 100 IP-to-cloud-region mappings in a single request. Items in the request body are created or replaced; mappings not included in the request body are preserved unchanged (this is a merge operation, not a full collection replacement). Each item is validated independently — valid items are applied and invalid items are returned in the `failed` array. The vendor and region for every item are validated against the list from `GET /zones/{zone_id}/origin/cloud_regions/supported_regions`. */
export const bulkPutOriginCloudRegions: API.OperationMethod<
  BulkPutOriginCloudRegionsRequest,
  BulkPutOriginCloudRegionsResponse,
  BulkPutOriginCloudRegionsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: BulkPutOriginCloudRegionsRequest,
  output: BulkPutOriginCloudRegionsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ClearCacheReserveError = CloudflareOpError;
/** You can use Cache Reserve Clear to clear your Cache Reserve, but you must first disable Cache Reserve. In most cases, this will be accomplished within 24 hours. You cannot re-enable Cache Reserve while this process is ongoing. Keep in mind that you cannot undo or cancel this operation. */
export const clearCacheReserve: API.OperationMethod<
  ClearCacheReserveRequest,
  ClearCacheReserveResponse,
  ClearCacheReserveError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ClearCacheReserveRequest,
  output: ClearCacheReserveResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateSmartTieredCacheError = CloudflareOpError;
/** Smart Tiered Cache dynamically selects the single closest upper tier for each of your website's origins with no configuration required, using our in-house performance and routing data. Cloudflare collects latency data for each request to an origin, and uses the latency data to determine how well any upper-tier data center is connected with an origin. As a result, Cloudflare can select the data center with the lowest latency to be the upper-tier for an origin. */
export const createSmartTieredCache: API.OperationMethod<
  CreateSmartTieredCacheRequest,
  CreateSmartTieredCacheResponse,
  CreateSmartTieredCacheError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateSmartTieredCacheRequest,
  output: CreateSmartTieredCacheResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteOriginCloudRegionError =
  | OriginCloudRegionNotFound
  | Forbidden
  | CloudflareOpError;
/** Removes the cloud region mapping for a single origin IP address. The IP path parameter is normalized before lookup. Returns the deleted IP on success. Returns 404 if no mapping exists for the specified IP. When the last mapping for the zone is removed the underlying rule record is also deleted. */
export const deleteOriginCloudRegion: API.OperationMethod<
  DeleteOriginCloudRegionRequest,
  DeleteOriginCloudRegionResponse,
  DeleteOriginCloudRegionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteOriginCloudRegionRequest,
  output: DeleteOriginCloudRegionResponse,
  errors: [
    OriginCloudRegionNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteSmartTieredCacheError = CloudflareOpError;
/** Smart Tiered Cache dynamically selects the single closest upper tier for each of your website’s origins with no configuration required, using our in-house performance and routing data. Cloudflare collects latency data for each request to an origin, and uses the latency data to determine how well any upper-tier data center is connected with an origin. As a result, Cloudflare can select the data center with the lowest latency to be the upper-tier for an origin. */
export const deleteSmartTieredCache: API.OperationMethod<
  DeleteSmartTieredCacheRequest,
  DeleteSmartTieredCacheResponse,
  DeleteSmartTieredCacheError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteSmartTieredCacheRequest,
  output: DeleteSmartTieredCacheResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteVariantError =
  | VariantsNotConfigured
  | Forbidden
  | CloudflareOpError;
/** Variant support enables caching variants of images with certain file extensions in addition to the original. This only applies when the origin server sends the 'Vary: Accept' response header. If the origin server sends 'Vary: Accept' but does not serve the variant requested, the response will not be cached. This will be indicated with BYPASS cache status in the response headers. */
export const deleteVariant: API.OperationMethod<
  DeleteVariantRequest,
  DeleteVariantResponse,
  DeleteVariantError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteVariantRequest,
  output: DeleteVariantResponse,
  errors: [
    VariantsNotConfigured,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetCacheReserveError =
  | SettingUnavailableForPlan
  | Forbidden
  | CloudflareOpError;
/** Increase cache lifetimes by automatically storing all cacheable files into Cloudflare's persistent object storage buckets. Requires Cache Reserve subscription. Note: using Tiered Cache with Cache Reserve is highly recommended to reduce Reserve operations costs. See the [developer docs](https://developers.cloudflare.com/cache/about/cache-reserve) for more information. */
export const getCacheReserve: API.OperationMethod<
  GetCacheReserveRequest,
  GetCacheReserveResponse,
  GetCacheReserveError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetCacheReserveRequest,
  output: GetCacheReserveResponse,
  errors: [
    SettingUnavailableForPlan,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetOriginCloudRegionError =
  | OriginCloudRegionNotFound
  | Forbidden
  | CloudflareOpError;
/** Returns the cloud region mapping for a single origin IP address. The IP path parameter is normalized before lookup (RFC 5952 for IPv6). Returns 404 if the zone has no mappings or if the specified IP has no mapping. */
export const getOriginCloudRegion: API.OperationMethod<
  GetOriginCloudRegionRequest,
  GetOriginCloudRegionResponse,
  GetOriginCloudRegionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetOriginCloudRegionRequest,
  output: GetOriginCloudRegionResponse,
  errors: [
    OriginCloudRegionNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetRegionalTieredCacheError =
  | SettingUnavailableForPlan
  | Forbidden
  | Unauthorized
  | CloudflareOpError;
/** Instructs Cloudflare to check a regional hub data center on the way to your upper tier. This can help improve performance for smart and custom tiered cache topologies. */
export const getRegionalTieredCache: API.OperationMethod<
  GetRegionalTieredCacheRequest,
  GetRegionalTieredCacheResponse,
  GetRegionalTieredCacheError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetRegionalTieredCacheRequest,
  output: GetRegionalTieredCacheResponse,
  errors: [
    SettingUnavailableForPlan,
    Forbidden,
    Unauthorized,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSmartTieredCacheError = Forbidden | CloudflareOpError;
/** Smart Tiered Cache dynamically selects the single closest upper tier for each of your website’s origins with no configuration required, using our in-house performance and routing data. Cloudflare collects latency data for each request to an origin, and uses the latency data to determine how well any upper-tier data center is connected with an origin. As a result, Cloudflare can select the data center with the lowest latency to be the upper-tier for an origin. */
export const getSmartTieredCache: API.OperationMethod<
  GetSmartTieredCacheRequest,
  GetSmartTieredCacheResponse,
  GetSmartTieredCacheError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSmartTieredCacheRequest,
  output: GetSmartTieredCacheResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetVariantError =
  | VariantsNotConfigured
  | Forbidden
  | CloudflareOpError;
/** Variant support enables caching variants of images with certain file extensions in addition to the original. This only applies when the origin server sends the 'Vary: Accept' response header. If the origin server sends 'Vary: Accept' but does not serve the variant requested, the response will not be cached. This will be indicated with BYPASS cache status in the response headers. */
export const getVariant: API.OperationMethod<
  GetVariantRequest,
  GetVariantResponse,
  GetVariantError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetVariantRequest,
  output: GetVariantResponse,
  errors: [
    VariantsNotConfigured,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListOriginCloudRegionsError = Forbidden | CloudflareOpError;
/** Returns all IP-to-cloud-region mappings configured for the zone with pagination support. Each mapping tells Cloudflare which cloud vendor and region hosts the origin at that IP, enabling the edge to route via the nearest Tiered Cache upper-tier co-located with that cloud provider. Returns an empty array when no mappings exist. */
export const listOriginCloudRegions: API.PaginatedOperationMethod<
  ListOriginCloudRegionsRequest,
  ListOriginCloudRegionsResponse,
  ListOriginCloudRegionsError,
  CloudflareOpContext,
  OriginCloudRegionsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListOriginCloudRegionsRequest,
    output: ListOriginCloudRegionsResponse,
    errors: [Forbidden, CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type OriginCloudRegionsBulkDeleteV1Error = CloudflareOpError;
/** Removes up to 100 IP-to-cloud-region mappings in a single request. Each IP is validated independently — successfully deleted items are returned in the `succeeded` array and IPs that could not be found or are invalid are returned in the `failed` array. */
export const originCloudRegionsBulkDeleteV1: API.OperationMethod<
  OriginCloudRegionsBulkDeleteV1Request,
  OriginCloudRegionsBulkDeleteV1Response,
  OriginCloudRegionsBulkDeleteV1Error,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: OriginCloudRegionsBulkDeleteV1Request,
  output: OriginCloudRegionsBulkDeleteV1Response,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type OriginCloudRegionsBulkEditV1Error = CloudflareOpError;
/** Adds or updates up to 100 IP-to-cloud-region mappings in a single request. Each item is validated independently — valid items are applied and invalid items are returned in the `failed` array. The vendor and region for every item are validated against the list from `GET /zones/{zone_id}/cache/origin_cloud_regions/supported_regions`. */
export const originCloudRegionsBulkEditV1: API.OperationMethod<
  OriginCloudRegionsBulkEditV1Request,
  OriginCloudRegionsBulkEditV1Response,
  OriginCloudRegionsBulkEditV1Error,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: OriginCloudRegionsBulkEditV1Request,
  output: OriginCloudRegionsBulkEditV1Response,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type OriginCloudRegionsCreateV1Error = CloudflareOpError;
/** Adds a single IP-to-cloud-region mapping for the zone. The IP must be a valid IPv4 or IPv6 address and is normalized to canonical form before storage (RFC 5952 for IPv6). Returns 400 (code 1145) if a mapping for that IP already exists — use PATCH to update an existing entry. The vendor and region are validated against the list from `GET /zones/{zone_id}/cache/origin_cloud_regions/supported_regions`. */
export const originCloudRegionsCreateV1: API.OperationMethod<
  OriginCloudRegionsCreateV1Request,
  OriginCloudRegionsCreateV1Response,
  OriginCloudRegionsCreateV1Error,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: OriginCloudRegionsCreateV1Request,
  output: OriginCloudRegionsCreateV1Response,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type OriginCloudRegionsDeleteV1Error = CloudflareOpError;
/** Removes the cloud region mapping for a single origin IP address. The IP path parameter is normalized before lookup. Returns the deleted entry on success. Returns 404 (code 1163) if no mapping exists for the specified IP. When the last mapping for the zone is removed the underlying rule record is also deleted. */
export const originCloudRegionsDeleteV1: API.OperationMethod<
  OriginCloudRegionsDeleteV1Request,
  OriginCloudRegionsDeleteV1Response,
  OriginCloudRegionsDeleteV1Error,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: OriginCloudRegionsDeleteV1Request,
  output: OriginCloudRegionsDeleteV1Response,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type OriginCloudRegionsEditV1Error = CloudflareOpError;
/** Adds or updates a single IP-to-cloud-region mapping for the zone. Unlike POST, this operation is idempotent — if a mapping for the IP already exists it is overwritten. Returns the complete updated list of all mappings for the zone. Returns 403 (code 1164) when the zone has reached the limit of 3,500 IP mappings. */
export const originCloudRegionsEditV1: API.OperationMethod<
  OriginCloudRegionsEditV1Request,
  OriginCloudRegionsEditV1Response,
  OriginCloudRegionsEditV1Error,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: OriginCloudRegionsEditV1Request,
  output: OriginCloudRegionsEditV1Response,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type OriginCloudRegionsGetV1Error = CloudflareOpError;
/** Returns the cloud region mapping for a single origin IP address. The IP path parameter is normalized before lookup (RFC 5952 for IPv6). Returns 404 (code 1142) if the zone has no mappings or if the specified IP has no mapping. */
export const originCloudRegionsGetV1: API.OperationMethod<
  OriginCloudRegionsGetV1Request,
  OriginCloudRegionsGetV1Response,
  OriginCloudRegionsGetV1Error,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: OriginCloudRegionsGetV1Request,
  output: OriginCloudRegionsGetV1Response,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type OriginCloudRegionsListV1Error = CloudflareOpError;
/** Returns all IP-to-cloud-region mappings configured for the zone. Each mapping tells Cloudflare which cloud vendor and region hosts the origin at that IP, enabling the edge to route via the nearest Tiered Cache upper-tier co-located with that cloud provider. Returns an empty array when no mappings exist. */
export const originCloudRegionsListV1: API.OperationMethod<
  OriginCloudRegionsListV1Request,
  OriginCloudRegionsListV1Response,
  OriginCloudRegionsListV1Error,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: OriginCloudRegionsListV1Request,
  output: OriginCloudRegionsListV1Response,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type OriginCloudRegionsSupportedRegionsV1Error = CloudflareOpError;
/** Returns the cloud vendors and regions that are valid values for origin cloud region mappings. Each region includes the Tiered Cache upper-tier colocation codes that will be used for cache routing when a mapping targeting that region is active. Requires the zone to have Tiered Cache enabled. */
export const originCloudRegionsSupportedRegionsV1: API.OperationMethod<
  OriginCloudRegionsSupportedRegionsV1Request,
  OriginCloudRegionsSupportedRegionsV1Response,
  OriginCloudRegionsSupportedRegionsV1Error,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: OriginCloudRegionsSupportedRegionsV1Request,
  output: OriginCloudRegionsSupportedRegionsV1Response,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchCacheReserveError =
  | SettingUnavailableForPlan
  | Forbidden
  | CloudflareOpError;
/** Increase cache lifetimes by automatically storing all cacheable files into Cloudflare's persistent object storage buckets. Requires Cache Reserve subscription. Note: using Tiered Cache with Cache Reserve is highly recommended to reduce Reserve operations costs. See the [developer docs](https://developers.cloudflare.com/cache/about/cache-reserve) for more information. */
export const patchCacheReserve: API.OperationMethod<
  PatchCacheReserveRequest,
  PatchCacheReserveResponse,
  PatchCacheReserveError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchCacheReserveRequest,
  output: PatchCacheReserveResponse,
  errors: [
    SettingUnavailableForPlan,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchRegionalTieredCacheError =
  | SettingUnavailableForPlan
  | Forbidden
  | CloudflareOpError;
/** Instructs Cloudflare to check a regional hub data center on the way to your upper tier. This can help improve performance for smart and custom tiered cache topologies. */
export const patchRegionalTieredCache: API.OperationMethod<
  PatchRegionalTieredCacheRequest,
  PatchRegionalTieredCacheResponse,
  PatchRegionalTieredCacheError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchRegionalTieredCacheRequest,
  output: PatchRegionalTieredCacheResponse,
  errors: [
    SettingUnavailableForPlan,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchSmartTieredCacheError = Forbidden | CloudflareOpError;
/** Smart Tiered Cache dynamically selects the single closest upper tier for each of your website’s origins with no configuration required, using our in-house performance and routing data. Cloudflare collects latency data for each request to an origin, and uses the latency data to determine how well any upper-tier data center is connected with an origin. As a result, Cloudflare can select the data center with the lowest latency to be the upper-tier for an origin. */
export const patchSmartTieredCache: API.OperationMethod<
  PatchSmartTieredCacheRequest,
  PatchSmartTieredCacheResponse,
  PatchSmartTieredCacheError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchSmartTieredCacheRequest,
  output: PatchSmartTieredCacheResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchVariantError = Forbidden | CloudflareOpError;
/** Variant support enables caching variants of images with certain file extensions in addition to the original. This only applies when the origin server sends the 'Vary: Accept' response header. If the origin server sends 'Vary: Accept' but does not serve the variant requested, the response will not be cached. This will be indicated with BYPASS cache status in the response headers. */
export const patchVariant: API.OperationMethod<
  PatchVariantRequest,
  PatchVariantResponse,
  PatchVariantError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchVariantRequest,
  output: PatchVariantResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PurgeCacheError = CloudflareOpError;
export const purgeCache: API.OperationMethod<
  PurgeCacheRequest,
  PurgeCacheResponse,
  PurgeCacheError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PurgeCacheRequest,
  output: PurgeCacheResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PurgeEnvironmentCacheError = CloudflareOpError;
/** Purge cached content scoped to a specific environment. Supports the same purge types as the zone-level endpoint (purge everything, by URL, by tag, host, or prefix). */
export const purgeEnvironmentCache: API.OperationMethod<
  PurgeEnvironmentCacheRequest,
  PurgeEnvironmentCacheResponse,
  PurgeEnvironmentCacheError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PurgeEnvironmentCacheRequest,
  output: PurgeEnvironmentCacheResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PutOriginCloudRegionError = Forbidden | CloudflareOpError;
/** Creates a new IP-to-cloud-region mapping or replaces the existing mapping for the specified IP. PUT is idempotent — calling it repeatedly with the same body produces the same result. The IP path parameter is normalized to canonical form (RFC 5952 for IPv6) before storage. The vendor and region are validated against the list from `GET /zones/{zone_id}/origin/cloud_regions/supported_regions`. Returns 400 if the `origin_ip` in the body does not match the URL path parameter. Returns 403 (code 1164) when the zone has reached the limit of 3,500 IP mappings. */
export const putOriginCloudRegion: API.OperationMethod<
  PutOriginCloudRegionRequest,
  PutOriginCloudRegionResponse,
  PutOriginCloudRegionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PutOriginCloudRegionRequest,
  output: PutOriginCloudRegionResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type StatusCacheReserveError = CloudflareOpError;
/** You can use Cache Reserve Clear to clear your Cache Reserve, but you must first disable Cache Reserve. In most cases, this will be accomplished within 24 hours. You cannot re-enable Cache Reserve while this process is ongoing. Keep in mind that you cannot undo or cancel this operation. */
export const statusCacheReserve: API.OperationMethod<
  StatusCacheReserveRequest,
  StatusCacheReserveResponse,
  StatusCacheReserveError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: StatusCacheReserveRequest,
  output: StatusCacheReserveResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type SupportedRegionsOriginCloudRegionError = CloudflareOpError;
/** Returns the cloud vendors and regions that are valid values for origin cloud region mappings. Each region includes the Tiered Cache upper-tier colocation codes that will be used for cache routing when a mapping targeting that region is active. Requires the zone to have Tiered Cache enabled. */
export const supportedRegionsOriginCloudRegion: API.OperationMethod<
  SupportedRegionsOriginCloudRegionRequest,
  SupportedRegionsOriginCloudRegionResponse,
  SupportedRegionsOriginCloudRegionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: SupportedRegionsOriginCloudRegionRequest,
  output: SupportedRegionsOriginCloudRegionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));