@distilled.cloud/cloudflare 0.0.0-john

package/src/services/healthchecks.ts

@@ -0,0 +1,1866 @@
+/**
+ * Cloudflare HEALTHCHECKS API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service healthchecks
+ */
+
+import * as stream from "effect/Stream";
+import * as Schema from "effect/Schema";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import * as API from "../client/api.ts";
+import * as T from "../traits.ts";
+import type { Credentials } from "../credentials.ts";
+import { type DefaultErrors } from "../errors.ts";
+
+// =============================================================================
+// Healthcheck
+// =============================================================================
+
+export interface GetHealthcheckRequest {
+  healthcheckId: string;
+  /** Identifier */
+  zoneId: string;
+}
+
+export const GetHealthcheckRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  healthcheckId: Schema.String.pipe(T.HttpPath("healthcheckId")),
+  zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(
+  T.Http({
+    method: "GET",
+    path: "/zones/{zone_id}/healthchecks/{healthcheckId}",
+  }),
+) as unknown as Schema.Schema<GetHealthcheckRequest>;
+
+export interface GetHealthcheckResponse {
+  /** Identifier */
+  id?: string | null;
+  /** The hostname or IP address of the origin server to run health checks on. */
+  address?: string | null;
+  /** A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
+  checkRegions?:
+    | (
+        | "WNAM"
+        | "ENAM"
+        | "WEU"
+        | "EEU"
+        | "NSAM"
+        | "SSAM"
+        | "OC"
+        | "ME"
+        | "NAF"
+        | "SAF"
+        | "IN"
+        | "SEAS"
+        | "NEAS"
+        | "ALL_REGIONS"
+      )[]
+    | null;
+  /** The number of consecutive fails required from a health check before changing the health to unhealthy. */
+  consecutiveFails?: number | null;
+  /** The number of consecutive successes required from a health check before changing the health to healthy. */
+  consecutiveSuccesses?: number | null;
+  createdOn?: string | null;
+  /** A human-readable description of the health check. */
+  description?: string | null;
+  /** The current failure reason if status is unhealthy. */
+  failureReason?: string | null;
+  /** Parameters specific to an HTTP or HTTPS health check. */
+  httpConfig?: {
+    allowInsecure?: boolean | null;
+    expectedBody?: string | null;
+    expectedCodes?: string[] | null;
+    followRedirects?: boolean | null;
+    header?: Record<string, unknown> | null;
+    method?: "GET" | "HEAD" | null;
+    path?: string | null;
+    port?: number | null;
+  } | null;
+  /** The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locations. */
+  interval?: number | null;
+  modifiedOn?: string | null;
+  /** A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
+  name?: string | null;
+  /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+  retries?: number | null;
+  /** The current status of the origin server according to the health check. */
+  status?: "unknown" | "healthy" | "unhealthy" | "suspended" | null;
+  /** If suspended, no health checks are sent to the origin. */
+  suspended?: boolean | null;
+  /** Parameters specific to TCP health check. */
+  tcpConfig?: {
+    method?: "connection_established" | null;
+    port?: number | null;
+  } | null;
+  /** The timeout (in seconds) before marking the health check as failed. */
+  timeout?: number | null;
+  /** The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
+  type?: string | null;
+}
+
+export const GetHealthcheckResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    address: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    checkRegions: Schema.optional(
+      Schema.Union([
+        Schema.Array(
+          Schema.Literals([
+            "WNAM",
+            "ENAM",
+            "WEU",
+            "EEU",
+            "NSAM",
+            "SSAM",
+            "OC",
+            "ME",
+            "NAF",
+            "SAF",
+            "IN",
+            "SEAS",
+            "NEAS",
+            "ALL_REGIONS",
+          ]),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    consecutiveFails: Schema.optional(
+      Schema.Union([Schema.Number, Schema.Null]),
+    ),
+    consecutiveSuccesses: Schema.optional(
+      Schema.Union([Schema.Number, Schema.Null]),
+    ),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    failureReason: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    httpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          allowInsecure: Schema.optional(
+            Schema.Union([Schema.Boolean, Schema.Null]),
+          ),
+          expectedBody: Schema.optional(
+            Schema.Union([Schema.String, Schema.Null]),
+          ),
+          expectedCodes: Schema.optional(
+            Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+          ),
+          followRedirects: Schema.optional(
+            Schema.Union([Schema.Boolean, Schema.Null]),
+          ),
+          header: Schema.optional(
+            Schema.Union([Schema.Struct({}), Schema.Null]),
+          ),
+          method: Schema.optional(
+            Schema.Union([Schema.Literals(["GET", "HEAD"]), Schema.Null]),
+          ),
+          path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+          port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }).pipe(
+          Schema.encodeKeys({
+            allowInsecure: "allow_insecure",
+            expectedBody: "expected_body",
+            expectedCodes: "expected_codes",
+            followRedirects: "follow_redirects",
+            header: "header",
+            method: "method",
+            path: "path",
+            port: "port",
+          }),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    interval: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    retries: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    status: Schema.optional(
+      Schema.Union([
+        Schema.Literals(["unknown", "healthy", "unhealthy", "suspended"]),
+        Schema.Null,
+      ]),
+    ),
+    suspended: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    tcpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          method: Schema.optional(
+            Schema.Union([
+              Schema.Literal("connection_established"),
+              Schema.Null,
+            ]),
+          ),
+          port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }),
+        Schema.Null,
+      ]),
+    ),
+    timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    type: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  },
+)
+  .pipe(
+    Schema.encodeKeys({
+      id: "id",
+      address: "address",
+      checkRegions: "check_regions",
+      consecutiveFails: "consecutive_fails",
+      consecutiveSuccesses: "consecutive_successes",
+      createdOn: "created_on",
+      description: "description",
+      failureReason: "failure_reason",
+      httpConfig: "http_config",
+      interval: "interval",
+      modifiedOn: "modified_on",
+      name: "name",
+      retries: "retries",
+      status: "status",
+      suspended: "suspended",
+      tcpConfig: "tcp_config",
+      timeout: "timeout",
+      type: "type",
+    }),
+  )
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<GetHealthcheckResponse>;
+
+export type GetHealthcheckError = DefaultErrors;
+
+export const getHealthcheck: API.OperationMethod<
+  GetHealthcheckRequest,
+  GetHealthcheckResponse,
+  GetHealthcheckError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: GetHealthcheckRequest,
+  output: GetHealthcheckResponse,
+  errors: [],
+}));
+
+export interface ListHealthchecksRequest {
+  /** Path param: Identifier */
+  zoneId: string;
+}
+
+export const ListHealthchecksRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+  }).pipe(
+    T.Http({ method: "GET", path: "/zones/{zone_id}/healthchecks" }),
+  ) as unknown as Schema.Schema<ListHealthchecksRequest>;
+
+export interface ListHealthchecksResponse {
+  result: {
+    id?: string | null;
+    address?: string | null;
+    checkRegions?:
+      | (
+          | "WNAM"
+          | "ENAM"
+          | "WEU"
+          | "EEU"
+          | "NSAM"
+          | "SSAM"
+          | "OC"
+          | "ME"
+          | "NAF"
+          | "SAF"
+          | "IN"
+          | "SEAS"
+          | "NEAS"
+          | "ALL_REGIONS"
+        )[]
+      | null;
+    consecutiveFails?: number | null;
+    consecutiveSuccesses?: number | null;
+    createdOn?: string | null;
+    description?: string | null;
+    failureReason?: string | null;
+    httpConfig?: {
+      allowInsecure?: boolean | null;
+      expectedBody?: string | null;
+      expectedCodes?: string[] | null;
+      followRedirects?: boolean | null;
+      header?: Record<string, unknown> | null;
+      method?: "GET" | "HEAD" | null;
+      path?: string | null;
+      port?: number | null;
+    } | null;
+    interval?: number | null;
+    modifiedOn?: string | null;
+    name?: string | null;
+    retries?: number | null;
+    status?: "unknown" | "healthy" | "unhealthy" | "suspended" | null;
+    suspended?: boolean | null;
+    tcpConfig?: {
+      method?: "connection_established" | null;
+      port?: number | null;
+    } | null;
+    timeout?: number | null;
+    type?: string | null;
+  }[];
+  resultInfo: {
+    count?: number | null;
+    page?: number | null;
+    perPage?: number | null;
+    totalCount?: number | null;
+  };
+}
+
+export const ListHealthchecksResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(
+      Schema.Struct({
+        id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        address: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        checkRegions: Schema.optional(
+          Schema.Union([
+            Schema.Array(
+              Schema.Literals([
+                "WNAM",
+                "ENAM",
+                "WEU",
+                "EEU",
+                "NSAM",
+                "SSAM",
+                "OC",
+                "ME",
+                "NAF",
+                "SAF",
+                "IN",
+                "SEAS",
+                "NEAS",
+                "ALL_REGIONS",
+              ]),
+            ),
+            Schema.Null,
+          ]),
+        ),
+        consecutiveFails: Schema.optional(
+          Schema.Union([Schema.Number, Schema.Null]),
+        ),
+        consecutiveSuccesses: Schema.optional(
+          Schema.Union([Schema.Number, Schema.Null]),
+        ),
+        createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        description: Schema.optional(
+          Schema.Union([Schema.String, Schema.Null]),
+        ),
+        failureReason: Schema.optional(
+          Schema.Union([Schema.String, Schema.Null]),
+        ),
+        httpConfig: Schema.optional(
+          Schema.Union([
+            Schema.Struct({
+              allowInsecure: Schema.optional(
+                Schema.Union([Schema.Boolean, Schema.Null]),
+              ),
+              expectedBody: Schema.optional(
+                Schema.Union([Schema.String, Schema.Null]),
+              ),
+              expectedCodes: Schema.optional(
+                Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+              ),
+              followRedirects: Schema.optional(
+                Schema.Union([Schema.Boolean, Schema.Null]),
+              ),
+              header: Schema.optional(
+                Schema.Union([Schema.Struct({}), Schema.Null]),
+              ),
+              method: Schema.optional(
+                Schema.Union([Schema.Literals(["GET", "HEAD"]), Schema.Null]),
+              ),
+              path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+              port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            }).pipe(
+              Schema.encodeKeys({
+                allowInsecure: "allow_insecure",
+                expectedBody: "expected_body",
+                expectedCodes: "expected_codes",
+                followRedirects: "follow_redirects",
+                header: "header",
+                method: "method",
+                path: "path",
+                port: "port",
+              }),
+            ),
+            Schema.Null,
+          ]),
+        ),
+        interval: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        retries: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        status: Schema.optional(
+          Schema.Union([
+            Schema.Literals(["unknown", "healthy", "unhealthy", "suspended"]),
+            Schema.Null,
+          ]),
+        ),
+        suspended: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        tcpConfig: Schema.optional(
+          Schema.Union([
+            Schema.Struct({
+              method: Schema.optional(
+                Schema.Union([
+                  Schema.Literal("connection_established"),
+                  Schema.Null,
+                ]),
+              ),
+              port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            }),
+            Schema.Null,
+          ]),
+        ),
+        timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        type: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      }).pipe(
+        Schema.encodeKeys({
+          id: "id",
+          address: "address",
+          checkRegions: "check_regions",
+          consecutiveFails: "consecutive_fails",
+          consecutiveSuccesses: "consecutive_successes",
+          createdOn: "created_on",
+          description: "description",
+          failureReason: "failure_reason",
+          httpConfig: "http_config",
+          interval: "interval",
+          modifiedOn: "modified_on",
+          name: "name",
+          retries: "retries",
+          status: "status",
+          suspended: "suspended",
+          tcpConfig: "tcp_config",
+          timeout: "timeout",
+          type: "type",
+        }),
+      ),
+    ),
+    resultInfo: Schema.Struct({
+      count: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+      page: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+      perPage: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+      totalCount: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    }).pipe(
+      Schema.encodeKeys({
+        count: "count",
+        page: "page",
+        perPage: "per_page",
+        totalCount: "total_count",
+      }),
+    ),
+  }).pipe(
+    Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
+  ) as unknown as Schema.Schema<ListHealthchecksResponse>;
+
+export type ListHealthchecksError = DefaultErrors;
+
+export const listHealthchecks: API.PaginatedOperationMethod<
+  ListHealthchecksRequest,
+  ListHealthchecksResponse,
+  ListHealthchecksError,
+  Credentials | HttpClient.HttpClient
+> & {
+  pages: (
+    input: ListHealthchecksRequest,
+  ) => stream.Stream<
+    ListHealthchecksResponse,
+    ListHealthchecksError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: ListHealthchecksRequest) => stream.Stream<
+    {
+      id?: string | null;
+      address?: string | null;
+      checkRegions?:
+        | (
+            | "WNAM"
+            | "ENAM"
+            | "WEU"
+            | "EEU"
+            | "NSAM"
+            | "SSAM"
+            | "OC"
+            | "ME"
+            | "NAF"
+            | "SAF"
+            | "IN"
+            | "SEAS"
+            | "NEAS"
+            | "ALL_REGIONS"
+          )[]
+        | null;
+      consecutiveFails?: number | null;
+      consecutiveSuccesses?: number | null;
+      createdOn?: string | null;
+      description?: string | null;
+      failureReason?: string | null;
+      httpConfig?: {
+        allowInsecure?: boolean | null;
+        expectedBody?: string | null;
+        expectedCodes?: string[] | null;
+        followRedirects?: boolean | null;
+        header?: Record<string, unknown> | null;
+        method?: "GET" | "HEAD" | null;
+        path?: string | null;
+        port?: number | null;
+      } | null;
+      interval?: number | null;
+      modifiedOn?: string | null;
+      name?: string | null;
+      retries?: number | null;
+      status?: "unknown" | "healthy" | "unhealthy" | "suspended" | null;
+      suspended?: boolean | null;
+      tcpConfig?: {
+        method?: "connection_established" | null;
+        port?: number | null;
+      } | null;
+      timeout?: number | null;
+      type?: string | null;
+    },
+    ListHealthchecksError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
+  input: ListHealthchecksRequest,
+  output: ListHealthchecksResponse,
+  errors: [],
+  pagination: {
+    mode: "page",
+    inputToken: "page",
+    outputToken: "resultInfo.page",
+    items: "result",
+    pageSize: "perPage",
+  } as const,
+}));
+
+export interface CreateHealthcheckRequest {
+  /** Path param: Identifier */
+  zoneId: string;
+  /** Body param: The hostname or IP address of the origin server to run health checks on. */
+  address: string;
+  /** Body param: A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
+  name: string;
+  /** Body param: A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
+  checkRegions?:
+    | (
+        | "WNAM"
+        | "ENAM"
+        | "WEU"
+        | "EEU"
+        | "NSAM"
+        | "SSAM"
+        | "OC"
+        | "ME"
+        | "NAF"
+        | "SAF"
+        | "IN"
+        | "SEAS"
+        | "NEAS"
+        | "ALL_REGIONS"
+      )[]
+    | null;
+  /** Body param: The number of consecutive fails required from a health check before changing the health to unhealthy. */
+  consecutiveFails?: number;
+  /** Body param: The number of consecutive successes required from a health check before changing the health to healthy. */
+  consecutiveSuccesses?: number;
+  /** Body param: A human-readable description of the health check. */
+  description?: string;
+  /** Body param: Parameters specific to an HTTP or HTTPS health check. */
+  httpConfig?: {
+    allowInsecure?: boolean;
+    expectedBody?: string;
+    expectedCodes?: string[] | null;
+    followRedirects?: boolean;
+    header?: Record<string, unknown> | null;
+    method?: "GET" | "HEAD";
+    path?: string;
+    port?: number;
+  } | null;
+  /** Body param: The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locati */
+  interval?: number;
+  /** Body param: The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+  retries?: number;
+  /** Body param: If suspended, no health checks are sent to the origin. */
+  suspended?: boolean;
+  /** Body param: Parameters specific to TCP health check. */
+  tcpConfig?: { method?: "connection_established"; port?: number } | null;
+  /** Body param: The timeout (in seconds) before marking the health check as failed. */
+  timeout?: number;
+  /** Body param: The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
+  type?: string;
+}
+
+export const CreateHealthcheckRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    address: Schema.String,
+    name: Schema.String,
+    checkRegions: Schema.optional(
+      Schema.Union([
+        Schema.Array(
+          Schema.Literals([
+            "WNAM",
+            "ENAM",
+            "WEU",
+            "EEU",
+            "NSAM",
+            "SSAM",
+            "OC",
+            "ME",
+            "NAF",
+            "SAF",
+            "IN",
+            "SEAS",
+            "NEAS",
+            "ALL_REGIONS",
+          ]),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    consecutiveFails: Schema.optional(Schema.Number),
+    consecutiveSuccesses: Schema.optional(Schema.Number),
+    description: Schema.optional(Schema.String),
+    httpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          allowInsecure: Schema.optional(Schema.Boolean),
+          expectedBody: Schema.optional(Schema.String),
+          expectedCodes: Schema.optional(
+            Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+          ),
+          followRedirects: Schema.optional(Schema.Boolean),
+          header: Schema.optional(
+            Schema.Union([Schema.Struct({}), Schema.Null]),
+          ),
+          method: Schema.optional(Schema.Literals(["GET", "HEAD"])),
+          path: Schema.optional(Schema.String),
+          port: Schema.optional(Schema.Number),
+        }).pipe(
+          Schema.encodeKeys({
+            allowInsecure: "allow_insecure",
+            expectedBody: "expected_body",
+            expectedCodes: "expected_codes",
+            followRedirects: "follow_redirects",
+            header: "header",
+            method: "method",
+            path: "path",
+            port: "port",
+          }),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    interval: Schema.optional(Schema.Number),
+    retries: Schema.optional(Schema.Number),
+    suspended: Schema.optional(Schema.Boolean),
+    tcpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          method: Schema.optional(Schema.Literal("connection_established")),
+          port: Schema.optional(Schema.Number),
+        }),
+        Schema.Null,
+      ]),
+    ),
+    timeout: Schema.optional(Schema.Number),
+    type: Schema.optional(Schema.String),
+  }).pipe(
+    Schema.encodeKeys({
+      address: "address",
+      name: "name",
+      checkRegions: "check_regions",
+      consecutiveFails: "consecutive_fails",
+      consecutiveSuccesses: "consecutive_successes",
+      description: "description",
+      httpConfig: "http_config",
+      interval: "interval",
+      retries: "retries",
+      suspended: "suspended",
+      tcpConfig: "tcp_config",
+      timeout: "timeout",
+      type: "type",
+    }),
+    T.Http({ method: "POST", path: "/zones/{zone_id}/healthchecks" }),
+  ) as unknown as Schema.Schema<CreateHealthcheckRequest>;
+
+export interface CreateHealthcheckResponse {
+  /** Identifier */
+  id?: string | null;
+  /** The hostname or IP address of the origin server to run health checks on. */
+  address?: string | null;
+  /** A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
+  checkRegions?:
+    | (
+        | "WNAM"
+        | "ENAM"
+        | "WEU"
+        | "EEU"
+        | "NSAM"
+        | "SSAM"
+        | "OC"
+        | "ME"
+        | "NAF"
+        | "SAF"
+        | "IN"
+        | "SEAS"
+        | "NEAS"
+        | "ALL_REGIONS"
+      )[]
+    | null;
+  /** The number of consecutive fails required from a health check before changing the health to unhealthy. */
+  consecutiveFails?: number | null;
+  /** The number of consecutive successes required from a health check before changing the health to healthy. */
+  consecutiveSuccesses?: number | null;
+  createdOn?: string | null;
+  /** A human-readable description of the health check. */
+  description?: string | null;
+  /** The current failure reason if status is unhealthy. */
+  failureReason?: string | null;
+  /** Parameters specific to an HTTP or HTTPS health check. */
+  httpConfig?: {
+    allowInsecure?: boolean | null;
+    expectedBody?: string | null;
+    expectedCodes?: string[] | null;
+    followRedirects?: boolean | null;
+    header?: Record<string, unknown> | null;
+    method?: "GET" | "HEAD" | null;
+    path?: string | null;
+    port?: number | null;
+  } | null;
+  /** The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locations. */
+  interval?: number | null;
+  modifiedOn?: string | null;
+  /** A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
+  name?: string | null;
+  /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+  retries?: number | null;
+  /** The current status of the origin server according to the health check. */
+  status?: "unknown" | "healthy" | "unhealthy" | "suspended" | null;
+  /** If suspended, no health checks are sent to the origin. */
+  suspended?: boolean | null;
+  /** Parameters specific to TCP health check. */
+  tcpConfig?: {
+    method?: "connection_established" | null;
+    port?: number | null;
+  } | null;
+  /** The timeout (in seconds) before marking the health check as failed. */
+  timeout?: number | null;
+  /** The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
+  type?: string | null;
+}
+
+export const CreateHealthcheckResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    address: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    checkRegions: Schema.optional(
+      Schema.Union([
+        Schema.Array(
+          Schema.Literals([
+            "WNAM",
+            "ENAM",
+            "WEU",
+            "EEU",
+            "NSAM",
+            "SSAM",
+            "OC",
+            "ME",
+            "NAF",
+            "SAF",
+            "IN",
+            "SEAS",
+            "NEAS",
+            "ALL_REGIONS",
+          ]),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    consecutiveFails: Schema.optional(
+      Schema.Union([Schema.Number, Schema.Null]),
+    ),
+    consecutiveSuccesses: Schema.optional(
+      Schema.Union([Schema.Number, Schema.Null]),
+    ),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    failureReason: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    httpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          allowInsecure: Schema.optional(
+            Schema.Union([Schema.Boolean, Schema.Null]),
+          ),
+          expectedBody: Schema.optional(
+            Schema.Union([Schema.String, Schema.Null]),
+          ),
+          expectedCodes: Schema.optional(
+            Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+          ),
+          followRedirects: Schema.optional(
+            Schema.Union([Schema.Boolean, Schema.Null]),
+          ),
+          header: Schema.optional(
+            Schema.Union([Schema.Struct({}), Schema.Null]),
+          ),
+          method: Schema.optional(
+            Schema.Union([Schema.Literals(["GET", "HEAD"]), Schema.Null]),
+          ),
+          path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+          port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }).pipe(
+          Schema.encodeKeys({
+            allowInsecure: "allow_insecure",
+            expectedBody: "expected_body",
+            expectedCodes: "expected_codes",
+            followRedirects: "follow_redirects",
+            header: "header",
+            method: "method",
+            path: "path",
+            port: "port",
+          }),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    interval: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    retries: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    status: Schema.optional(
+      Schema.Union([
+        Schema.Literals(["unknown", "healthy", "unhealthy", "suspended"]),
+        Schema.Null,
+      ]),
+    ),
+    suspended: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    tcpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          method: Schema.optional(
+            Schema.Union([
+              Schema.Literal("connection_established"),
+              Schema.Null,
+            ]),
+          ),
+          port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }),
+        Schema.Null,
+      ]),
+    ),
+    timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    type: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  })
+    .pipe(
+      Schema.encodeKeys({
+        id: "id",
+        address: "address",
+        checkRegions: "check_regions",
+        consecutiveFails: "consecutive_fails",
+        consecutiveSuccesses: "consecutive_successes",
+        createdOn: "created_on",
+        description: "description",
+        failureReason: "failure_reason",
+        httpConfig: "http_config",
+        interval: "interval",
+        modifiedOn: "modified_on",
+        name: "name",
+        retries: "retries",
+        status: "status",
+        suspended: "suspended",
+        tcpConfig: "tcp_config",
+        timeout: "timeout",
+        type: "type",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<CreateHealthcheckResponse>;
+
+export type CreateHealthcheckError = DefaultErrors;
+
+export const createHealthcheck: API.OperationMethod<
+  CreateHealthcheckRequest,
+  CreateHealthcheckResponse,
+  CreateHealthcheckError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: CreateHealthcheckRequest,
+  output: CreateHealthcheckResponse,
+  errors: [],
+}));
+
+export interface UpdateHealthcheckRequest {
+  healthcheckId: string;
+  /** Path param: Identifier */
+  zoneId: string;
+  /** Body param: The hostname or IP address of the origin server to run health checks on. */
+  address: string;
+  /** Body param: A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
+  name: string;
+  /** Body param: A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
+  checkRegions?:
+    | (
+        | "WNAM"
+        | "ENAM"
+        | "WEU"
+        | "EEU"
+        | "NSAM"
+        | "SSAM"
+        | "OC"
+        | "ME"
+        | "NAF"
+        | "SAF"
+        | "IN"
+        | "SEAS"
+        | "NEAS"
+        | "ALL_REGIONS"
+      )[]
+    | null;
+  /** Body param: The number of consecutive fails required from a health check before changing the health to unhealthy. */
+  consecutiveFails?: number;
+  /** Body param: The number of consecutive successes required from a health check before changing the health to healthy. */
+  consecutiveSuccesses?: number;
+  /** Body param: A human-readable description of the health check. */
+  description?: string;
+  /** Body param: Parameters specific to an HTTP or HTTPS health check. */
+  httpConfig?: {
+    allowInsecure?: boolean;
+    expectedBody?: string;
+    expectedCodes?: string[] | null;
+    followRedirects?: boolean;
+    header?: Record<string, unknown> | null;
+    method?: "GET" | "HEAD";
+    path?: string;
+    port?: number;
+  } | null;
+  /** Body param: The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locati */
+  interval?: number;
+  /** Body param: The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+  retries?: number;
+  /** Body param: If suspended, no health checks are sent to the origin. */
+  suspended?: boolean;
+  /** Body param: Parameters specific to TCP health check. */
+  tcpConfig?: { method?: "connection_established"; port?: number } | null;
+  /** Body param: The timeout (in seconds) before marking the health check as failed. */
+  timeout?: number;
+  /** Body param: The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
+  type?: string;
+}
+
+export const UpdateHealthcheckRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    healthcheckId: Schema.String.pipe(T.HttpPath("healthcheckId")),
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    address: Schema.String,
+    name: Schema.String,
+    checkRegions: Schema.optional(
+      Schema.Union([
+        Schema.Array(
+          Schema.Literals([
+            "WNAM",
+            "ENAM",
+            "WEU",
+            "EEU",
+            "NSAM",
+            "SSAM",
+            "OC",
+            "ME",
+            "NAF",
+            "SAF",
+            "IN",
+            "SEAS",
+            "NEAS",
+            "ALL_REGIONS",
+          ]),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    consecutiveFails: Schema.optional(Schema.Number),
+    consecutiveSuccesses: Schema.optional(Schema.Number),
+    description: Schema.optional(Schema.String),
+    httpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          allowInsecure: Schema.optional(Schema.Boolean),
+          expectedBody: Schema.optional(Schema.String),
+          expectedCodes: Schema.optional(
+            Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+          ),
+          followRedirects: Schema.optional(Schema.Boolean),
+          header: Schema.optional(
+            Schema.Union([Schema.Struct({}), Schema.Null]),
+          ),
+          method: Schema.optional(Schema.Literals(["GET", "HEAD"])),
+          path: Schema.optional(Schema.String),
+          port: Schema.optional(Schema.Number),
+        }).pipe(
+          Schema.encodeKeys({
+            allowInsecure: "allow_insecure",
+            expectedBody: "expected_body",
+            expectedCodes: "expected_codes",
+            followRedirects: "follow_redirects",
+            header: "header",
+            method: "method",
+            path: "path",
+            port: "port",
+          }),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    interval: Schema.optional(Schema.Number),
+    retries: Schema.optional(Schema.Number),
+    suspended: Schema.optional(Schema.Boolean),
+    tcpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          method: Schema.optional(Schema.Literal("connection_established")),
+          port: Schema.optional(Schema.Number),
+        }),
+        Schema.Null,
+      ]),
+    ),
+    timeout: Schema.optional(Schema.Number),
+    type: Schema.optional(Schema.String),
+  }).pipe(
+    Schema.encodeKeys({
+      address: "address",
+      name: "name",
+      checkRegions: "check_regions",
+      consecutiveFails: "consecutive_fails",
+      consecutiveSuccesses: "consecutive_successes",
+      description: "description",
+      httpConfig: "http_config",
+      interval: "interval",
+      retries: "retries",
+      suspended: "suspended",
+      tcpConfig: "tcp_config",
+      timeout: "timeout",
+      type: "type",
+    }),
+    T.Http({
+      method: "PUT",
+      path: "/zones/{zone_id}/healthchecks/{healthcheckId}",
+    }),
+  ) as unknown as Schema.Schema<UpdateHealthcheckRequest>;
+
+export interface UpdateHealthcheckResponse {
+  /** Identifier */
+  id?: string | null;
+  /** The hostname or IP address of the origin server to run health checks on. */
+  address?: string | null;
+  /** A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
+  checkRegions?:
+    | (
+        | "WNAM"
+        | "ENAM"
+        | "WEU"
+        | "EEU"
+        | "NSAM"
+        | "SSAM"
+        | "OC"
+        | "ME"
+        | "NAF"
+        | "SAF"
+        | "IN"
+        | "SEAS"
+        | "NEAS"
+        | "ALL_REGIONS"
+      )[]
+    | null;
+  /** The number of consecutive fails required from a health check before changing the health to unhealthy. */
+  consecutiveFails?: number | null;
+  /** The number of consecutive successes required from a health check before changing the health to healthy. */
+  consecutiveSuccesses?: number | null;
+  createdOn?: string | null;
+  /** A human-readable description of the health check. */
+  description?: string | null;
+  /** The current failure reason if status is unhealthy. */
+  failureReason?: string | null;
+  /** Parameters specific to an HTTP or HTTPS health check. */
+  httpConfig?: {
+    allowInsecure?: boolean | null;
+    expectedBody?: string | null;
+    expectedCodes?: string[] | null;
+    followRedirects?: boolean | null;
+    header?: Record<string, unknown> | null;
+    method?: "GET" | "HEAD" | null;
+    path?: string | null;
+    port?: number | null;
+  } | null;
+  /** The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locations. */
+  interval?: number | null;
+  modifiedOn?: string | null;
+  /** A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
+  name?: string | null;
+  /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+  retries?: number | null;
+  /** The current status of the origin server according to the health check. */
+  status?: "unknown" | "healthy" | "unhealthy" | "suspended" | null;
+  /** If suspended, no health checks are sent to the origin. */
+  suspended?: boolean | null;
+  /** Parameters specific to TCP health check. */
+  tcpConfig?: {
+    method?: "connection_established" | null;
+    port?: number | null;
+  } | null;
+  /** The timeout (in seconds) before marking the health check as failed. */
+  timeout?: number | null;
+  /** The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
+  type?: string | null;
+}
+
+export const UpdateHealthcheckResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    address: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    checkRegions: Schema.optional(
+      Schema.Union([
+        Schema.Array(
+          Schema.Literals([
+            "WNAM",
+            "ENAM",
+            "WEU",
+            "EEU",
+            "NSAM",
+            "SSAM",
+            "OC",
+            "ME",
+            "NAF",
+            "SAF",
+            "IN",
+            "SEAS",
+            "NEAS",
+            "ALL_REGIONS",
+          ]),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    consecutiveFails: Schema.optional(
+      Schema.Union([Schema.Number, Schema.Null]),
+    ),
+    consecutiveSuccesses: Schema.optional(
+      Schema.Union([Schema.Number, Schema.Null]),
+    ),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    failureReason: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    httpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          allowInsecure: Schema.optional(
+            Schema.Union([Schema.Boolean, Schema.Null]),
+          ),
+          expectedBody: Schema.optional(
+            Schema.Union([Schema.String, Schema.Null]),
+          ),
+          expectedCodes: Schema.optional(
+            Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+          ),
+          followRedirects: Schema.optional(
+            Schema.Union([Schema.Boolean, Schema.Null]),
+          ),
+          header: Schema.optional(
+            Schema.Union([Schema.Struct({}), Schema.Null]),
+          ),
+          method: Schema.optional(
+            Schema.Union([Schema.Literals(["GET", "HEAD"]), Schema.Null]),
+          ),
+          path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+          port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }).pipe(
+          Schema.encodeKeys({
+            allowInsecure: "allow_insecure",
+            expectedBody: "expected_body",
+            expectedCodes: "expected_codes",
+            followRedirects: "follow_redirects",
+            header: "header",
+            method: "method",
+            path: "path",
+            port: "port",
+          }),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    interval: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    retries: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    status: Schema.optional(
+      Schema.Union([
+        Schema.Literals(["unknown", "healthy", "unhealthy", "suspended"]),
+        Schema.Null,
+      ]),
+    ),
+    suspended: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    tcpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          method: Schema.optional(
+            Schema.Union([
+              Schema.Literal("connection_established"),
+              Schema.Null,
+            ]),
+          ),
+          port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }),
+        Schema.Null,
+      ]),
+    ),
+    timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    type: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  })
+    .pipe(
+      Schema.encodeKeys({
+        id: "id",
+        address: "address",
+        checkRegions: "check_regions",
+        consecutiveFails: "consecutive_fails",
+        consecutiveSuccesses: "consecutive_successes",
+        createdOn: "created_on",
+        description: "description",
+        failureReason: "failure_reason",
+        httpConfig: "http_config",
+        interval: "interval",
+        modifiedOn: "modified_on",
+        name: "name",
+        retries: "retries",
+        status: "status",
+        suspended: "suspended",
+        tcpConfig: "tcp_config",
+        timeout: "timeout",
+        type: "type",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<UpdateHealthcheckResponse>;
+
+export type UpdateHealthcheckError = DefaultErrors;
+
+export const updateHealthcheck: API.OperationMethod<
+  UpdateHealthcheckRequest,
+  UpdateHealthcheckResponse,
+  UpdateHealthcheckError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: UpdateHealthcheckRequest,
+  output: UpdateHealthcheckResponse,
+  errors: [],
+}));
+
+export interface PatchHealthcheckRequest {
+  healthcheckId: string;
+  /** Path param: Identifier */
+  zoneId: string;
+  /** Body param: The hostname or IP address of the origin server to run health checks on. */
+  address: string;
+  /** Body param: A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
+  name: string;
+  /** Body param: A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
+  checkRegions?:
+    | (
+        | "WNAM"
+        | "ENAM"
+        | "WEU"
+        | "EEU"
+        | "NSAM"
+        | "SSAM"
+        | "OC"
+        | "ME"
+        | "NAF"
+        | "SAF"
+        | "IN"
+        | "SEAS"
+        | "NEAS"
+        | "ALL_REGIONS"
+      )[]
+    | null;
+  /** Body param: The number of consecutive fails required from a health check before changing the health to unhealthy. */
+  consecutiveFails?: number;
+  /** Body param: The number of consecutive successes required from a health check before changing the health to healthy. */
+  consecutiveSuccesses?: number;
+  /** Body param: A human-readable description of the health check. */
+  description?: string;
+  /** Body param: Parameters specific to an HTTP or HTTPS health check. */
+  httpConfig?: {
+    allowInsecure?: boolean;
+    expectedBody?: string;
+    expectedCodes?: string[] | null;
+    followRedirects?: boolean;
+    header?: Record<string, unknown> | null;
+    method?: "GET" | "HEAD";
+    path?: string;
+    port?: number;
+  } | null;
+  /** Body param: The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locati */
+  interval?: number;
+  /** Body param: The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+  retries?: number;
+  /** Body param: If suspended, no health checks are sent to the origin. */
+  suspended?: boolean;
+  /** Body param: Parameters specific to TCP health check. */
+  tcpConfig?: { method?: "connection_established"; port?: number } | null;
+  /** Body param: The timeout (in seconds) before marking the health check as failed. */
+  timeout?: number;
+  /** Body param: The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
+  type?: string;
+}
+
+export const PatchHealthcheckRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    healthcheckId: Schema.String.pipe(T.HttpPath("healthcheckId")),
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    address: Schema.String,
+    name: Schema.String,
+    checkRegions: Schema.optional(
+      Schema.Union([
+        Schema.Array(
+          Schema.Literals([
+            "WNAM",
+            "ENAM",
+            "WEU",
+            "EEU",
+            "NSAM",
+            "SSAM",
+            "OC",
+            "ME",
+            "NAF",
+            "SAF",
+            "IN",
+            "SEAS",
+            "NEAS",
+            "ALL_REGIONS",
+          ]),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    consecutiveFails: Schema.optional(Schema.Number),
+    consecutiveSuccesses: Schema.optional(Schema.Number),
+    description: Schema.optional(Schema.String),
+    httpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          allowInsecure: Schema.optional(Schema.Boolean),
+          expectedBody: Schema.optional(Schema.String),
+          expectedCodes: Schema.optional(
+            Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+          ),
+          followRedirects: Schema.optional(Schema.Boolean),
+          header: Schema.optional(
+            Schema.Union([Schema.Struct({}), Schema.Null]),
+          ),
+          method: Schema.optional(Schema.Literals(["GET", "HEAD"])),
+          path: Schema.optional(Schema.String),
+          port: Schema.optional(Schema.Number),
+        }).pipe(
+          Schema.encodeKeys({
+            allowInsecure: "allow_insecure",
+            expectedBody: "expected_body",
+            expectedCodes: "expected_codes",
+            followRedirects: "follow_redirects",
+            header: "header",
+            method: "method",
+            path: "path",
+            port: "port",
+          }),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    interval: Schema.optional(Schema.Number),
+    retries: Schema.optional(Schema.Number),
+    suspended: Schema.optional(Schema.Boolean),
+    tcpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          method: Schema.optional(Schema.Literal("connection_established")),
+          port: Schema.optional(Schema.Number),
+        }),
+        Schema.Null,
+      ]),
+    ),
+    timeout: Schema.optional(Schema.Number),
+    type: Schema.optional(Schema.String),
+  }).pipe(
+    Schema.encodeKeys({
+      address: "address",
+      name: "name",
+      checkRegions: "check_regions",
+      consecutiveFails: "consecutive_fails",
+      consecutiveSuccesses: "consecutive_successes",
+      description: "description",
+      httpConfig: "http_config",
+      interval: "interval",
+      retries: "retries",
+      suspended: "suspended",
+      tcpConfig: "tcp_config",
+      timeout: "timeout",
+      type: "type",
+    }),
+    T.Http({
+      method: "PATCH",
+      path: "/zones/{zone_id}/healthchecks/{healthcheckId}",
+    }),
+  ) as unknown as Schema.Schema<PatchHealthcheckRequest>;
+
+export interface PatchHealthcheckResponse {
+  /** Identifier */
+  id?: string | null;
+  /** The hostname or IP address of the origin server to run health checks on. */
+  address?: string | null;
+  /** A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
+  checkRegions?:
+    | (
+        | "WNAM"
+        | "ENAM"
+        | "WEU"
+        | "EEU"
+        | "NSAM"
+        | "SSAM"
+        | "OC"
+        | "ME"
+        | "NAF"
+        | "SAF"
+        | "IN"
+        | "SEAS"
+        | "NEAS"
+        | "ALL_REGIONS"
+      )[]
+    | null;
+  /** The number of consecutive fails required from a health check before changing the health to unhealthy. */
+  consecutiveFails?: number | null;
+  /** The number of consecutive successes required from a health check before changing the health to healthy. */
+  consecutiveSuccesses?: number | null;
+  createdOn?: string | null;
+  /** A human-readable description of the health check. */
+  description?: string | null;
+  /** The current failure reason if status is unhealthy. */
+  failureReason?: string | null;
+  /** Parameters specific to an HTTP or HTTPS health check. */
+  httpConfig?: {
+    allowInsecure?: boolean | null;
+    expectedBody?: string | null;
+    expectedCodes?: string[] | null;
+    followRedirects?: boolean | null;
+    header?: Record<string, unknown> | null;
+    method?: "GET" | "HEAD" | null;
+    path?: string | null;
+    port?: number | null;
+  } | null;
+  /** The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locations. */
+  interval?: number | null;
+  modifiedOn?: string | null;
+  /** A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
+  name?: string | null;
+  /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+  retries?: number | null;
+  /** The current status of the origin server according to the health check. */
+  status?: "unknown" | "healthy" | "unhealthy" | "suspended" | null;
+  /** If suspended, no health checks are sent to the origin. */
+  suspended?: boolean | null;
+  /** Parameters specific to TCP health check. */
+  tcpConfig?: {
+    method?: "connection_established" | null;
+    port?: number | null;
+  } | null;
+  /** The timeout (in seconds) before marking the health check as failed. */
+  timeout?: number | null;
+  /** The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
+  type?: string | null;
+}
+
+export const PatchHealthcheckResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    address: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    checkRegions: Schema.optional(
+      Schema.Union([
+        Schema.Array(
+          Schema.Literals([
+            "WNAM",
+            "ENAM",
+            "WEU",
+            "EEU",
+            "NSAM",
+            "SSAM",
+            "OC",
+            "ME",
+            "NAF",
+            "SAF",
+            "IN",
+            "SEAS",
+            "NEAS",
+            "ALL_REGIONS",
+          ]),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    consecutiveFails: Schema.optional(
+      Schema.Union([Schema.Number, Schema.Null]),
+    ),
+    consecutiveSuccesses: Schema.optional(
+      Schema.Union([Schema.Number, Schema.Null]),
+    ),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    failureReason: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    httpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          allowInsecure: Schema.optional(
+            Schema.Union([Schema.Boolean, Schema.Null]),
+          ),
+          expectedBody: Schema.optional(
+            Schema.Union([Schema.String, Schema.Null]),
+          ),
+          expectedCodes: Schema.optional(
+            Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+          ),
+          followRedirects: Schema.optional(
+            Schema.Union([Schema.Boolean, Schema.Null]),
+          ),
+          header: Schema.optional(
+            Schema.Union([Schema.Struct({}), Schema.Null]),
+          ),
+          method: Schema.optional(
+            Schema.Union([Schema.Literals(["GET", "HEAD"]), Schema.Null]),
+          ),
+          path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+          port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }).pipe(
+          Schema.encodeKeys({
+            allowInsecure: "allow_insecure",
+            expectedBody: "expected_body",
+            expectedCodes: "expected_codes",
+            followRedirects: "follow_redirects",
+            header: "header",
+            method: "method",
+            path: "path",
+            port: "port",
+          }),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    interval: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    retries: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    status: Schema.optional(
+      Schema.Union([
+        Schema.Literals(["unknown", "healthy", "unhealthy", "suspended"]),
+        Schema.Null,
+      ]),
+    ),
+    suspended: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    tcpConfig: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          method: Schema.optional(
+            Schema.Union([
+              Schema.Literal("connection_established"),
+              Schema.Null,
+            ]),
+          ),
+          port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }),
+        Schema.Null,
+      ]),
+    ),
+    timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    type: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  })
+    .pipe(
+      Schema.encodeKeys({
+        id: "id",
+        address: "address",
+        checkRegions: "check_regions",
+        consecutiveFails: "consecutive_fails",
+        consecutiveSuccesses: "consecutive_successes",
+        createdOn: "created_on",
+        description: "description",
+        failureReason: "failure_reason",
+        httpConfig: "http_config",
+        interval: "interval",
+        modifiedOn: "modified_on",
+        name: "name",
+        retries: "retries",
+        status: "status",
+        suspended: "suspended",
+        tcpConfig: "tcp_config",
+        timeout: "timeout",
+        type: "type",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<PatchHealthcheckResponse>;
+
+export type PatchHealthcheckError = DefaultErrors;
+
+export const patchHealthcheck: API.OperationMethod<
+  PatchHealthcheckRequest,
+  PatchHealthcheckResponse,
+  PatchHealthcheckError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: PatchHealthcheckRequest,
+  output: PatchHealthcheckResponse,
+  errors: [],
+}));
+
+export interface DeleteHealthcheckRequest {
+  healthcheckId: string;
+  /** Identifier */
+  zoneId: string;
+}
+
+export const DeleteHealthcheckRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    healthcheckId: Schema.String.pipe(T.HttpPath("healthcheckId")),
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      path: "/zones/{zone_id}/healthchecks/{healthcheckId}",
+    }),
+  ) as unknown as Schema.Schema<DeleteHealthcheckRequest>;
+
+export interface DeleteHealthcheckResponse {
+  /** Identifier */
+  id?: string | null;
+}
+
+export const DeleteHealthcheckResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  }).pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<DeleteHealthcheckResponse>;
+
+export type DeleteHealthcheckError = DefaultErrors;
+
+export const deleteHealthcheck: API.OperationMethod<
+  DeleteHealthcheckRequest,
+  DeleteHealthcheckResponse,
+  DeleteHealthcheckError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: DeleteHealthcheckRequest,
+  output: DeleteHealthcheckResponse,
+  errors: [],
+}));
+
+// =============================================================================
+// Preview
+// =============================================================================
+
+export interface GetPreviewRequest {
+  healthcheckId: string;
+  /** Identifier */
+  zoneId: string;
+}
+
+export const GetPreviewRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  healthcheckId: Schema.String.pipe(T.HttpPath("healthcheckId")),
+  zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(
+  T.Http({
+    method: "GET",
+    path: "/zones/{zone_id}/healthchecks/preview/{healthcheckId}",
+  }),
+) as unknown as Schema.Schema<GetPreviewRequest>;
+
+export type GetPreviewResponse = unknown;
+
+export const GetPreviewResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Schema<GetPreviewResponse>;
+
+export type GetPreviewError = DefaultErrors;
+
+export const getPreview: API.OperationMethod<
+  GetPreviewRequest,
+  GetPreviewResponse,
+  GetPreviewError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: GetPreviewRequest,
+  output: GetPreviewResponse,
+  errors: [],
+}));
+
+export interface CreatePreviewRequest {
+  /** Path param: Identifier */
+  zoneId: string;
+  /** Body param: The hostname or IP address of the origin server to run health checks on. */
+  address: string;
+  /** Body param: A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
+  name: string;
+  /** Body param: A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
+  checkRegions?:
+    | (
+        | "WNAM"
+        | "ENAM"
+        | "WEU"
+        | "EEU"
+        | "NSAM"
+        | "SSAM"
+        | "OC"
+        | "ME"
+        | "NAF"
+        | "SAF"
+        | "IN"
+        | "SEAS"
+        | "NEAS"
+        | "ALL_REGIONS"
+      )[]
+    | null;
+  /** Body param: The number of consecutive fails required from a health check before changing the health to unhealthy. */
+  consecutiveFails?: number;
+  /** Body param: The number of consecutive successes required from a health check before changing the health to healthy. */
+  consecutiveSuccesses?: number;
+  /** Body param: A human-readable description of the health check. */
+  description?: string;
+  /** Body param: Parameters specific to an HTTP or HTTPS health check. */
+  httpConfig?: unknown | null;
+  /** Body param: The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locati */
+  interval?: number;
+  /** Body param: The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
+  retries?: number;
+  /** Body param: If suspended, no health checks are sent to the origin. */
+  suspended?: boolean;
+  /** Body param: Parameters specific to TCP health check. */
+  tcpConfig?: unknown | null;
+  /** Body param: The timeout (in seconds) before marking the health check as failed. */
+  timeout?: number;
+  /** Body param: The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
+  type?: string;
+}
+
+export const CreatePreviewRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+  address: Schema.String,
+  name: Schema.String,
+  checkRegions: Schema.optional(
+    Schema.Union([
+      Schema.Array(
+        Schema.Literals([
+          "WNAM",
+          "ENAM",
+          "WEU",
+          "EEU",
+          "NSAM",
+          "SSAM",
+          "OC",
+          "ME",
+          "NAF",
+          "SAF",
+          "IN",
+          "SEAS",
+          "NEAS",
+          "ALL_REGIONS",
+        ]),
+      ),
+      Schema.Null,
+    ]),
+  ),
+  consecutiveFails: Schema.optional(Schema.Number),
+  consecutiveSuccesses: Schema.optional(Schema.Number),
+  description: Schema.optional(Schema.String),
+  httpConfig: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+  interval: Schema.optional(Schema.Number),
+  retries: Schema.optional(Schema.Number),
+  suspended: Schema.optional(Schema.Boolean),
+  tcpConfig: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+  timeout: Schema.optional(Schema.Number),
+  type: Schema.optional(Schema.String),
+}).pipe(
+  Schema.encodeKeys({
+    address: "address",
+    name: "name",
+    checkRegions: "check_regions",
+    consecutiveFails: "consecutive_fails",
+    consecutiveSuccesses: "consecutive_successes",
+    description: "description",
+    httpConfig: "http_config",
+    interval: "interval",
+    retries: "retries",
+    suspended: "suspended",
+    tcpConfig: "tcp_config",
+    timeout: "timeout",
+    type: "type",
+  }),
+  T.Http({ method: "POST", path: "/zones/{zone_id}/healthchecks/preview" }),
+) as unknown as Schema.Schema<CreatePreviewRequest>;
+
+export type CreatePreviewResponse = unknown;
+
+export const CreatePreviewResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Schema<CreatePreviewResponse>;
+
+export type CreatePreviewError = DefaultErrors;
+
+export const createPreview: API.OperationMethod<
+  CreatePreviewRequest,
+  CreatePreviewResponse,
+  CreatePreviewError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: CreatePreviewRequest,
+  output: CreatePreviewResponse,
+  errors: [],
+}));
+
+export interface DeletePreviewRequest {
+  healthcheckId: string;
+  /** Identifier */
+  zoneId: string;
+}
+
+export const DeletePreviewRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  healthcheckId: Schema.String.pipe(T.HttpPath("healthcheckId")),
+  zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(
+  T.Http({
+    method: "DELETE",
+    path: "/zones/{zone_id}/healthchecks/preview/{healthcheckId}",
+  }),
+) as unknown as Schema.Schema<DeletePreviewRequest>;
+
+export interface DeletePreviewResponse {
+  /** Identifier */
+  id?: string | null;
+}
+
+export const DeletePreviewResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}).pipe(
+  T.ResponsePath("result"),
+) as unknown as Schema.Schema<DeletePreviewResponse>;
+
+export type DeletePreviewError = DefaultErrors;
+
+export const deletePreview: API.OperationMethod<
+  DeletePreviewRequest,
+  DeletePreviewResponse,
+  DeletePreviewError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: DeletePreviewRequest,
+  output: DeletePreviewResponse,
+  errors: [],
+}));