// 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>> = {
  bundleMethod: "bundle_method",
  certificateAuthority: "certificate_authority",
  cloudflareBranding: "cloudflare_branding",
  cnameTarget: "cname_target",
  createdAt: "created_at",
  customCertBundle: "custom_cert_bundle",
  customCertificate: "custom_certificate",
  customCsrId: "custom_csr_id",
  customKey: "custom_key",
  customMetadata: "custom_metadata",
  customOriginServer: "custom_origin_server",
  customOriginSni: "custom_origin_sni",
  dcvDelegationRecords: "dcv_delegation_records",
  earlyHints: "early_hints",
  expiresOn: "expires_on",
  httpBody: "http_body",
  httpUrl: "http_url",
  minTlsVersion: "min_tls_version",
  ownershipVerification: "ownership_verification",
  ownershipVerificationHttp: "ownership_verification_http",
  perPage: "per_page",
  resultInfo: "result_info",
  serialNumber: "serial_number",
  totalCount: "total_count",
  txtName: "txt_name",
  txtValue: "txt_value",
  updatedAt: "updated_at",
  uploadedOn: "uploaded_on",
  validationErrors: "validation_errors",
  validationRecords: "validation_records",
  verificationErrors: "verification_errors",
};

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

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

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

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

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

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

export type CreateRequestSslBundleMethod = "ubiquitous" | "optimal" | "force";
export const CreateRequestSslBundleMethod = /*@__PURE__*/ S.String;

export type CreateRequestSslCertificateAuthority =
  | "digicert"
  | "google"
  | "lets_encrypt"
  | "ssl_com";
export const CreateRequestSslCertificateAuthority = /*@__PURE__*/ S.String;

export interface CreateRequestSslCustomCertBundleItem {
  /** If a custom uploaded certificate is used. */
  customCertificate: string;
  /** The key for a custom uploaded certificate. */
  customKey: string;
}
export const CreateRequestSslCustomCertBundleItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      customCertificate: S.String.pipe(T.Body("custom_certificate")),
      customKey: S.String.pipe(T.Body("custom_key")),
    }),
).annotate({
  identifier: "CreateRequestSslCustomCertBundleItem",
}) as any as S.Schema<CreateRequestSslCustomCertBundleItem>;

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

export type CreateRequestSslMethod = "http" | "txt" | "email";
export const CreateRequestSslMethod = /*@__PURE__*/ S.String;

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

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

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

export type CreateRequestSslSettingsMinTlsVersion =
  | "1.0"
  | "1.1"
  | "1.2"
  | "1.3";
export const CreateRequestSslSettingsMinTlsVersion = /*@__PURE__*/ S.String;

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

export interface CreateRequestSslSettings {
  /** An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format. */
  ciphers?: CreateRequestSslSettingsCiphersList;
  /** Whether or not Early Hints is enabled. */
  earlyHints?: CreateRequestSslSettingsEarlyHints | (string & {});
  /** Whether or not HTTP2 is enabled. */
  http2?: CreateRequestSslSettingsHttp2 | (string & {});
  /** The minimum TLS version supported. */
  minTlsVersion?: CreateRequestSslSettingsMinTlsVersion | (string & {});
  /** Whether or not TLS 1.3 is enabled. */
  tls_1_3?: CreateRequestSslSettingsTls13 | (string & {});
}
export const CreateRequestSslSettings = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    ciphers: S.optional(CreateRequestSslSettingsCiphersList),
    earlyHints: S.optional(
      CreateRequestSslSettingsEarlyHints.pipe(T.Body("early_hints")),
    ),
    http2: S.optional(CreateRequestSslSettingsHttp2),
    minTlsVersion: S.optional(
      CreateRequestSslSettingsMinTlsVersion.pipe(T.Body("min_tls_version")),
    ),
    tls_1_3: S.optional(CreateRequestSslSettingsTls13),
  }),
).annotate({
  identifier: "CreateRequestSslSettings",
}) as any as S.Schema<CreateRequestSslSettings>;

export type CreateRequestSslType = "dv";
export const CreateRequestSslType = /*@__PURE__*/ S.String;

export interface CreateRequestSsl {
  /** A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates. And the force bundle verifies the chain, but does not otherwise modify it. */
  bundleMethod?: CreateRequestSslBundleMethod | (string & {});
  /** The Certificate Authority that will issue the certificate. */
  certificateAuthority?: CreateRequestSslCertificateAuthority | (string & {});
  /** Whether or not to add Cloudflare Branding for the order. This will add a subdomain of sni.cloudflaressl.com as the Common Name if set to true. */
  cloudflareBranding?: boolean;
  /** Array of custom certificate and key pairs (1 or 2 pairs allowed). */
  customCertBundle?: CreateRequestSslCustomCertBundleList;
  /** If a custom uploaded certificate is used. */
  customCertificate?: string;
  /** The identifier for the Custom CSR that was used. */
  customCsrId?: string;
  /** The key for a custom uploaded certificate. */
  customKey?: string;
  /** Domain control validation (DCV) method used for this hostname. */
  method?: CreateRequestSslMethod | (string & {});
  /** SSL specific settings. */
  settings?: CreateRequestSslSettings;
  /** Level of validation to be used for this hostname. Domain validation (dv) must be used. */
  type?: CreateRequestSslType | (string & {});
  /** Indicates whether the certificate covers a wildcard. */
  wildcard?: boolean;
}
export const CreateRequestSsl = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    bundleMethod: S.optional(
      CreateRequestSslBundleMethod.pipe(T.Body("bundle_method")),
    ),
    certificateAuthority: S.optional(
      CreateRequestSslCertificateAuthority.pipe(
        T.Body("certificate_authority"),
      ),
    ),
    cloudflareBranding: S.optional(
      S.Boolean.pipe(T.Body("cloudflare_branding")),
    ),
    customCertBundle: S.optional(
      CreateRequestSslCustomCertBundleList.pipe(T.Body("custom_cert_bundle")),
    ),
    customCertificate: S.optional(S.String.pipe(T.Body("custom_certificate"))),
    customCsrId: S.optional(S.String.pipe(T.Body("custom_csr_id"))),
    customKey: S.optional(S.String.pipe(T.Body("custom_key"))),
    method: S.optional(CreateRequestSslMethod),
    settings: S.optional(CreateRequestSslSettings),
    type: S.optional(CreateRequestSslType),
    wildcard: S.optional(S.Boolean),
  }),
).annotate({
  identifier: "CreateRequestSsl",
}) as any as S.Schema<CreateRequestSsl>;

export interface CreateCustomHostnameRequest {
  /** Identifier. */
  zoneId: string;
  /** The custom hostname that will point to your hostname via CNAME. */
  hostname: string;
  /** Unique key/value metadata for this hostname. These are per-hostname (customer) settings. */
  customMetadata?: CreateRequestCustomMetadataMap;
  /** SSL properties used when creating the custom hostname. */
  ssl?: CreateRequestSsl;
}
export const CreateCustomHostnameRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    hostname: S.String,
    customMetadata: S.optional(
      CreateRequestCustomMetadataMap.pipe(T.Body("custom_metadata")),
    ),
    ssl: S.optional(CreateRequestSsl),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/zones/{zone_id}/custom_hostnames",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateCustomHostnameRequest",
}) as any as S.Schema<CreateCustomHostnameRequest>;

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

export type CreateResponseOwnershipVerificationType = "txt";
export const CreateResponseOwnershipVerificationType = /*@__PURE__*/ S.String;

export interface CreateResponseOwnershipVerification {
  /** DNS Name for record. */
  name?: string | null;
  /** DNS Record type. */
  type?: CreateResponseOwnershipVerificationType | null;
  /** Content for the record. */
  value?: string | null;
}
export const CreateResponseOwnershipVerification = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.optional(S.NullOr(S.String)),
    type: S.optional(S.NullOr(CreateResponseOwnershipVerificationType)),
    value: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "CreateResponseOwnershipVerification",
}) as any as S.Schema<CreateResponseOwnershipVerification>;

export interface CreateResponseOwnershipVerificationHttp {
  /** Token to be served. */
  httpBody?: string | null;
  /** The HTTP URL that will be checked during custom hostname verification and where the customer should host the token. */
  httpUrl?: string | null;
}
export const CreateResponseOwnershipVerificationHttp = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      httpBody: S.optional(S.NullOr(S.String).pipe(T.Body("http_body"))),
      httpUrl: S.optional(S.NullOr(S.String).pipe(T.Body("http_url"))),
    }),
).annotate({
  identifier: "CreateResponseOwnershipVerificationHttp",
}) as any as S.Schema<CreateResponseOwnershipVerificationHttp>;

export type CreateResponseSslBundleMethod = "ubiquitous" | "optimal" | "force";
export const CreateResponseSslBundleMethod = /*@__PURE__*/ S.String;

export type CreateResponseSslCertificateAuthority =
  | "digicert"
  | "google"
  | "lets_encrypt"
  | "ssl_com";
export const CreateResponseSslCertificateAuthority = /*@__PURE__*/ S.String;

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

export interface CreateResponseSslDcvDelegationRecordsItem {
  /** The CNAME record hostname for DCV delegation. */
  cname?: string | null;
  /** The CNAME record target value for DCV delegation. */
  cnameTarget?: string | null;
  /** The set of email addresses that the certificate authority (CA) will use to complete domain validation. */
  emails?: CreateResponseSslDcvDelegationRecordsItemEmailsList | null;
  /** The content that the certificate authority (CA) will expect to find at the http_url during the domain validation. */
  httpBody?: string | null;
  /** The url that will be checked during domain validation. */
  httpUrl?: string | null;
  /** Status of the validation record. */
  status?: string | null;
  /** The hostname that the certificate authority (CA) will check for a TXT record during domain validation . */
  txtName?: string | null;
  /** The TXT record that the certificate authority (CA) will check during domain validation. */
  txtValue?: string | null;
}
export const CreateResponseSslDcvDelegationRecordsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      cname: S.optional(S.NullOr(S.String)),
      cnameTarget: S.optional(S.NullOr(S.String).pipe(T.Body("cname_target"))),
      emails: S.optional(
        S.NullOr(CreateResponseSslDcvDelegationRecordsItemEmailsList),
      ),
      httpBody: S.optional(S.NullOr(S.String).pipe(T.Body("http_body"))),
      httpUrl: S.optional(S.NullOr(S.String).pipe(T.Body("http_url"))),
      status: S.optional(S.NullOr(S.String)),
      txtName: S.optional(S.NullOr(S.String).pipe(T.Body("txt_name"))),
      txtValue: S.optional(S.NullOr(S.String).pipe(T.Body("txt_value"))),
    }),
  ).annotate({
    identifier: "CreateResponseSslDcvDelegationRecordsItem",
  }) as any as S.Schema<CreateResponseSslDcvDelegationRecordsItem>;

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

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

export type CreateResponseSslMethod = "http" | "txt" | "email";
export const CreateResponseSslMethod = /*@__PURE__*/ S.String;

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

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

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

export type CreateResponseSslSettingsMinTlsVersion =
  | "1.0"
  | "1.1"
  | "1.2"
  | "1.3";
export const CreateResponseSslSettingsMinTlsVersion = /*@__PURE__*/ S.String;

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

export interface CreateResponseSslSettings {
  /** An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format. */
  ciphers?: CreateResponseSslSettingsCiphersList | null;
  /** Whether or not Early Hints is enabled. */
  earlyHints?: CreateResponseSslSettingsEarlyHints | null;
  /** Whether or not HTTP2 is enabled. */
  http2?: CreateResponseSslSettingsHttp2 | null;
  /** The minimum TLS version supported. */
  minTlsVersion?: CreateResponseSslSettingsMinTlsVersion | null;
  /** Whether or not TLS 1.3 is enabled. */
  tls_1_3?: CreateResponseSslSettingsTls13 | null;
}
export const CreateResponseSslSettings = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    ciphers: S.optional(S.NullOr(CreateResponseSslSettingsCiphersList)),
    earlyHints: S.optional(
      S.NullOr(CreateResponseSslSettingsEarlyHints).pipe(T.Body("early_hints")),
    ),
    http2: S.optional(S.NullOr(CreateResponseSslSettingsHttp2)),
    minTlsVersion: S.optional(
      S.NullOr(CreateResponseSslSettingsMinTlsVersion).pipe(
        T.Body("min_tls_version"),
      ),
    ),
    tls_1_3: S.optional(S.NullOr(CreateResponseSslSettingsTls13)),
  }),
).annotate({
  identifier: "CreateResponseSslSettings",
}) as any as S.Schema<CreateResponseSslSettings>;

export type CreateResponseSslStatus =
  | "initializing"
  | "pending_validation"
  | "deleted"
  | "pending_issuance"
  | "pending_deployment"
  | "pending_deletion"
  | "pending_expiration"
  | "expired"
  | "active"
  | "initializing_timed_out"
  | "validation_timed_out"
  | "issuance_timed_out"
  | "deployment_timed_out"
  | "deletion_timed_out"
  | "pending_cleanup"
  | "staging_deployment"
  | "staging_active"
  | "deactivating"
  | "inactive"
  | "backup_issued"
  | "holding_deployment";
export const CreateResponseSslStatus = /*@__PURE__*/ S.String;

export type CreateResponseSslType = "dv";
export const CreateResponseSslType = /*@__PURE__*/ S.String;

export interface CreateResponseSslValidationErrorsItem {
  /** A domain validation error. */
  message?: string | null;
}
export const CreateResponseSslValidationErrorsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      message: S.optional(S.NullOr(S.String)),
    }),
).annotate({
  identifier: "CreateResponseSslValidationErrorsItem",
}) as any as S.Schema<CreateResponseSslValidationErrorsItem>;

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

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

export interface CreateResponseSslValidationRecordsItem {
  /** The CNAME record hostname for DCV delegation. */
  cname?: string | null;
  /** The CNAME record target value for DCV delegation. */
  cnameTarget?: string | null;
  /** The set of email addresses that the certificate authority (CA) will use to complete domain validation. */
  emails?: CreateResponseSslValidationRecordsItemEmailsList | null;
  /** The content that the certificate authority (CA) will expect to find at the http_url during the domain validation. */
  httpBody?: string | null;
  /** The url that will be checked during domain validation. */
  httpUrl?: string | null;
  /** Status of the validation record. */
  status?: string | null;
  /** The hostname that the certificate authority (CA) will check for a TXT record during domain validation . */
  txtName?: string | null;
  /** The TXT record that the certificate authority (CA) will check during domain validation. */
  txtValue?: string | null;
}
export const CreateResponseSslValidationRecordsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      cname: S.optional(S.NullOr(S.String)),
      cnameTarget: S.optional(S.NullOr(S.String).pipe(T.Body("cname_target"))),
      emails: S.optional(
        S.NullOr(CreateResponseSslValidationRecordsItemEmailsList),
      ),
      httpBody: S.optional(S.NullOr(S.String).pipe(T.Body("http_body"))),
      httpUrl: S.optional(S.NullOr(S.String).pipe(T.Body("http_url"))),
      status: S.optional(S.NullOr(S.String)),
      txtName: S.optional(S.NullOr(S.String).pipe(T.Body("txt_name"))),
      txtValue: S.optional(S.NullOr(S.String).pipe(T.Body("txt_value"))),
    }),
).annotate({
  identifier: "CreateResponseSslValidationRecordsItem",
}) as any as S.Schema<CreateResponseSslValidationRecordsItem>;

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

export interface CreateResponseSsl {
  /** Custom hostname SSL identifier tag. */
  id?: string | null;
  /** A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates. And the force bundle verifies the chain, but does not otherwise modify it. */
  bundleMethod?: CreateResponseSslBundleMethod | null;
  /** The Certificate Authority that will issue the certificate. */
  certificateAuthority?: CreateResponseSslCertificateAuthority | null;
  /** If a custom uploaded certificate is used. */
  customCertificate?: string | null;
  /** The identifier for the Custom CSR that was used. */
  customCsrId?: string | null;
  /** The key for a custom uploaded certificate. */
  customKey?: string | null;
  /** DCV Delegation records for domain validation. */
  dcvDelegationRecords?: CreateResponseSslDcvDelegationRecordsList | null;
  /** The time the custom certificate expires on. */
  expiresOn?: string | null;
  /** A list of Hostnames on a custom uploaded certificate. */
  hosts?: CreateResponseSslHostsList | null;
  /** The issuer on a custom uploaded certificate. */
  issuer?: string | null;
  /** Domain control validation (DCV) method used for this hostname. */
  method?: CreateResponseSslMethod | null;
  /** The serial number on a custom uploaded certificate. */
  serialNumber?: string | null;
  settings?: CreateResponseSslSettings | null;
  /** The signature on a custom uploaded certificate. */
  signature?: string | null;
  /** Status of the hostname's SSL certificates. */
  status?: CreateResponseSslStatus | null;
  /** Level of validation to be used for this hostname. Domain validation (dv) must be used. */
  type?: CreateResponseSslType | null;
  /** The time the custom certificate was uploaded. */
  uploadedOn?: string | null;
  /** Domain validation errors that have been received by the certificate authority (CA). */
  validationErrors?: CreateResponseSslValidationErrorsList | null;
  validationRecords?: CreateResponseSslValidationRecordsList | null;
  /** Indicates whether the certificate covers a wildcard. */
  wildcard?: boolean | null;
}
export const CreateResponseSsl = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    bundleMethod: S.optional(
      S.NullOr(CreateResponseSslBundleMethod).pipe(T.Body("bundle_method")),
    ),
    certificateAuthority: S.optional(
      S.NullOr(CreateResponseSslCertificateAuthority).pipe(
        T.Body("certificate_authority"),
      ),
    ),
    customCertificate: S.optional(
      S.NullOr(S.String).pipe(T.Body("custom_certificate")),
    ),
    customCsrId: S.optional(S.NullOr(S.String).pipe(T.Body("custom_csr_id"))),
    customKey: S.optional(S.NullOr(S.String).pipe(T.Body("custom_key"))),
    dcvDelegationRecords: S.optional(
      S.NullOr(CreateResponseSslDcvDelegationRecordsList).pipe(
        T.Body("dcv_delegation_records"),
      ),
    ),
    expiresOn: S.optional(S.NullOr(S.String).pipe(T.Body("expires_on"))),
    hosts: S.optional(S.NullOr(CreateResponseSslHostsList)),
    issuer: S.optional(S.NullOr(S.String)),
    method: S.optional(S.NullOr(CreateResponseSslMethod)),
    serialNumber: S.optional(S.NullOr(S.String).pipe(T.Body("serial_number"))),
    settings: S.optional(S.NullOr(CreateResponseSslSettings)),
    signature: S.optional(S.NullOr(S.String)),
    status: S.optional(S.NullOr(CreateResponseSslStatus)),
    type: S.optional(S.NullOr(CreateResponseSslType)),
    uploadedOn: S.optional(S.NullOr(S.String).pipe(T.Body("uploaded_on"))),
    validationErrors: S.optional(
      S.NullOr(CreateResponseSslValidationErrorsList).pipe(
        T.Body("validation_errors"),
      ),
    ),
    validationRecords: S.optional(
      S.NullOr(CreateResponseSslValidationRecordsList).pipe(
        T.Body("validation_records"),
      ),
    ),
    wildcard: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "CreateResponseSsl",
}) as any as S.Schema<CreateResponseSsl>;

export type CreateResponseStatus =
  | "active"
  | "pending"
  | "active_redeploying"
  | "moved"
  | "pending_deletion"
  | "deleted"
  | "pending_blocked"
  | "pending_migration"
  | "pending_provisioned"
  | "test_pending"
  | "test_active"
  | "test_active_apex"
  | "test_blocked"
  | "test_failed"
  | "provisioned"
  | "blocked";
export const CreateResponseStatus = /*@__PURE__*/ S.String;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateCustomHostnameResponse {
  /** Identifier. */
  id: string;
  /** The custom hostname that will point to your hostname via CNAME. */
  hostname: string;
  /** This is the time the hostname was created. */
  createdAt?: string | null;
  /** Unique key/value metadata for this hostname. These are per-hostname (customer) settings. */
  customMetadata?: CreateResponseCustomMetadataMap | null;
  /** a valid hostname that’s been added to your DNS zone as an A, AAAA, or CNAME record. */
  customOriginServer?: string | null;
  /** A hostname that will be sent to your custom origin server as SNI for TLS handshake. This can be a valid subdomain of the zone or custom origin server name or the string ':request_host_header:' which will cause the host header in the request to be used as SNI. Not configurable with default/fallback origin server. */
  customOriginSni?: string | null;
  /** This is a record which can be placed to activate a hostname. */
  ownershipVerification?: CreateResponseOwnershipVerification | null;
  /** This presents the token to be served by the given http url to activate a hostname. */
  ownershipVerificationHttp?: CreateResponseOwnershipVerificationHttp | null;
  ssl?: CreateResponseSsl | null;
  /** Status of the hostname's activation. */
  status?: CreateResponseStatus | null;
  /** These are errors that were encountered while trying to activate a hostname. */
  verificationErrors?: CreateResponseVerificationErrorsList | null;
}
export const CreateCustomHostnameResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    hostname: S.String,
    createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
    customMetadata: S.optional(
      S.NullOr(CreateResponseCustomMetadataMap).pipe(T.Body("custom_metadata")),
    ),
    customOriginServer: S.optional(
      S.NullOr(S.String).pipe(T.Body("custom_origin_server")),
    ),
    customOriginSni: S.optional(
      S.NullOr(S.String).pipe(T.Body("custom_origin_sni")),
    ),
    ownershipVerification: S.optional(
      S.NullOr(CreateResponseOwnershipVerification).pipe(
        T.Body("ownership_verification"),
      ),
    ),
    ownershipVerificationHttp: S.optional(
      S.NullOr(CreateResponseOwnershipVerificationHttp).pipe(
        T.Body("ownership_verification_http"),
      ),
    ),
    ssl: S.optional(S.NullOr(CreateResponseSsl)),
    status: S.optional(S.NullOr(CreateResponseStatus)),
    verificationErrors: S.optional(
      S.NullOr(CreateResponseVerificationErrorsList).pipe(
        T.Body("verification_errors"),
      ),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateCustomHostnameResponse",
}) as any as S.Schema<CreateCustomHostnameResponse>;

export interface DeleteCertificatePackCertificateRequest {
  /** Identifier. */
  zoneId: string;
  /** Identifier. */
  customHostnameId: string;
  /** Identifier. */
  certificatePackId: string;
  /** Identifier. */
  certificateId: string;
}
export const DeleteCertificatePackCertificateRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      zoneId: S.String.pipe(T.Label("zone_id")),
      customHostnameId: S.String.pipe(T.Label("custom_hostname_id")),
      certificatePackId: S.String.pipe(T.Label("certificate_pack_id")),
      certificateId: S.String.pipe(T.Label("certificate_id")),
    })
      .pipe(
        T.Http({
          method: "DELETE",
          uri: "/zones/{zone_id}/custom_hostnames/{custom_hostname_id}/certificate_pack/{certificate_pack_id}/certificates/{certificate_id}",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteCertificatePackCertificateRequest",
}) as any as S.Schema<DeleteCertificatePackCertificateRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface DeleteCertificatePackCertificateResponse {
  /** Identifier. */
  id?: string | null;
}
export const DeleteCertificatePackCertificateResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteCertificatePackCertificateResponse",
}) as any as S.Schema<DeleteCertificatePackCertificateResponse>;

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

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface DeleteCustomHostnameResponse {
  /** Identifier. */
  id?: string | null;
}
export const DeleteCustomHostnameResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteCustomHostnameResponse",
}) as any as S.Schema<DeleteCustomHostnameResponse>;

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

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

export type FallbackOriginDeleteResponseStatus =
  | "initializing"
  | "pending_deployment"
  | "pending_deletion"
  | "active"
  | "deployment_timed_out"
  | "deletion_timed_out";
export const FallbackOriginDeleteResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteFallbackOriginResponse {
  /** This is the time the fallback origin was created. */
  createdAt?: string | null;
  /** These are errors that were encountered while trying to activate a fallback origin. */
  errors?: FallbackOriginDeleteResponseErrorsList | null;
  /** Your origin hostname that requests to your custom hostnames will be sent to. */
  origin?: string | null;
  /** Status of the fallback origin's activation. */
  status?: FallbackOriginDeleteResponseStatus | null;
  /** This is the time the fallback origin was updated. */
  updatedAt?: string | null;
}
export const DeleteFallbackOriginResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
    errors: S.optional(S.NullOr(FallbackOriginDeleteResponseErrorsList)),
    origin: S.optional(S.NullOr(S.String)),
    status: S.optional(S.NullOr(FallbackOriginDeleteResponseStatus)),
    updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteFallbackOriginResponse",
}) as any as S.Schema<DeleteFallbackOriginResponse>;

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

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

export type GetResponseOwnershipVerificationType = "txt";
export const GetResponseOwnershipVerificationType = /*@__PURE__*/ S.String;

export interface GetResponseOwnershipVerification {
  /** DNS Name for record. */
  name?: string | null;
  /** DNS Record type. */
  type?: GetResponseOwnershipVerificationType | null;
  /** Content for the record. */
  value?: string | null;
}
export const GetResponseOwnershipVerification = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.optional(S.NullOr(S.String)),
    type: S.optional(S.NullOr(GetResponseOwnershipVerificationType)),
    value: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "GetResponseOwnershipVerification",
}) as any as S.Schema<GetResponseOwnershipVerification>;

export type GetResponseOwnershipVerificationHttp =
  CreateResponseOwnershipVerificationHttp;
export const GetResponseOwnershipVerificationHttp =
  CreateResponseOwnershipVerificationHttp;

export type GetResponseSslBundleMethod = "ubiquitous" | "optimal" | "force";
export const GetResponseSslBundleMethod = /*@__PURE__*/ S.String;

export type GetResponseSslCertificateAuthority =
  | "digicert"
  | "google"
  | "lets_encrypt"
  | "ssl_com";
export const GetResponseSslCertificateAuthority = /*@__PURE__*/ S.String;

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

export interface GetResponseSslDcvDelegationRecordsItem {
  /** The CNAME record hostname for DCV delegation. */
  cname?: string | null;
  /** The CNAME record target value for DCV delegation. */
  cnameTarget?: string | null;
  /** The set of email addresses that the certificate authority (CA) will use to complete domain validation. */
  emails?: GetResponseSslDcvDelegationRecordsItemEmailsList | null;
  /** The content that the certificate authority (CA) will expect to find at the http_url during the domain validation. */
  httpBody?: string | null;
  /** The url that will be checked during domain validation. */
  httpUrl?: string | null;
  /** Status of the validation record. */
  status?: string | null;
  /** The hostname that the certificate authority (CA) will check for a TXT record during domain validation . */
  txtName?: string | null;
  /** The TXT record that the certificate authority (CA) will check during domain validation. */
  txtValue?: string | null;
}
export const GetResponseSslDcvDelegationRecordsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      cname: S.optional(S.NullOr(S.String)),
      cnameTarget: S.optional(S.NullOr(S.String).pipe(T.Body("cname_target"))),
      emails: S.optional(
        S.NullOr(GetResponseSslDcvDelegationRecordsItemEmailsList),
      ),
      httpBody: S.optional(S.NullOr(S.String).pipe(T.Body("http_body"))),
      httpUrl: S.optional(S.NullOr(S.String).pipe(T.Body("http_url"))),
      status: S.optional(S.NullOr(S.String)),
      txtName: S.optional(S.NullOr(S.String).pipe(T.Body("txt_name"))),
      txtValue: S.optional(S.NullOr(S.String).pipe(T.Body("txt_value"))),
    }),
).annotate({
  identifier: "GetResponseSslDcvDelegationRecordsItem",
}) as any as S.Schema<GetResponseSslDcvDelegationRecordsItem>;

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

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

export type GetResponseSslMethod = "http" | "txt" | "email";
export const GetResponseSslMethod = /*@__PURE__*/ S.String;

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

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

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

export type GetResponseSslSettingsMinTlsVersion = "1.0" | "1.1" | "1.2" | "1.3";
export const GetResponseSslSettingsMinTlsVersion = /*@__PURE__*/ S.String;

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

export interface GetResponseSslSettings {
  /** An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format. */
  ciphers?: GetResponseSslSettingsCiphersList | null;
  /** Whether or not Early Hints is enabled. */
  earlyHints?: GetResponseSslSettingsEarlyHints | null;
  /** Whether or not HTTP2 is enabled. */
  http2?: GetResponseSslSettingsHttp2 | null;
  /** The minimum TLS version supported. */
  minTlsVersion?: GetResponseSslSettingsMinTlsVersion | null;
  /** Whether or not TLS 1.3 is enabled. */
  tls_1_3?: GetResponseSslSettingsTls13 | null;
}
export const GetResponseSslSettings = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    ciphers: S.optional(S.NullOr(GetResponseSslSettingsCiphersList)),
    earlyHints: S.optional(
      S.NullOr(GetResponseSslSettingsEarlyHints).pipe(T.Body("early_hints")),
    ),
    http2: S.optional(S.NullOr(GetResponseSslSettingsHttp2)),
    minTlsVersion: S.optional(
      S.NullOr(GetResponseSslSettingsMinTlsVersion).pipe(
        T.Body("min_tls_version"),
      ),
    ),
    tls_1_3: S.optional(S.NullOr(GetResponseSslSettingsTls13)),
  }),
).annotate({
  identifier: "GetResponseSslSettings",
}) as any as S.Schema<GetResponseSslSettings>;

export type GetResponseSslStatus =
  | "initializing"
  | "pending_validation"
  | "deleted"
  | "pending_issuance"
  | "pending_deployment"
  | "pending_deletion"
  | "pending_expiration"
  | "expired"
  | "active"
  | "initializing_timed_out"
  | "validation_timed_out"
  | "issuance_timed_out"
  | "deployment_timed_out"
  | "deletion_timed_out"
  | "pending_cleanup"
  | "staging_deployment"
  | "staging_active"
  | "deactivating"
  | "inactive"
  | "backup_issued"
  | "holding_deployment";
export const GetResponseSslStatus = /*@__PURE__*/ S.String;

export type GetResponseSslType = "dv";
export const GetResponseSslType = /*@__PURE__*/ S.String;

export type GetResponseSslValidationErrorsItem =
  CreateResponseSslValidationErrorsItem;
export const GetResponseSslValidationErrorsItem =
  CreateResponseSslValidationErrorsItem;

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

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

export interface GetResponseSslValidationRecordsItem {
  /** The CNAME record hostname for DCV delegation. */
  cname?: string | null;
  /** The CNAME record target value for DCV delegation. */
  cnameTarget?: string | null;
  /** The set of email addresses that the certificate authority (CA) will use to complete domain validation. */
  emails?: GetResponseSslValidationRecordsItemEmailsList | null;
  /** The content that the certificate authority (CA) will expect to find at the http_url during the domain validation. */
  httpBody?: string | null;
  /** The url that will be checked during domain validation. */
  httpUrl?: string | null;
  /** Status of the validation record. */
  status?: string | null;
  /** The hostname that the certificate authority (CA) will check for a TXT record during domain validation . */
  txtName?: string | null;
  /** The TXT record that the certificate authority (CA) will check during domain validation. */
  txtValue?: string | null;
}
export const GetResponseSslValidationRecordsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    cname: S.optional(S.NullOr(S.String)),
    cnameTarget: S.optional(S.NullOr(S.String).pipe(T.Body("cname_target"))),
    emails: S.optional(S.NullOr(GetResponseSslValidationRecordsItemEmailsList)),
    httpBody: S.optional(S.NullOr(S.String).pipe(T.Body("http_body"))),
    httpUrl: S.optional(S.NullOr(S.String).pipe(T.Body("http_url"))),
    status: S.optional(S.NullOr(S.String)),
    txtName: S.optional(S.NullOr(S.String).pipe(T.Body("txt_name"))),
    txtValue: S.optional(S.NullOr(S.String).pipe(T.Body("txt_value"))),
  }),
).annotate({
  identifier: "GetResponseSslValidationRecordsItem",
}) as any as S.Schema<GetResponseSslValidationRecordsItem>;

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

export interface GetResponseSsl {
  /** Custom hostname SSL identifier tag. */
  id?: string | null;
  /** A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates. And the force bundle verifies the chain, but does not otherwise modify it. */
  bundleMethod?: GetResponseSslBundleMethod | null;
  /** The Certificate Authority that will issue the certificate. */
  certificateAuthority?: GetResponseSslCertificateAuthority | null;
  /** If a custom uploaded certificate is used. */
  customCertificate?: string | null;
  /** The identifier for the Custom CSR that was used. */
  customCsrId?: string | null;
  /** The key for a custom uploaded certificate. */
  customKey?: string | null;
  /** DCV Delegation records for domain validation. */
  dcvDelegationRecords?: GetResponseSslDcvDelegationRecordsList | null;
  /** The time the custom certificate expires on. */
  expiresOn?: string | null;
  /** A list of Hostnames on a custom uploaded certificate. */
  hosts?: GetResponseSslHostsList | null;
  /** The issuer on a custom uploaded certificate. */
  issuer?: string | null;
  /** Domain control validation (DCV) method used for this hostname. */
  method?: GetResponseSslMethod | null;
  /** The serial number on a custom uploaded certificate. */
  serialNumber?: string | null;
  settings?: GetResponseSslSettings | null;
  /** The signature on a custom uploaded certificate. */
  signature?: string | null;
  /** Status of the hostname's SSL certificates. */
  status?: GetResponseSslStatus | null;
  /** Level of validation to be used for this hostname. Domain validation (dv) must be used. */
  type?: GetResponseSslType | null;
  /** The time the custom certificate was uploaded. */
  uploadedOn?: string | null;
  /** Domain validation errors that have been received by the certificate authority (CA). */
  validationErrors?: GetResponseSslValidationErrorsList | null;
  validationRecords?: GetResponseSslValidationRecordsList | null;
  /** Indicates whether the certificate covers a wildcard. */
  wildcard?: boolean | null;
}
export const GetResponseSsl = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    bundleMethod: S.optional(
      S.NullOr(GetResponseSslBundleMethod).pipe(T.Body("bundle_method")),
    ),
    certificateAuthority: S.optional(
      S.NullOr(GetResponseSslCertificateAuthority).pipe(
        T.Body("certificate_authority"),
      ),
    ),
    customCertificate: S.optional(
      S.NullOr(S.String).pipe(T.Body("custom_certificate")),
    ),
    customCsrId: S.optional(S.NullOr(S.String).pipe(T.Body("custom_csr_id"))),
    customKey: S.optional(S.NullOr(S.String).pipe(T.Body("custom_key"))),
    dcvDelegationRecords: S.optional(
      S.NullOr(GetResponseSslDcvDelegationRecordsList).pipe(
        T.Body("dcv_delegation_records"),
      ),
    ),
    expiresOn: S.optional(S.NullOr(S.String).pipe(T.Body("expires_on"))),
    hosts: S.optional(S.NullOr(GetResponseSslHostsList)),
    issuer: S.optional(S.NullOr(S.String)),
    method: S.optional(S.NullOr(GetResponseSslMethod)),
    serialNumber: S.optional(S.NullOr(S.String).pipe(T.Body("serial_number"))),
    settings: S.optional(S.NullOr(GetResponseSslSettings)),
    signature: S.optional(S.NullOr(S.String)),
    status: S.optional(S.NullOr(GetResponseSslStatus)),
    type: S.optional(S.NullOr(GetResponseSslType)),
    uploadedOn: S.optional(S.NullOr(S.String).pipe(T.Body("uploaded_on"))),
    validationErrors: S.optional(
      S.NullOr(GetResponseSslValidationErrorsList).pipe(
        T.Body("validation_errors"),
      ),
    ),
    validationRecords: S.optional(
      S.NullOr(GetResponseSslValidationRecordsList).pipe(
        T.Body("validation_records"),
      ),
    ),
    wildcard: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({ identifier: "GetResponseSsl" }) as any as S.Schema<GetResponseSsl>;

export type GetResponseStatus =
  | "active"
  | "pending"
  | "active_redeploying"
  | "moved"
  | "pending_deletion"
  | "deleted"
  | "pending_blocked"
  | "pending_migration"
  | "pending_provisioned"
  | "test_pending"
  | "test_active"
  | "test_active_apex"
  | "test_blocked"
  | "test_failed"
  | "provisioned"
  | "blocked";
export const GetResponseStatus = /*@__PURE__*/ S.String;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetCustomHostnameResponse {
  /** Identifier. */
  id: string;
  /** The custom hostname that will point to your hostname via CNAME. */
  hostname: string;
  /** This is the time the hostname was created. */
  createdAt?: string | null;
  /** Unique key/value metadata for this hostname. These are per-hostname (customer) settings. */
  customMetadata?: GetResponseCustomMetadataMap | null;
  /** a valid hostname that’s been added to your DNS zone as an A, AAAA, or CNAME record. */
  customOriginServer?: string | null;
  /** A hostname that will be sent to your custom origin server as SNI for TLS handshake. This can be a valid subdomain of the zone or custom origin server name or the string ':request_host_header:' which will cause the host header in the request to be used as SNI. Not configurable with default/fallback origin server. */
  customOriginSni?: string | null;
  /** This is a record which can be placed to activate a hostname. */
  ownershipVerification?: GetResponseOwnershipVerification | null;
  /** This presents the token to be served by the given http url to activate a hostname. */
  ownershipVerificationHttp?: CreateResponseOwnershipVerificationHttp | null;
  ssl?: GetResponseSsl | null;
  /** Status of the hostname's activation. */
  status?: GetResponseStatus | null;
  /** These are errors that were encountered while trying to activate a hostname. */
  verificationErrors?: GetResponseVerificationErrorsList | null;
}
export const GetCustomHostnameResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    hostname: S.String,
    createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
    customMetadata: S.optional(
      S.NullOr(GetResponseCustomMetadataMap).pipe(T.Body("custom_metadata")),
    ),
    customOriginServer: S.optional(
      S.NullOr(S.String).pipe(T.Body("custom_origin_server")),
    ),
    customOriginSni: S.optional(
      S.NullOr(S.String).pipe(T.Body("custom_origin_sni")),
    ),
    ownershipVerification: S.optional(
      S.NullOr(GetResponseOwnershipVerification).pipe(
        T.Body("ownership_verification"),
      ),
    ),
    ownershipVerificationHttp: S.optional(
      S.NullOr(CreateResponseOwnershipVerificationHttp).pipe(
        T.Body("ownership_verification_http"),
      ),
    ),
    ssl: S.optional(S.NullOr(GetResponseSsl)),
    status: S.optional(S.NullOr(GetResponseStatus)),
    verificationErrors: S.optional(
      S.NullOr(GetResponseVerificationErrorsList).pipe(
        T.Body("verification_errors"),
      ),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetCustomHostnameResponse",
}) as any as S.Schema<GetCustomHostnameResponse>;

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

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

export type FallbackOriginGetResponseStatus =
  | "initializing"
  | "pending_deployment"
  | "pending_deletion"
  | "active"
  | "deployment_timed_out"
  | "deletion_timed_out";
export const FallbackOriginGetResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetFallbackOriginResponse {
  /** This is the time the fallback origin was created. */
  createdAt?: string | null;
  /** These are errors that were encountered while trying to activate a fallback origin. */
  errors?: FallbackOriginGetResponseErrorsList | null;
  /** Your origin hostname that requests to your custom hostnames will be sent to. */
  origin?: string | null;
  /** Status of the fallback origin's activation. */
  status?: FallbackOriginGetResponseStatus | null;
  /** This is the time the fallback origin was updated. */
  updatedAt?: string | null;
}
export const GetFallbackOriginResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
    errors: S.optional(S.NullOr(FallbackOriginGetResponseErrorsList)),
    origin: S.optional(S.NullOr(S.String)),
    status: S.optional(S.NullOr(FallbackOriginGetResponseStatus)),
    updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetFallbackOriginResponse",
}) as any as S.Schema<GetFallbackOriginResponse>;

export type ListRequestCertificateAuthority =
  | "google"
  | "lets_encrypt"
  | "ssl_com";
export const ListRequestCertificateAuthority = /*@__PURE__*/ S.String;

export type ListRequestDirection = "asc" | "desc";
export const ListRequestDirection = /*@__PURE__*/ S.String;

export interface ListRequestHostname {
  /** Filters hostnames by a substring match on the hostname value. This parameter cannot be used with the 'id', 'hostname', 'hostname.exact', or 'hostname.startsWith' parameters. */
  contain?: string;
  /** Fully qualified domain name to match against. This parameter cannot be used with the 'id', 'hostname', 'hostname.contain', or 'hostname.startsWith' parameters. */
  exact?: string;
  /** Filters hostnames by a prefix match on the hostname value. This parameter cannot be used with the 'id', 'hostname', 'hostname.exact', or 'hostname.contain' parameters. */
  startsWith?: string;
}
export const ListRequestHostname = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    contain: S.optional(S.String),
    exact: S.optional(S.String),
    startsWith: S.optional(S.String),
  }),
).annotate({
  identifier: "ListRequestHostname",
}) as any as S.Schema<ListRequestHostname>;

export type ListRequestHostnameStatus =
  | "active"
  | "pending"
  | "active_redeploying"
  | "moved"
  | "pending_deletion"
  | "deleted"
  | "pending_blocked"
  | "pending_migration"
  | "pending_provisioned"
  | "test_pending"
  | "test_active"
  | "test_active_apex"
  | "test_blocked"
  | "test_failed"
  | "provisioned"
  | "blocked";
export const ListRequestHostnameStatus = /*@__PURE__*/ S.String;

export type ListRequestOrder = "ssl" | "ssl_status";
export const ListRequestOrder = /*@__PURE__*/ S.String;

export type ListRequestSslStatus =
  | "initializing"
  | "pending_validation"
  | "deleted"
  | "pending_issuance"
  | "pending_deployment"
  | "pending_deletion"
  | "pending_expiration"
  | "expired"
  | "active"
  | "initializing_timed_out"
  | "validation_timed_out"
  | "issuance_timed_out"
  | "deployment_timed_out"
  | "deletion_timed_out"
  | "pending_cleanup"
  | "staging_deployment"
  | "staging_active"
  | "deactivating"
  | "inactive"
  | "backup_issued"
  | "holding_deployment";
export const ListRequestSslStatus = /*@__PURE__*/ S.String;

export interface ListCustomHostnamesRequest {
  /** Identifier. */
  zoneId: string;
  /** Hostname ID to match against. This ID was generated and returned during the initial custom_hostname creation. This parameter cannot be used with the 'hostname', 'hostname.exact', 'hostname.contain', or 'hostname.startsWith' parameters. */
  id?: string;
  /** Filter by the certificate authority that issued the SSL certificate. */
  certificateAuthority?: ListRequestCertificateAuthority | (string & {});
  /** Filter by custom origin server name. */
  customOriginServer?: string;
  /** Direction to order hostnames. */
  direction?: ListRequestDirection | (string & {});
  hostname?: ListRequestHostname;
  /** Filter by the hostname's activation status. */
  hostnameStatus?: ListRequestHostnameStatus | (string & {});
  /** Field to order hostnames by. */
  order?: ListRequestOrder | (string & {});
  /** Page number of paginated results. */
  page?: number;
  /** Number of hostnames per page. */
  perPage?: number;
  /** Whether to filter hostnames based on if they have SSL enabled. */
  ssl?: string;
  /** Filter by SSL certificate status. */
  sslStatus?: ListRequestSslStatus | (string & {});
  /** Filter by whether the custom hostname is a wildcard hostname. */
  wildcard?: boolean;
}
export const ListCustomHostnamesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    id: S.optional(S.String.pipe(T.Query())),
    certificateAuthority: S.optional(
      ListRequestCertificateAuthority.pipe(T.Query("certificate_authority")),
    ),
    customOriginServer: S.optional(
      S.String.pipe(T.Query("custom_origin_server")),
    ),
    direction: S.optional(ListRequestDirection.pipe(T.Query())),
    hostname: S.optional(ListRequestHostname.pipe(T.DeepQuery("hostname"))),
    hostnameStatus: S.optional(
      ListRequestHostnameStatus.pipe(T.Query("hostname_status")),
    ),
    order: S.optional(ListRequestOrder.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    ssl: S.optional(S.String.pipe(T.Query())),
    sslStatus: S.optional(ListRequestSslStatus.pipe(T.Query("ssl_status"))),
    wildcard: S.optional(S.Boolean.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/custom_hostnames",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListCustomHostnamesRequest",
}) as any as S.Schema<ListCustomHostnamesRequest>;

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

export type ListResultItemOwnershipVerificationType = "txt";
export const ListResultItemOwnershipVerificationType = /*@__PURE__*/ S.String;

export interface ListResultItemOwnershipVerification {
  /** DNS Name for record. */
  name?: string | null;
  /** DNS Record type. */
  type?: ListResultItemOwnershipVerificationType | null;
  /** Content for the record. */
  value?: string | null;
}
export const ListResultItemOwnershipVerification = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.optional(S.NullOr(S.String)),
    type: S.optional(S.NullOr(ListResultItemOwnershipVerificationType)),
    value: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "ListResultItemOwnershipVerification",
}) as any as S.Schema<ListResultItemOwnershipVerification>;

export type ListResultItemOwnershipVerificationHttp =
  CreateResponseOwnershipVerificationHttp;
export const ListResultItemOwnershipVerificationHttp =
  CreateResponseOwnershipVerificationHttp;

export type ListResultItemSslBundleMethod = "ubiquitous" | "optimal" | "force";
export const ListResultItemSslBundleMethod = /*@__PURE__*/ S.String;

export type ListResultItemSslCertificateAuthority =
  | "digicert"
  | "google"
  | "lets_encrypt"
  | "ssl_com";
export const ListResultItemSslCertificateAuthority = /*@__PURE__*/ S.String;

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

export interface ListResultItemSslDcvDelegationRecordsItem {
  /** The CNAME record hostname for DCV delegation. */
  cname?: string | null;
  /** The CNAME record target value for DCV delegation. */
  cnameTarget?: string | null;
  /** The set of email addresses that the certificate authority (CA) will use to complete domain validation. */
  emails?: ListResultItemSslDcvDelegationRecordsItemEmailsList | null;
  /** The content that the certificate authority (CA) will expect to find at the http_url during the domain validation. */
  httpBody?: string | null;
  /** The url that will be checked during domain validation. */
  httpUrl?: string | null;
  /** Status of the validation record. */
  status?: string | null;
  /** The hostname that the certificate authority (CA) will check for a TXT record during domain validation . */
  txtName?: string | null;
  /** The TXT record that the certificate authority (CA) will check during domain validation. */
  txtValue?: string | null;
}
export const ListResultItemSslDcvDelegationRecordsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      cname: S.optional(S.NullOr(S.String)),
      cnameTarget: S.optional(S.NullOr(S.String).pipe(T.Body("cname_target"))),
      emails: S.optional(
        S.NullOr(ListResultItemSslDcvDelegationRecordsItemEmailsList),
      ),
      httpBody: S.optional(S.NullOr(S.String).pipe(T.Body("http_body"))),
      httpUrl: S.optional(S.NullOr(S.String).pipe(T.Body("http_url"))),
      status: S.optional(S.NullOr(S.String)),
      txtName: S.optional(S.NullOr(S.String).pipe(T.Body("txt_name"))),
      txtValue: S.optional(S.NullOr(S.String).pipe(T.Body("txt_value"))),
    }),
  ).annotate({
    identifier: "ListResultItemSslDcvDelegationRecordsItem",
  }) as any as S.Schema<ListResultItemSslDcvDelegationRecordsItem>;

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

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

export type ListResultItemSslMethod = "http" | "txt" | "email";
export const ListResultItemSslMethod = /*@__PURE__*/ S.String;

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

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

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

export type ListResultItemSslSettingsMinTlsVersion =
  | "1.0"
  | "1.1"
  | "1.2"
  | "1.3";
export const ListResultItemSslSettingsMinTlsVersion = /*@__PURE__*/ S.String;

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

export interface ListResultItemSslSettings {
  /** An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format. */
  ciphers?: ListResultItemSslSettingsCiphersList | null;
  /** Whether or not Early Hints is enabled. */
  earlyHints?: ListResultItemSslSettingsEarlyHints | null;
  /** Whether or not HTTP2 is enabled. */
  http2?: ListResultItemSslSettingsHttp2 | null;
  /** The minimum TLS version supported. */
  minTlsVersion?: ListResultItemSslSettingsMinTlsVersion | null;
  /** Whether or not TLS 1.3 is enabled. */
  tls_1_3?: ListResultItemSslSettingsTls13 | null;
}
export const ListResultItemSslSettings = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    ciphers: S.optional(S.NullOr(ListResultItemSslSettingsCiphersList)),
    earlyHints: S.optional(
      S.NullOr(ListResultItemSslSettingsEarlyHints).pipe(T.Body("early_hints")),
    ),
    http2: S.optional(S.NullOr(ListResultItemSslSettingsHttp2)),
    minTlsVersion: S.optional(
      S.NullOr(ListResultItemSslSettingsMinTlsVersion).pipe(
        T.Body("min_tls_version"),
      ),
    ),
    tls_1_3: S.optional(S.NullOr(ListResultItemSslSettingsTls13)),
  }),
).annotate({
  identifier: "ListResultItemSslSettings",
}) as any as S.Schema<ListResultItemSslSettings>;

export type ListResultItemSslStatus =
  | "initializing"
  | "pending_validation"
  | "deleted"
  | "pending_issuance"
  | "pending_deployment"
  | "pending_deletion"
  | "pending_expiration"
  | "expired"
  | "active"
  | "initializing_timed_out"
  | "validation_timed_out"
  | "issuance_timed_out"
  | "deployment_timed_out"
  | "deletion_timed_out"
  | "pending_cleanup"
  | "staging_deployment"
  | "staging_active"
  | "deactivating"
  | "inactive"
  | "backup_issued"
  | "holding_deployment";
export const ListResultItemSslStatus = /*@__PURE__*/ S.String;

export type ListResultItemSslType = "dv";
export const ListResultItemSslType = /*@__PURE__*/ S.String;

export type ListResultItemSslValidationErrorsItem =
  CreateResponseSslValidationErrorsItem;
export const ListResultItemSslValidationErrorsItem =
  CreateResponseSslValidationErrorsItem;

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

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

export interface ListResultItemSslValidationRecordsItem {
  /** The CNAME record hostname for DCV delegation. */
  cname?: string | null;
  /** The CNAME record target value for DCV delegation. */
  cnameTarget?: string | null;
  /** The set of email addresses that the certificate authority (CA) will use to complete domain validation. */
  emails?: ListResultItemSslValidationRecordsItemEmailsList | null;
  /** The content that the certificate authority (CA) will expect to find at the http_url during the domain validation. */
  httpBody?: string | null;
  /** The url that will be checked during domain validation. */
  httpUrl?: string | null;
  /** Status of the validation record. */
  status?: string | null;
  /** The hostname that the certificate authority (CA) will check for a TXT record during domain validation . */
  txtName?: string | null;
  /** The TXT record that the certificate authority (CA) will check during domain validation. */
  txtValue?: string | null;
}
export const ListResultItemSslValidationRecordsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      cname: S.optional(S.NullOr(S.String)),
      cnameTarget: S.optional(S.NullOr(S.String).pipe(T.Body("cname_target"))),
      emails: S.optional(
        S.NullOr(ListResultItemSslValidationRecordsItemEmailsList),
      ),
      httpBody: S.optional(S.NullOr(S.String).pipe(T.Body("http_body"))),
      httpUrl: S.optional(S.NullOr(S.String).pipe(T.Body("http_url"))),
      status: S.optional(S.NullOr(S.String)),
      txtName: S.optional(S.NullOr(S.String).pipe(T.Body("txt_name"))),
      txtValue: S.optional(S.NullOr(S.String).pipe(T.Body("txt_value"))),
    }),
).annotate({
  identifier: "ListResultItemSslValidationRecordsItem",
}) as any as S.Schema<ListResultItemSslValidationRecordsItem>;

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

export interface ListResultItemSsl {
  /** Custom hostname SSL identifier tag. */
  id?: string | null;
  /** A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates. And the force bundle verifies the chain, but does not otherwise modify it. */
  bundleMethod?: ListResultItemSslBundleMethod | null;
  /** The Certificate Authority that will issue the certificate. */
  certificateAuthority?: ListResultItemSslCertificateAuthority | null;
  /** If a custom uploaded certificate is used. */
  customCertificate?: string | null;
  /** The identifier for the Custom CSR that was used. */
  customCsrId?: string | null;
  /** The key for a custom uploaded certificate. */
  customKey?: string | null;
  /** DCV Delegation records for domain validation. */
  dcvDelegationRecords?: ListResultItemSslDcvDelegationRecordsList | null;
  /** The time the custom certificate expires on. */
  expiresOn?: string | null;
  /** A list of Hostnames on a custom uploaded certificate. */
  hosts?: ListResultItemSslHostsList | null;
  /** The issuer on a custom uploaded certificate. */
  issuer?: string | null;
  /** Domain control validation (DCV) method used for this hostname. */
  method?: ListResultItemSslMethod | null;
  /** The serial number on a custom uploaded certificate. */
  serialNumber?: string | null;
  settings?: ListResultItemSslSettings | null;
  /** The signature on a custom uploaded certificate. */
  signature?: string | null;
  /** Status of the hostname's SSL certificates. */
  status?: ListResultItemSslStatus | null;
  /** Level of validation to be used for this hostname. Domain validation (dv) must be used. */
  type?: ListResultItemSslType | null;
  /** The time the custom certificate was uploaded. */
  uploadedOn?: string | null;
  /** Domain validation errors that have been received by the certificate authority (CA). */
  validationErrors?: ListResultItemSslValidationErrorsList | null;
  validationRecords?: ListResultItemSslValidationRecordsList | null;
  /** Indicates whether the certificate covers a wildcard. */
  wildcard?: boolean | null;
}
export const ListResultItemSsl = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    bundleMethod: S.optional(
      S.NullOr(ListResultItemSslBundleMethod).pipe(T.Body("bundle_method")),
    ),
    certificateAuthority: S.optional(
      S.NullOr(ListResultItemSslCertificateAuthority).pipe(
        T.Body("certificate_authority"),
      ),
    ),
    customCertificate: S.optional(
      S.NullOr(S.String).pipe(T.Body("custom_certificate")),
    ),
    customCsrId: S.optional(S.NullOr(S.String).pipe(T.Body("custom_csr_id"))),
    customKey: S.optional(S.NullOr(S.String).pipe(T.Body("custom_key"))),
    dcvDelegationRecords: S.optional(
      S.NullOr(ListResultItemSslDcvDelegationRecordsList).pipe(
        T.Body("dcv_delegation_records"),
      ),
    ),
    expiresOn: S.optional(S.NullOr(S.String).pipe(T.Body("expires_on"))),
    hosts: S.optional(S.NullOr(ListResultItemSslHostsList)),
    issuer: S.optional(S.NullOr(S.String)),
    method: S.optional(S.NullOr(ListResultItemSslMethod)),
    serialNumber: S.optional(S.NullOr(S.String).pipe(T.Body("serial_number"))),
    settings: S.optional(S.NullOr(ListResultItemSslSettings)),
    signature: S.optional(S.NullOr(S.String)),
    status: S.optional(S.NullOr(ListResultItemSslStatus)),
    type: S.optional(S.NullOr(ListResultItemSslType)),
    uploadedOn: S.optional(S.NullOr(S.String).pipe(T.Body("uploaded_on"))),
    validationErrors: S.optional(
      S.NullOr(ListResultItemSslValidationErrorsList).pipe(
        T.Body("validation_errors"),
      ),
    ),
    validationRecords: S.optional(
      S.NullOr(ListResultItemSslValidationRecordsList).pipe(
        T.Body("validation_records"),
      ),
    ),
    wildcard: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "ListResultItemSsl",
}) as any as S.Schema<ListResultItemSsl>;

export type ListResultItemStatus =
  | "active"
  | "pending"
  | "active_redeploying"
  | "moved"
  | "pending_deletion"
  | "deleted"
  | "pending_blocked"
  | "pending_migration"
  | "pending_provisioned"
  | "test_pending"
  | "test_active"
  | "test_active_apex"
  | "test_blocked"
  | "test_failed"
  | "provisioned"
  | "blocked";
export const ListResultItemStatus = /*@__PURE__*/ S.String;

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

export interface ListResultItem {
  /** Identifier. */
  id: string;
  /** The custom hostname that will point to your hostname via CNAME. */
  hostname: string;
  /** This is the time the hostname was created. */
  createdAt?: string | null;
  /** Unique key/value metadata for this hostname. These are per-hostname (customer) settings. */
  customMetadata?: ListResultItemCustomMetadataMap | null;
  /** a valid hostname that’s been added to your DNS zone as an A, AAAA, or CNAME record. */
  customOriginServer?: string | null;
  /** A hostname that will be sent to your custom origin server as SNI for TLS handshake. This can be a valid subdomain of the zone or custom origin server name or the string ':request_host_header:' which will cause the host header in the request to be used as SNI. Not configurable with default/fallback origin server. */
  customOriginSni?: string | null;
  /** This is a record which can be placed to activate a hostname. */
  ownershipVerification?: ListResultItemOwnershipVerification | null;
  /** This presents the token to be served by the given http url to activate a hostname. */
  ownershipVerificationHttp?: CreateResponseOwnershipVerificationHttp | null;
  ssl?: ListResultItemSsl | null;
  /** Status of the hostname's activation. */
  status?: ListResultItemStatus | null;
  /** These are errors that were encountered while trying to activate a hostname. */
  verificationErrors?: ListResultItemVerificationErrorsList | null;
}
export const ListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    hostname: S.String,
    createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
    customMetadata: S.optional(
      S.NullOr(ListResultItemCustomMetadataMap).pipe(T.Body("custom_metadata")),
    ),
    customOriginServer: S.optional(
      S.NullOr(S.String).pipe(T.Body("custom_origin_server")),
    ),
    customOriginSni: S.optional(
      S.NullOr(S.String).pipe(T.Body("custom_origin_sni")),
    ),
    ownershipVerification: S.optional(
      S.NullOr(ListResultItemOwnershipVerification).pipe(
        T.Body("ownership_verification"),
      ),
    ),
    ownershipVerificationHttp: S.optional(
      S.NullOr(CreateResponseOwnershipVerificationHttp).pipe(
        T.Body("ownership_verification_http"),
      ),
    ),
    ssl: S.optional(S.NullOr(ListResultItemSsl)),
    status: S.optional(S.NullOr(ListResultItemStatus)),
    verificationErrors: S.optional(
      S.NullOr(ListResultItemVerificationErrorsList).pipe(
        T.Body("verification_errors"),
      ),
    ),
  }),
).annotate({ identifier: "ListResultItem" }) as any as S.Schema<ListResultItem>;

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

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

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

export type EditRequestSslBundleMethod = "ubiquitous" | "optimal" | "force";
export const EditRequestSslBundleMethod = /*@__PURE__*/ S.String;

export type EditRequestSslCertificateAuthority =
  | "digicert"
  | "google"
  | "lets_encrypt"
  | "ssl_com";
export const EditRequestSslCertificateAuthority = /*@__PURE__*/ S.String;

export type EditRequestSslCustomCertBundleItem =
  CreateRequestSslCustomCertBundleItem;
export const EditRequestSslCustomCertBundleItem =
  CreateRequestSslCustomCertBundleItem;

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

export type EditRequestSslMethod = "http" | "txt" | "email";
export const EditRequestSslMethod = /*@__PURE__*/ S.String;

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

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

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

export type EditRequestSslSettingsMinTlsVersion = "1.0" | "1.1" | "1.2" | "1.3";
export const EditRequestSslSettingsMinTlsVersion = /*@__PURE__*/ S.String;

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

export interface EditRequestSslSettings {
  /** An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format. */
  ciphers?: EditRequestSslSettingsCiphersList;
  /** Whether or not Early Hints is enabled. */
  earlyHints?: EditRequestSslSettingsEarlyHints | (string & {});
  /** Whether or not HTTP2 is enabled. */
  http2?: EditRequestSslSettingsHttp2 | (string & {});
  /** The minimum TLS version supported. */
  minTlsVersion?: EditRequestSslSettingsMinTlsVersion | (string & {});
  /** Whether or not TLS 1.3 is enabled. */
  tls_1_3?: EditRequestSslSettingsTls13 | (string & {});
}
export const EditRequestSslSettings = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    ciphers: S.optional(EditRequestSslSettingsCiphersList),
    earlyHints: S.optional(
      EditRequestSslSettingsEarlyHints.pipe(T.Body("early_hints")),
    ),
    http2: S.optional(EditRequestSslSettingsHttp2),
    minTlsVersion: S.optional(
      EditRequestSslSettingsMinTlsVersion.pipe(T.Body("min_tls_version")),
    ),
    tls_1_3: S.optional(EditRequestSslSettingsTls13),
  }),
).annotate({
  identifier: "EditRequestSslSettings",
}) as any as S.Schema<EditRequestSslSettings>;

export type EditRequestSslType = "dv";
export const EditRequestSslType = /*@__PURE__*/ S.String;

export interface EditRequestSsl {
  /** A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates. And the force bundle verifies the chain, but does not otherwise modify it. */
  bundleMethod?: EditRequestSslBundleMethod | (string & {});
  /** The Certificate Authority that will issue the certificate. */
  certificateAuthority?: EditRequestSslCertificateAuthority | (string & {});
  /** Whether or not to add Cloudflare Branding for the order. This will add a subdomain of sni.cloudflaressl.com as the Common Name if set to true. */
  cloudflareBranding?: boolean;
  /** Array of custom certificate and key pairs (1 or 2 pairs allowed). */
  customCertBundle?: EditRequestSslCustomCertBundleList;
  /** If a custom uploaded certificate is used. */
  customCertificate?: string;
  /** The identifier for the Custom CSR that was used. */
  customCsrId?: string;
  /** The key for a custom uploaded certificate. */
  customKey?: string;
  /** Domain control validation (DCV) method used for this hostname. */
  method?: EditRequestSslMethod | (string & {});
  /** SSL specific settings. */
  settings?: EditRequestSslSettings;
  /** Level of validation to be used for this hostname. Domain validation (dv) must be used. */
  type?: EditRequestSslType | (string & {});
  /** Indicates whether the certificate covers a wildcard. */
  wildcard?: boolean;
}
export const EditRequestSsl = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    bundleMethod: S.optional(
      EditRequestSslBundleMethod.pipe(T.Body("bundle_method")),
    ),
    certificateAuthority: S.optional(
      EditRequestSslCertificateAuthority.pipe(T.Body("certificate_authority")),
    ),
    cloudflareBranding: S.optional(
      S.Boolean.pipe(T.Body("cloudflare_branding")),
    ),
    customCertBundle: S.optional(
      EditRequestSslCustomCertBundleList.pipe(T.Body("custom_cert_bundle")),
    ),
    customCertificate: S.optional(S.String.pipe(T.Body("custom_certificate"))),
    customCsrId: S.optional(S.String.pipe(T.Body("custom_csr_id"))),
    customKey: S.optional(S.String.pipe(T.Body("custom_key"))),
    method: S.optional(EditRequestSslMethod),
    settings: S.optional(EditRequestSslSettings),
    type: S.optional(EditRequestSslType),
    wildcard: S.optional(S.Boolean),
  }),
).annotate({ identifier: "EditRequestSsl" }) as any as S.Schema<EditRequestSsl>;

export interface PatchCustomHostnameRequest {
  /** Identifier. */
  zoneId: string;
  /** Identifier. */
  customHostnameId: string;
  /** Unique key/value metadata for this hostname. These are per-hostname (customer) settings. */
  customMetadata?: EditRequestCustomMetadataMap;
  /** a valid hostname that’s been added to your DNS zone as an A, AAAA, or CNAME record. */
  customOriginServer?: string;
  /** A hostname that will be sent to your custom origin server as SNI for TLS handshake. This can be a valid subdomain of the zone or custom origin server name or the string ':request_host_header:' which will cause the host header in the request to be used as SNI. Not configurable with default/fallback origin server. */
  customOriginSni?: string;
  /** SSL properties used when creating the custom hostname. */
  ssl?: EditRequestSsl;
}
export const PatchCustomHostnameRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    customHostnameId: S.String.pipe(T.Label("custom_hostname_id")),
    customMetadata: S.optional(
      EditRequestCustomMetadataMap.pipe(T.Body("custom_metadata")),
    ),
    customOriginServer: S.optional(
      S.String.pipe(T.Body("custom_origin_server")),
    ),
    customOriginSni: S.optional(S.String.pipe(T.Body("custom_origin_sni"))),
    ssl: S.optional(EditRequestSsl),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/zones/{zone_id}/custom_hostnames/{custom_hostname_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchCustomHostnameRequest",
}) as any as S.Schema<PatchCustomHostnameRequest>;

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

export type EditResponseOwnershipVerificationType = "txt";
export const EditResponseOwnershipVerificationType = /*@__PURE__*/ S.String;

export interface EditResponseOwnershipVerification {
  /** DNS Name for record. */
  name?: string | null;
  /** DNS Record type. */
  type?: EditResponseOwnershipVerificationType | null;
  /** Content for the record. */
  value?: string | null;
}
export const EditResponseOwnershipVerification = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.optional(S.NullOr(S.String)),
    type: S.optional(S.NullOr(EditResponseOwnershipVerificationType)),
    value: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "EditResponseOwnershipVerification",
}) as any as S.Schema<EditResponseOwnershipVerification>;

export type EditResponseOwnershipVerificationHttp =
  CreateResponseOwnershipVerificationHttp;
export const EditResponseOwnershipVerificationHttp =
  CreateResponseOwnershipVerificationHttp;

export type EditResponseSslBundleMethod = "ubiquitous" | "optimal" | "force";
export const EditResponseSslBundleMethod = /*@__PURE__*/ S.String;

export type EditResponseSslCertificateAuthority =
  | "digicert"
  | "google"
  | "lets_encrypt"
  | "ssl_com";
export const EditResponseSslCertificateAuthority = /*@__PURE__*/ S.String;

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

export interface EditResponseSslDcvDelegationRecordsItem {
  /** The CNAME record hostname for DCV delegation. */
  cname?: string | null;
  /** The CNAME record target value for DCV delegation. */
  cnameTarget?: string | null;
  /** The set of email addresses that the certificate authority (CA) will use to complete domain validation. */
  emails?: EditResponseSslDcvDelegationRecordsItemEmailsList | null;
  /** The content that the certificate authority (CA) will expect to find at the http_url during the domain validation. */
  httpBody?: string | null;
  /** The url that will be checked during domain validation. */
  httpUrl?: string | null;
  /** Status of the validation record. */
  status?: string | null;
  /** The hostname that the certificate authority (CA) will check for a TXT record during domain validation . */
  txtName?: string | null;
  /** The TXT record that the certificate authority (CA) will check during domain validation. */
  txtValue?: string | null;
}
export const EditResponseSslDcvDelegationRecordsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      cname: S.optional(S.NullOr(S.String)),
      cnameTarget: S.optional(S.NullOr(S.String).pipe(T.Body("cname_target"))),
      emails: S.optional(
        S.NullOr(EditResponseSslDcvDelegationRecordsItemEmailsList),
      ),
      httpBody: S.optional(S.NullOr(S.String).pipe(T.Body("http_body"))),
      httpUrl: S.optional(S.NullOr(S.String).pipe(T.Body("http_url"))),
      status: S.optional(S.NullOr(S.String)),
      txtName: S.optional(S.NullOr(S.String).pipe(T.Body("txt_name"))),
      txtValue: S.optional(S.NullOr(S.String).pipe(T.Body("txt_value"))),
    }),
).annotate({
  identifier: "EditResponseSslDcvDelegationRecordsItem",
}) as any as S.Schema<EditResponseSslDcvDelegationRecordsItem>;

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

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

export type EditResponseSslMethod = "http" | "txt" | "email";
export const EditResponseSslMethod = /*@__PURE__*/ S.String;

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

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

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

export type EditResponseSslSettingsMinTlsVersion =
  | "1.0"
  | "1.1"
  | "1.2"
  | "1.3";
export const EditResponseSslSettingsMinTlsVersion = /*@__PURE__*/ S.String;

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

export interface EditResponseSslSettings {
  /** An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format. */
  ciphers?: EditResponseSslSettingsCiphersList | null;
  /** Whether or not Early Hints is enabled. */
  earlyHints?: EditResponseSslSettingsEarlyHints | null;
  /** Whether or not HTTP2 is enabled. */
  http2?: EditResponseSslSettingsHttp2 | null;
  /** The minimum TLS version supported. */
  minTlsVersion?: EditResponseSslSettingsMinTlsVersion | null;
  /** Whether or not TLS 1.3 is enabled. */
  tls_1_3?: EditResponseSslSettingsTls13 | null;
}
export const EditResponseSslSettings = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    ciphers: S.optional(S.NullOr(EditResponseSslSettingsCiphersList)),
    earlyHints: S.optional(
      S.NullOr(EditResponseSslSettingsEarlyHints).pipe(T.Body("early_hints")),
    ),
    http2: S.optional(S.NullOr(EditResponseSslSettingsHttp2)),
    minTlsVersion: S.optional(
      S.NullOr(EditResponseSslSettingsMinTlsVersion).pipe(
        T.Body("min_tls_version"),
      ),
    ),
    tls_1_3: S.optional(S.NullOr(EditResponseSslSettingsTls13)),
  }),
).annotate({
  identifier: "EditResponseSslSettings",
}) as any as S.Schema<EditResponseSslSettings>;

export type EditResponseSslStatus =
  | "initializing"
  | "pending_validation"
  | "deleted"
  | "pending_issuance"
  | "pending_deployment"
  | "pending_deletion"
  | "pending_expiration"
  | "expired"
  | "active"
  | "initializing_timed_out"
  | "validation_timed_out"
  | "issuance_timed_out"
  | "deployment_timed_out"
  | "deletion_timed_out"
  | "pending_cleanup"
  | "staging_deployment"
  | "staging_active"
  | "deactivating"
  | "inactive"
  | "backup_issued"
  | "holding_deployment";
export const EditResponseSslStatus = /*@__PURE__*/ S.String;

export type EditResponseSslType = "dv";
export const EditResponseSslType = /*@__PURE__*/ S.String;

export type EditResponseSslValidationErrorsItem =
  CreateResponseSslValidationErrorsItem;
export const EditResponseSslValidationErrorsItem =
  CreateResponseSslValidationErrorsItem;

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

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

export interface EditResponseSslValidationRecordsItem {
  /** The CNAME record hostname for DCV delegation. */
  cname?: string | null;
  /** The CNAME record target value for DCV delegation. */
  cnameTarget?: string | null;
  /** The set of email addresses that the certificate authority (CA) will use to complete domain validation. */
  emails?: EditResponseSslValidationRecordsItemEmailsList | null;
  /** The content that the certificate authority (CA) will expect to find at the http_url during the domain validation. */
  httpBody?: string | null;
  /** The url that will be checked during domain validation. */
  httpUrl?: string | null;
  /** Status of the validation record. */
  status?: string | null;
  /** The hostname that the certificate authority (CA) will check for a TXT record during domain validation . */
  txtName?: string | null;
  /** The TXT record that the certificate authority (CA) will check during domain validation. */
  txtValue?: string | null;
}
export const EditResponseSslValidationRecordsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      cname: S.optional(S.NullOr(S.String)),
      cnameTarget: S.optional(S.NullOr(S.String).pipe(T.Body("cname_target"))),
      emails: S.optional(
        S.NullOr(EditResponseSslValidationRecordsItemEmailsList),
      ),
      httpBody: S.optional(S.NullOr(S.String).pipe(T.Body("http_body"))),
      httpUrl: S.optional(S.NullOr(S.String).pipe(T.Body("http_url"))),
      status: S.optional(S.NullOr(S.String)),
      txtName: S.optional(S.NullOr(S.String).pipe(T.Body("txt_name"))),
      txtValue: S.optional(S.NullOr(S.String).pipe(T.Body("txt_value"))),
    }),
).annotate({
  identifier: "EditResponseSslValidationRecordsItem",
}) as any as S.Schema<EditResponseSslValidationRecordsItem>;

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

export interface EditResponseSsl {
  /** Custom hostname SSL identifier tag. */
  id?: string | null;
  /** A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates. And the force bundle verifies the chain, but does not otherwise modify it. */
  bundleMethod?: EditResponseSslBundleMethod | null;
  /** The Certificate Authority that will issue the certificate. */
  certificateAuthority?: EditResponseSslCertificateAuthority | null;
  /** If a custom uploaded certificate is used. */
  customCertificate?: string | null;
  /** The identifier for the Custom CSR that was used. */
  customCsrId?: string | null;
  /** The key for a custom uploaded certificate. */
  customKey?: string | null;
  /** DCV Delegation records for domain validation. */
  dcvDelegationRecords?: EditResponseSslDcvDelegationRecordsList | null;
  /** The time the custom certificate expires on. */
  expiresOn?: string | null;
  /** A list of Hostnames on a custom uploaded certificate. */
  hosts?: EditResponseSslHostsList | null;
  /** The issuer on a custom uploaded certificate. */
  issuer?: string | null;
  /** Domain control validation (DCV) method used for this hostname. */
  method?: EditResponseSslMethod | null;
  /** The serial number on a custom uploaded certificate. */
  serialNumber?: string | null;
  settings?: EditResponseSslSettings | null;
  /** The signature on a custom uploaded certificate. */
  signature?: string | null;
  /** Status of the hostname's SSL certificates. */
  status?: EditResponseSslStatus | null;
  /** Level of validation to be used for this hostname. Domain validation (dv) must be used. */
  type?: EditResponseSslType | null;
  /** The time the custom certificate was uploaded. */
  uploadedOn?: string | null;
  /** Domain validation errors that have been received by the certificate authority (CA). */
  validationErrors?: EditResponseSslValidationErrorsList | null;
  validationRecords?: EditResponseSslValidationRecordsList | null;
  /** Indicates whether the certificate covers a wildcard. */
  wildcard?: boolean | null;
}
export const EditResponseSsl = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    bundleMethod: S.optional(
      S.NullOr(EditResponseSslBundleMethod).pipe(T.Body("bundle_method")),
    ),
    certificateAuthority: S.optional(
      S.NullOr(EditResponseSslCertificateAuthority).pipe(
        T.Body("certificate_authority"),
      ),
    ),
    customCertificate: S.optional(
      S.NullOr(S.String).pipe(T.Body("custom_certificate")),
    ),
    customCsrId: S.optional(S.NullOr(S.String).pipe(T.Body("custom_csr_id"))),
    customKey: S.optional(S.NullOr(S.String).pipe(T.Body("custom_key"))),
    dcvDelegationRecords: S.optional(
      S.NullOr(EditResponseSslDcvDelegationRecordsList).pipe(
        T.Body("dcv_delegation_records"),
      ),
    ),
    expiresOn: S.optional(S.NullOr(S.String).pipe(T.Body("expires_on"))),
    hosts: S.optional(S.NullOr(EditResponseSslHostsList)),
    issuer: S.optional(S.NullOr(S.String)),
    method: S.optional(S.NullOr(EditResponseSslMethod)),
    serialNumber: S.optional(S.NullOr(S.String).pipe(T.Body("serial_number"))),
    settings: S.optional(S.NullOr(EditResponseSslSettings)),
    signature: S.optional(S.NullOr(S.String)),
    status: S.optional(S.NullOr(EditResponseSslStatus)),
    type: S.optional(S.NullOr(EditResponseSslType)),
    uploadedOn: S.optional(S.NullOr(S.String).pipe(T.Body("uploaded_on"))),
    validationErrors: S.optional(
      S.NullOr(EditResponseSslValidationErrorsList).pipe(
        T.Body("validation_errors"),
      ),
    ),
    validationRecords: S.optional(
      S.NullOr(EditResponseSslValidationRecordsList).pipe(
        T.Body("validation_records"),
      ),
    ),
    wildcard: S.optional(S.NullOr(S.Boolean)),
  }),
).annotate({
  identifier: "EditResponseSsl",
}) as any as S.Schema<EditResponseSsl>;

export type EditResponseStatus =
  | "active"
  | "pending"
  | "active_redeploying"
  | "moved"
  | "pending_deletion"
  | "deleted"
  | "pending_blocked"
  | "pending_migration"
  | "pending_provisioned"
  | "test_pending"
  | "test_active"
  | "test_active_apex"
  | "test_blocked"
  | "test_failed"
  | "provisioned"
  | "blocked";
export const EditResponseStatus = /*@__PURE__*/ S.String;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchCustomHostnameResponse {
  /** Identifier. */
  id: string;
  /** The custom hostname that will point to your hostname via CNAME. */
  hostname: string;
  /** This is the time the hostname was created. */
  createdAt?: string | null;
  /** Unique key/value metadata for this hostname. These are per-hostname (customer) settings. */
  customMetadata?: EditResponseCustomMetadataMap | null;
  /** a valid hostname that’s been added to your DNS zone as an A, AAAA, or CNAME record. */
  customOriginServer?: string | null;
  /** A hostname that will be sent to your custom origin server as SNI for TLS handshake. This can be a valid subdomain of the zone or custom origin server name or the string ':request_host_header:' which will cause the host header in the request to be used as SNI. Not configurable with default/fallback origin server. */
  customOriginSni?: string | null;
  /** This is a record which can be placed to activate a hostname. */
  ownershipVerification?: EditResponseOwnershipVerification | null;
  /** This presents the token to be served by the given http url to activate a hostname. */
  ownershipVerificationHttp?: CreateResponseOwnershipVerificationHttp | null;
  ssl?: EditResponseSsl | null;
  /** Status of the hostname's activation. */
  status?: EditResponseStatus | null;
  /** These are errors that were encountered while trying to activate a hostname. */
  verificationErrors?: EditResponseVerificationErrorsList | null;
}
export const PatchCustomHostnameResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    hostname: S.String,
    createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
    customMetadata: S.optional(
      S.NullOr(EditResponseCustomMetadataMap).pipe(T.Body("custom_metadata")),
    ),
    customOriginServer: S.optional(
      S.NullOr(S.String).pipe(T.Body("custom_origin_server")),
    ),
    customOriginSni: S.optional(
      S.NullOr(S.String).pipe(T.Body("custom_origin_sni")),
    ),
    ownershipVerification: S.optional(
      S.NullOr(EditResponseOwnershipVerification).pipe(
        T.Body("ownership_verification"),
      ),
    ),
    ownershipVerificationHttp: S.optional(
      S.NullOr(CreateResponseOwnershipVerificationHttp).pipe(
        T.Body("ownership_verification_http"),
      ),
    ),
    ssl: S.optional(S.NullOr(EditResponseSsl)),
    status: S.optional(S.NullOr(EditResponseStatus)),
    verificationErrors: S.optional(
      S.NullOr(EditResponseVerificationErrorsList).pipe(
        T.Body("verification_errors"),
      ),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchCustomHostnameResponse",
}) as any as S.Schema<PatchCustomHostnameResponse>;

export interface PutCertificatePackCertificateRequest {
  /** Identifier. */
  zoneId: string;
  /** Identifier. */
  customHostnameId: string;
  /** Identifier. */
  certificatePackId: string;
  /** Identifier. */
  certificateId: string;
  /** If a custom uploaded certificate is used. */
  customCertificate: string;
  /** The key for a custom uploaded certificate. */
  customKey: string;
}
export const PutCertificatePackCertificateRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      zoneId: S.String.pipe(T.Label("zone_id")),
      customHostnameId: S.String.pipe(T.Label("custom_hostname_id")),
      certificatePackId: S.String.pipe(T.Label("certificate_pack_id")),
      certificateId: S.String.pipe(T.Label("certificate_id")),
      customCertificate: S.String.pipe(T.Body("custom_certificate")),
      customKey: S.String.pipe(T.Body("custom_key")),
    })
      .pipe(
        T.Http({
          method: "PUT",
          uri: "/zones/{zone_id}/custom_hostnames/{custom_hostname_id}/certificate_pack/{certificate_pack_id}/certificates/{certificate_id}",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutCertificatePackCertificateRequest",
}) as any as S.Schema<PutCertificatePackCertificateRequest>;

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

export type CertificatePackCertificatesUpdateResponseOwnershipVerificationType =
  "txt";
export const CertificatePackCertificatesUpdateResponseOwnershipVerificationType =
  /*@__PURE__*/ S.String;

export interface CertificatePackCertificatesUpdateResponseOwnershipVerification {
  /** DNS Name for record. */
  name?: string | null;
  /** DNS Record type. */
  type?: CertificatePackCertificatesUpdateResponseOwnershipVerificationType | null;
  /** Content for the record. */
  value?: string | null;
}
export const CertificatePackCertificatesUpdateResponseOwnershipVerification =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      name: S.optional(S.NullOr(S.String)),
      type: S.optional(
        S.NullOr(
          CertificatePackCertificatesUpdateResponseOwnershipVerificationType,
        ),
      ),
      value: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "CertificatePackCertificatesUpdateResponseOwnershipVerification",
  }) as any as S.Schema<CertificatePackCertificatesUpdateResponseOwnershipVerification>;

export type CertificatePackCertificatesUpdateResponseOwnershipVerificationHttp =
  CreateResponseOwnershipVerificationHttp;
export const CertificatePackCertificatesUpdateResponseOwnershipVerificationHttp =
  CreateResponseOwnershipVerificationHttp;

export type CertificatePackCertificatesUpdateResponseSslBundleMethod =
  | "ubiquitous"
  | "optimal"
  | "force";
export const CertificatePackCertificatesUpdateResponseSslBundleMethod =
  /*@__PURE__*/ S.String;

export type CertificatePackCertificatesUpdateResponseSslCertificateAuthority =
  | "digicert"
  | "google"
  | "lets_encrypt"
  | "ssl_com";
export const CertificatePackCertificatesUpdateResponseSslCertificateAuthority =
  /*@__PURE__*/ S.String;

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

export interface CertificatePackCertificatesUpdateResponseSslDcvDelegationRecordsItem {
  /** The CNAME record hostname for DCV delegation. */
  cname?: string | null;
  /** The CNAME record target value for DCV delegation. */
  cnameTarget?: string | null;
  /** The set of email addresses that the certificate authority (CA) will use to complete domain validation. */
  emails?: CertificatePackCertificatesUpdateResponseSslDcvDelegationRecordsItemEmailsList | null;
  /** The content that the certificate authority (CA) will expect to find at the http_url during the domain validation. */
  httpBody?: string | null;
  /** The url that will be checked during domain validation. */
  httpUrl?: string | null;
  /** Status of the validation record. */
  status?: string | null;
  /** The hostname that the certificate authority (CA) will check for a TXT record during domain validation . */
  txtName?: string | null;
  /** The TXT record that the certificate authority (CA) will check during domain validation. */
  txtValue?: string | null;
}
export const CertificatePackCertificatesUpdateResponseSslDcvDelegationRecordsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      cname: S.optional(S.NullOr(S.String)),
      cnameTarget: S.optional(S.NullOr(S.String).pipe(T.Body("cname_target"))),
      emails: S.optional(
        S.NullOr(
          CertificatePackCertificatesUpdateResponseSslDcvDelegationRecordsItemEmailsList,
        ),
      ),
      httpBody: S.optional(S.NullOr(S.String).pipe(T.Body("http_body"))),
      httpUrl: S.optional(S.NullOr(S.String).pipe(T.Body("http_url"))),
      status: S.optional(S.NullOr(S.String)),
      txtName: S.optional(S.NullOr(S.String).pipe(T.Body("txt_name"))),
      txtValue: S.optional(S.NullOr(S.String).pipe(T.Body("txt_value"))),
    }),
  ).annotate({
    identifier:
      "CertificatePackCertificatesUpdateResponseSslDcvDelegationRecordsItem",
  }) as any as S.Schema<CertificatePackCertificatesUpdateResponseSslDcvDelegationRecordsItem>;

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

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

export type CertificatePackCertificatesUpdateResponseSslMethod =
  | "http"
  | "txt"
  | "email";
export const CertificatePackCertificatesUpdateResponseSslMethod =
  /*@__PURE__*/ S.String;

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

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

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

export type CertificatePackCertificatesUpdateResponseSslSettingsMinTlsVersion =
  | "1.0"
  | "1.1"
  | "1.2"
  | "1.3";
export const CertificatePackCertificatesUpdateResponseSslSettingsMinTlsVersion =
  /*@__PURE__*/ S.String;

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

export interface CertificatePackCertificatesUpdateResponseSslSettings {
  /** An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format. */
  ciphers?: CertificatePackCertificatesUpdateResponseSslSettingsCiphersList | null;
  /** Whether or not Early Hints is enabled. */
  earlyHints?: CertificatePackCertificatesUpdateResponseSslSettingsEarlyHints | null;
  /** Whether or not HTTP2 is enabled. */
  http2?: CertificatePackCertificatesUpdateResponseSslSettingsHttp2 | null;
  /** The minimum TLS version supported. */
  minTlsVersion?: CertificatePackCertificatesUpdateResponseSslSettingsMinTlsVersion | null;
  /** Whether or not TLS 1.3 is enabled. */
  tls_1_3?: CertificatePackCertificatesUpdateResponseSslSettingsTls13 | null;
}
export const CertificatePackCertificatesUpdateResponseSslSettings =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      ciphers: S.optional(
        S.NullOr(
          CertificatePackCertificatesUpdateResponseSslSettingsCiphersList,
        ),
      ),
      earlyHints: S.optional(
        S.NullOr(
          CertificatePackCertificatesUpdateResponseSslSettingsEarlyHints,
        ).pipe(T.Body("early_hints")),
      ),
      http2: S.optional(
        S.NullOr(CertificatePackCertificatesUpdateResponseSslSettingsHttp2),
      ),
      minTlsVersion: S.optional(
        S.NullOr(
          CertificatePackCertificatesUpdateResponseSslSettingsMinTlsVersion,
        ).pipe(T.Body("min_tls_version")),
      ),
      tls_1_3: S.optional(
        S.NullOr(CertificatePackCertificatesUpdateResponseSslSettingsTls13),
      ),
    }),
  ).annotate({
    identifier: "CertificatePackCertificatesUpdateResponseSslSettings",
  }) as any as S.Schema<CertificatePackCertificatesUpdateResponseSslSettings>;

export type CertificatePackCertificatesUpdateResponseSslStatus =
  | "initializing"
  | "pending_validation"
  | "deleted"
  | "pending_issuance"
  | "pending_deployment"
  | "pending_deletion"
  | "pending_expiration"
  | "expired"
  | "active"
  | "initializing_timed_out"
  | "validation_timed_out"
  | "issuance_timed_out"
  | "deployment_timed_out"
  | "deletion_timed_out"
  | "pending_cleanup"
  | "staging_deployment"
  | "staging_active"
  | "deactivating"
  | "inactive"
  | "backup_issued"
  | "holding_deployment";
export const CertificatePackCertificatesUpdateResponseSslStatus =
  /*@__PURE__*/ S.String;

export type CertificatePackCertificatesUpdateResponseSslType = "dv";
export const CertificatePackCertificatesUpdateResponseSslType =
  /*@__PURE__*/ S.String;

export type CertificatePackCertificatesUpdateResponseSslValidationErrorsItem =
  CreateResponseSslValidationErrorsItem;
export const CertificatePackCertificatesUpdateResponseSslValidationErrorsItem =
  CreateResponseSslValidationErrorsItem;

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

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

export interface CertificatePackCertificatesUpdateResponseSslValidationRecordsItem {
  /** The CNAME record hostname for DCV delegation. */
  cname?: string | null;
  /** The CNAME record target value for DCV delegation. */
  cnameTarget?: string | null;
  /** The set of email addresses that the certificate authority (CA) will use to complete domain validation. */
  emails?: CertificatePackCertificatesUpdateResponseSslValidationRecordsItemEmailsList | null;
  /** The content that the certificate authority (CA) will expect to find at the http_url during the domain validation. */
  httpBody?: string | null;
  /** The url that will be checked during domain validation. */
  httpUrl?: string | null;
  /** Status of the validation record. */
  status?: string | null;
  /** The hostname that the certificate authority (CA) will check for a TXT record during domain validation . */
  txtName?: string | null;
  /** The TXT record that the certificate authority (CA) will check during domain validation. */
  txtValue?: string | null;
}
export const CertificatePackCertificatesUpdateResponseSslValidationRecordsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      cname: S.optional(S.NullOr(S.String)),
      cnameTarget: S.optional(S.NullOr(S.String).pipe(T.Body("cname_target"))),
      emails: S.optional(
        S.NullOr(
          CertificatePackCertificatesUpdateResponseSslValidationRecordsItemEmailsList,
        ),
      ),
      httpBody: S.optional(S.NullOr(S.String).pipe(T.Body("http_body"))),
      httpUrl: S.optional(S.NullOr(S.String).pipe(T.Body("http_url"))),
      status: S.optional(S.NullOr(S.String)),
      txtName: S.optional(S.NullOr(S.String).pipe(T.Body("txt_name"))),
      txtValue: S.optional(S.NullOr(S.String).pipe(T.Body("txt_value"))),
    }),
  ).annotate({
    identifier:
      "CertificatePackCertificatesUpdateResponseSslValidationRecordsItem",
  }) as any as S.Schema<CertificatePackCertificatesUpdateResponseSslValidationRecordsItem>;

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

export interface CertificatePackCertificatesUpdateResponseSsl {
  /** Custom hostname SSL identifier tag. */
  id?: string | null;
  /** A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates. And the force bundle verifies the chain, but does not otherwise modify it. */
  bundleMethod?: CertificatePackCertificatesUpdateResponseSslBundleMethod | null;
  /** The Certificate Authority that will issue the certificate. */
  certificateAuthority?: CertificatePackCertificatesUpdateResponseSslCertificateAuthority | null;
  /** If a custom uploaded certificate is used. */
  customCertificate?: string | null;
  /** The identifier for the Custom CSR that was used. */
  customCsrId?: string | null;
  /** The key for a custom uploaded certificate. */
  customKey?: string | null;
  /** DCV Delegation records for domain validation. */
  dcvDelegationRecords?: CertificatePackCertificatesUpdateResponseSslDcvDelegationRecordsList | null;
  /** The time the custom certificate expires on. */
  expiresOn?: string | null;
  /** A list of Hostnames on a custom uploaded certificate. */
  hosts?: CertificatePackCertificatesUpdateResponseSslHostsList | null;
  /** The issuer on a custom uploaded certificate. */
  issuer?: string | null;
  /** Domain control validation (DCV) method used for this hostname. */
  method?: CertificatePackCertificatesUpdateResponseSslMethod | null;
  /** The serial number on a custom uploaded certificate. */
  serialNumber?: string | null;
  settings?: CertificatePackCertificatesUpdateResponseSslSettings | null;
  /** The signature on a custom uploaded certificate. */
  signature?: string | null;
  /** Status of the hostname's SSL certificates. */
  status?: CertificatePackCertificatesUpdateResponseSslStatus | null;
  /** Level of validation to be used for this hostname. Domain validation (dv) must be used. */
  type?: CertificatePackCertificatesUpdateResponseSslType | null;
  /** The time the custom certificate was uploaded. */
  uploadedOn?: string | null;
  /** Domain validation errors that have been received by the certificate authority (CA). */
  validationErrors?: CertificatePackCertificatesUpdateResponseSslValidationErrorsList | null;
  validationRecords?: CertificatePackCertificatesUpdateResponseSslValidationRecordsList | null;
  /** Indicates whether the certificate covers a wildcard. */
  wildcard?: boolean | null;
}
export const CertificatePackCertificatesUpdateResponseSsl =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      bundleMethod: S.optional(
        S.NullOr(CertificatePackCertificatesUpdateResponseSslBundleMethod).pipe(
          T.Body("bundle_method"),
        ),
      ),
      certificateAuthority: S.optional(
        S.NullOr(
          CertificatePackCertificatesUpdateResponseSslCertificateAuthority,
        ).pipe(T.Body("certificate_authority")),
      ),
      customCertificate: S.optional(
        S.NullOr(S.String).pipe(T.Body("custom_certificate")),
      ),
      customCsrId: S.optional(S.NullOr(S.String).pipe(T.Body("custom_csr_id"))),
      customKey: S.optional(S.NullOr(S.String).pipe(T.Body("custom_key"))),
      dcvDelegationRecords: S.optional(
        S.NullOr(
          CertificatePackCertificatesUpdateResponseSslDcvDelegationRecordsList,
        ).pipe(T.Body("dcv_delegation_records")),
      ),
      expiresOn: S.optional(S.NullOr(S.String).pipe(T.Body("expires_on"))),
      hosts: S.optional(
        S.NullOr(CertificatePackCertificatesUpdateResponseSslHostsList),
      ),
      issuer: S.optional(S.NullOr(S.String)),
      method: S.optional(
        S.NullOr(CertificatePackCertificatesUpdateResponseSslMethod),
      ),
      serialNumber: S.optional(
        S.NullOr(S.String).pipe(T.Body("serial_number")),
      ),
      settings: S.optional(
        S.NullOr(CertificatePackCertificatesUpdateResponseSslSettings),
      ),
      signature: S.optional(S.NullOr(S.String)),
      status: S.optional(
        S.NullOr(CertificatePackCertificatesUpdateResponseSslStatus),
      ),
      type: S.optional(
        S.NullOr(CertificatePackCertificatesUpdateResponseSslType),
      ),
      uploadedOn: S.optional(S.NullOr(S.String).pipe(T.Body("uploaded_on"))),
      validationErrors: S.optional(
        S.NullOr(
          CertificatePackCertificatesUpdateResponseSslValidationErrorsList,
        ).pipe(T.Body("validation_errors")),
      ),
      validationRecords: S.optional(
        S.NullOr(
          CertificatePackCertificatesUpdateResponseSslValidationRecordsList,
        ).pipe(T.Body("validation_records")),
      ),
      wildcard: S.optional(S.NullOr(S.Boolean)),
    }),
  ).annotate({
    identifier: "CertificatePackCertificatesUpdateResponseSsl",
  }) as any as S.Schema<CertificatePackCertificatesUpdateResponseSsl>;

export type CertificatePackCertificatesUpdateResponseStatus =
  | "active"
  | "pending"
  | "active_redeploying"
  | "moved"
  | "pending_deletion"
  | "deleted"
  | "pending_blocked"
  | "pending_migration"
  | "pending_provisioned"
  | "test_pending"
  | "test_active"
  | "test_active_apex"
  | "test_blocked"
  | "test_failed"
  | "provisioned"
  | "blocked";
export const CertificatePackCertificatesUpdateResponseStatus =
  /*@__PURE__*/ S.String;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PutCertificatePackCertificateResponse {
  /** Identifier. */
  id: string;
  /** The custom hostname that will point to your hostname via CNAME. */
  hostname: string;
  /** This is the time the hostname was created. */
  createdAt?: string | null;
  /** Unique key/value metadata for this hostname. These are per-hostname (customer) settings. */
  customMetadata?: CertificatePackCertificatesUpdateResponseCustomMetadataMap | null;
  /** a valid hostname that’s been added to your DNS zone as an A, AAAA, or CNAME record. */
  customOriginServer?: string | null;
  /** A hostname that will be sent to your custom origin server as SNI for TLS handshake. This can be a valid subdomain of the zone or custom origin server name or the string ':request_host_header:' which will cause the host header in the request to be used as SNI. Not configurable with default/fallback origin server. */
  customOriginSni?: string | null;
  /** This is a record which can be placed to activate a hostname. */
  ownershipVerification?: CertificatePackCertificatesUpdateResponseOwnershipVerification | null;
  /** This presents the token to be served by the given http url to activate a hostname. */
  ownershipVerificationHttp?: CreateResponseOwnershipVerificationHttp | null;
  ssl?: CertificatePackCertificatesUpdateResponseSsl | null;
  /** Status of the hostname's activation. */
  status?: CertificatePackCertificatesUpdateResponseStatus | null;
  /** These are errors that were encountered while trying to activate a hostname. */
  verificationErrors?: CertificatePackCertificatesUpdateResponseVerificationErrorsList | null;
}
export const PutCertificatePackCertificateResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      hostname: S.String,
      createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
      customMetadata: S.optional(
        S.NullOr(
          CertificatePackCertificatesUpdateResponseCustomMetadataMap,
        ).pipe(T.Body("custom_metadata")),
      ),
      customOriginServer: S.optional(
        S.NullOr(S.String).pipe(T.Body("custom_origin_server")),
      ),
      customOriginSni: S.optional(
        S.NullOr(S.String).pipe(T.Body("custom_origin_sni")),
      ),
      ownershipVerification: S.optional(
        S.NullOr(
          CertificatePackCertificatesUpdateResponseOwnershipVerification,
        ).pipe(T.Body("ownership_verification")),
      ),
      ownershipVerificationHttp: S.optional(
        S.NullOr(CreateResponseOwnershipVerificationHttp).pipe(
          T.Body("ownership_verification_http"),
        ),
      ),
      ssl: S.optional(S.NullOr(CertificatePackCertificatesUpdateResponseSsl)),
      status: S.optional(
        S.NullOr(CertificatePackCertificatesUpdateResponseStatus),
      ),
      verificationErrors: S.optional(
        S.NullOr(
          CertificatePackCertificatesUpdateResponseVerificationErrorsList,
        ).pipe(T.Body("verification_errors")),
      ),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutCertificatePackCertificateResponse",
}) as any as S.Schema<PutCertificatePackCertificateResponse>;

export interface PutFallbackOriginRequest {
  /** Identifier. */
  zoneId: string;
  /** Your origin hostname that requests to your custom hostnames will be sent to. */
  origin: string;
}
export const PutFallbackOriginRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    origin: S.String,
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/zones/{zone_id}/custom_hostnames/fallback_origin",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutFallbackOriginRequest",
}) as any as S.Schema<PutFallbackOriginRequest>;

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

export type FallbackOriginUpdateResponseStatus =
  | "initializing"
  | "pending_deployment"
  | "pending_deletion"
  | "active"
  | "deployment_timed_out"
  | "deletion_timed_out";
export const FallbackOriginUpdateResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PutFallbackOriginResponse {
  /** This is the time the fallback origin was created. */
  createdAt?: string | null;
  /** These are errors that were encountered while trying to activate a fallback origin. */
  errors?: FallbackOriginUpdateResponseErrorsList | null;
  /** Your origin hostname that requests to your custom hostnames will be sent to. */
  origin?: string | null;
  /** Status of the fallback origin's activation. */
  status?: FallbackOriginUpdateResponseStatus | null;
  /** This is the time the fallback origin was updated. */
  updatedAt?: string | null;
}
export const PutFallbackOriginResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    createdAt: S.optional(S.NullOr(S.String).pipe(T.Body("created_at"))),
    errors: S.optional(S.NullOr(FallbackOriginUpdateResponseErrorsList)),
    origin: S.optional(S.NullOr(S.String)),
    status: S.optional(S.NullOr(FallbackOriginUpdateResponseStatus)),
    updatedAt: S.optional(S.NullOr(S.String).pipe(T.Body("updated_at"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutFallbackOriginResponse",
}) as any as S.Schema<PutFallbackOriginResponse>;

export type CreateCustomHostnameError =
  | SaasQuotaNotAllocated
  | CloudflareOpError;
/** Add a new custom hostname and request that an SSL certificate be issued for it. One of three validation methods—http, txt, email—should be used, with 'http' recommended if the CNAME is already in place (or will be soon). Specifying 'email' will send an email to the WHOIS contacts on file for the base domain plus hostmaster, postmaster, webmaster, admin, administrator. If http is used and the domain is not already pointing to the Managed CNAME host, the PATCH method must be used once it is (to complete validation). Enable bundling of certificates using the custom_cert_bundle field. The bundling process requires the following condition One certificate in the bundle must use an RSA, and the other must use an ECDSA. */
export const createCustomHostname: API.OperationMethod<
  CreateCustomHostnameRequest,
  CreateCustomHostnameResponse,
  CreateCustomHostnameError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateCustomHostnameRequest,
  output: CreateCustomHostnameResponse,
  errors: [SaasQuotaNotAllocated, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteCertificatePackCertificateError = CloudflareOpError;
/** Delete a single custom certificate from a certificate pack that contains two bundled certificates. Deletion is subject to the following constraints. You cannot delete a certificate if it is the only remaining certificate in the pack. At least one certificate must remain in the pack. */
export const deleteCertificatePackCertificate: API.OperationMethod<
  DeleteCertificatePackCertificateRequest,
  DeleteCertificatePackCertificateResponse,
  DeleteCertificatePackCertificateError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteCertificatePackCertificateRequest,
  output: DeleteCertificatePackCertificateResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteCustomHostnameError =
  | CustomHostnameNotFound
  | SaasQuotaNotAllocated
  | CloudflareOpError;
/** Permanently deletes a custom hostname and revokes any SSL certificates that were issued for it. This action cannot be undone. */
export const deleteCustomHostname: API.OperationMethod<
  DeleteCustomHostnameRequest,
  DeleteCustomHostnameResponse,
  DeleteCustomHostnameError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteCustomHostnameRequest,
  output: DeleteCustomHostnameResponse,
  errors: [
    CustomHostnameNotFound,
    SaasQuotaNotAllocated,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteFallbackOriginError =
  | FallbackOriginNotFound
  | SaasAccessNotGranted
  | CloudflareOpError;
/** Removes the fallback origin configuration for custom hostnames on a zone. Custom hostnames without specific origins will no longer have a fallback. */
export const deleteFallbackOrigin: API.OperationMethod<
  DeleteFallbackOriginRequest,
  DeleteFallbackOriginResponse,
  DeleteFallbackOriginError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteFallbackOriginRequest,
  output: DeleteFallbackOriginResponse,
  errors: [
    FallbackOriginNotFound,
    SaasAccessNotGranted,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetCustomHostnameError =
  | CustomHostnameNotFound
  | SaasQuotaNotAllocated
  | Forbidden
  | CloudflareOpError;
/** Retrieves detailed information about a specific custom hostname, including SSL certificate status, ownership verification, and origin configuration. */
export const getCustomHostname: API.OperationMethod<
  GetCustomHostnameRequest,
  GetCustomHostnameResponse,
  GetCustomHostnameError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetCustomHostnameRequest,
  output: GetCustomHostnameResponse,
  errors: [
    CustomHostnameNotFound,
    SaasQuotaNotAllocated,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetFallbackOriginError =
  | FallbackOriginNotFound
  | SaasAccessNotGranted
  | Forbidden
  | CloudflareOpError;
/** Retrieves the current fallback origin configuration for custom hostnames on a zone. The fallback origin handles traffic when specific custom hostname origins are unavailable. */
export const getFallbackOrigin: API.OperationMethod<
  GetFallbackOriginRequest,
  GetFallbackOriginResponse,
  GetFallbackOriginError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetFallbackOriginRequest,
  output: GetFallbackOriginResponse,
  errors: [
    FallbackOriginNotFound,
    SaasAccessNotGranted,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListCustomHostnamesError =
  | SaasQuotaNotAllocated
  | Forbidden
  | CloudflareOpError;
/** List, search, sort, and filter all of your custom hostnames. */
export const listCustomHostnames: API.PaginatedOperationMethod<
  ListCustomHostnamesRequest,
  ListCustomHostnamesResponse,
  ListCustomHostnamesError,
  CloudflareOpContext,
  ListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListCustomHostnamesRequest,
    output: ListCustomHostnamesResponse,
    errors: [
      SaasQuotaNotAllocated,
      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 PatchCustomHostnameError =
  | CustomHostnameNotFound
  | SaasQuotaNotAllocated
  | CloudflareOpError;
/** Modify SSL configuration for a custom hostname. When sent with SSL config that matches existing config, used to indicate that hostname should pass domain control validation (DCV). Can also be used to change validation type, e.g., from 'http' to 'email'. Bundle an existing certificate with another certificate by using the "custom_cert_bundle" field. The bundling process supports combining certificates as long as the following condition is met. One certificate must use the RSA algorithm, and the other must use the ECDSA algorithm. */
export const patchCustomHostname: API.OperationMethod<
  PatchCustomHostnameRequest,
  PatchCustomHostnameResponse,
  PatchCustomHostnameError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchCustomHostnameRequest,
  output: PatchCustomHostnameResponse,
  errors: [
    CustomHostnameNotFound,
    SaasQuotaNotAllocated,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PutCertificatePackCertificateError = CloudflareOpError;
/** Replace a single custom certificate within a certificate pack that contains two bundled certificates. The replacement must adhere to the following constraints. You can only replace an RSA certificate with another RSA certificate or an ECDSA certificate with another ECDSA certificate. */
export const putCertificatePackCertificate: API.OperationMethod<
  PutCertificatePackCertificateRequest,
  PutCertificatePackCertificateResponse,
  PutCertificatePackCertificateError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PutCertificatePackCertificateRequest,
  output: PutCertificatePackCertificateResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PutFallbackOriginError = SaasAccessNotGranted | CloudflareOpError;
/** Updates the fallback origin configuration for custom hostnames on a zone. Sets the default origin server for custom hostname traffic. */
export const putFallbackOrigin: API.OperationMethod<
  PutFallbackOriginRequest,
  PutFallbackOriginResponse,
  PutFallbackOriginError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PutFallbackOriginRequest,
  output: PutFallbackOriginResponse,
  errors: [SaasAccessNotGranted, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));