@distilled.cloud/cloudflare 0.0.0-john

package/src/services/rate-limits.ts

@@ -0,0 +1,1252 @@
+/**
+ * Cloudflare RATE-LIMITS API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service rate-limits
+ */
+
+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";
+
+// =============================================================================
+// RateLimit
+// =============================================================================
+
+export interface GetRateLimitRequest {
+  rateLimitId: string;
+  /** Defines an identifier. */
+  zoneId: string;
+}
+
+export const GetRateLimitRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  rateLimitId: Schema.String.pipe(T.HttpPath("rateLimitId")),
+  zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(
+  T.Http({ method: "GET", path: "/zones/{zone_id}/rate_limits/{rateLimitId}" }),
+) as unknown as Schema.Schema<GetRateLimitRequest>;
+
+export interface GetRateLimitResponse {
+  /** The unique identifier of the rate limit. */
+  id?: string | null;
+  /** The action to perform when the threshold of matched traffic within the configured period is exceeded. */
+  action?: {
+    mode?:
+      | "simulate"
+      | "ban"
+      | "challenge"
+      | "js_challenge"
+      | "managed_challenge"
+      | null;
+    response?: { body?: string | null; contentType?: string | null } | null;
+    timeout?: number | null;
+  } | null;
+  /** Criteria specifying when the current rate limit should be bypassed. You can specify that the rate limit should not apply to one or more URLs. */
+  bypass?: { name?: "url" | null; value?: string | null }[] | null;
+  /** An informative summary of the rule. This value is sanitized and any tags will be removed. */
+  description?: string | null;
+  /** When true, indicates that the rate limit is currently disabled. */
+  disabled?: boolean | null;
+  /** Determines which traffic the rate limit counts towards the threshold. */
+  match?: {
+    headers?:
+      | {
+          name?: string | null;
+          op?: "eq" | "ne" | null;
+          value?: string | null;
+        }[]
+      | null;
+    request?: {
+      methods?:
+        | ("GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "_ALL_")[]
+        | null;
+      schemes?: string[] | null;
+      url?: string | null;
+    } | null;
+    response?: { originTraffic?: boolean | null } | null;
+  } | null;
+  /** The time in seconds (an integer value) to count matching traffic. If the count exceeds the configured threshold within this period, Cloudflare will perform the configured action. */
+  period?: number | null;
+  /** The threshold that will trigger the configured mitigation action. Configure this value along with the `period` property to establish a threshold per period. */
+  threshold?: number | null;
+}
+
+export const GetRateLimitResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  action: Schema.optional(
+    Schema.Union([
+      Schema.Struct({
+        mode: Schema.optional(
+          Schema.Union([
+            Schema.Literals([
+              "simulate",
+              "ban",
+              "challenge",
+              "js_challenge",
+              "managed_challenge",
+            ]),
+            Schema.Null,
+          ]),
+        ),
+        response: Schema.optional(
+          Schema.Union([
+            Schema.Struct({
+              body: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+              contentType: Schema.optional(
+                Schema.Union([Schema.String, Schema.Null]),
+              ),
+            }).pipe(
+              Schema.encodeKeys({ body: "body", contentType: "content_type" }),
+            ),
+            Schema.Null,
+          ]),
+        ),
+        timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+      }),
+      Schema.Null,
+    ]),
+  ),
+  bypass: Schema.optional(
+    Schema.Union([
+      Schema.Array(
+        Schema.Struct({
+          name: Schema.optional(
+            Schema.Union([Schema.Literal("url"), Schema.Null]),
+          ),
+          value: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }),
+      ),
+      Schema.Null,
+    ]),
+  ),
+  description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+  match: Schema.optional(
+    Schema.Union([
+      Schema.Struct({
+        headers: Schema.optional(
+          Schema.Union([
+            Schema.Array(
+              Schema.Struct({
+                name: Schema.optional(
+                  Schema.Union([Schema.String, Schema.Null]),
+                ),
+                op: Schema.optional(
+                  Schema.Union([Schema.Literals(["eq", "ne"]), Schema.Null]),
+                ),
+                value: Schema.optional(
+                  Schema.Union([Schema.String, Schema.Null]),
+                ),
+              }),
+            ),
+            Schema.Null,
+          ]),
+        ),
+        request: Schema.optional(
+          Schema.Union([
+            Schema.Struct({
+              methods: Schema.optional(
+                Schema.Union([
+                  Schema.Array(
+                    Schema.Literals([
+                      "GET",
+                      "POST",
+                      "PUT",
+                      "DELETE",
+                      "PATCH",
+                      "HEAD",
+                      "_ALL_",
+                    ]),
+                  ),
+                  Schema.Null,
+                ]),
+              ),
+              schemes: Schema.optional(
+                Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+              ),
+              url: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }),
+            Schema.Null,
+          ]),
+        ),
+        response: Schema.optional(
+          Schema.Union([
+            Schema.Struct({
+              originTraffic: Schema.optional(
+                Schema.Union([Schema.Boolean, Schema.Null]),
+              ),
+            }).pipe(Schema.encodeKeys({ originTraffic: "origin_traffic" })),
+            Schema.Null,
+          ]),
+        ),
+      }),
+      Schema.Null,
+    ]),
+  ),
+  period: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+  threshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+}).pipe(
+  T.ResponsePath("result"),
+) as unknown as Schema.Schema<GetRateLimitResponse>;
+
+export type GetRateLimitError = DefaultErrors;
+
+export const getRateLimit: API.OperationMethod<
+  GetRateLimitRequest,
+  GetRateLimitResponse,
+  GetRateLimitError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: GetRateLimitRequest,
+  output: GetRateLimitResponse,
+  errors: [],
+}));
+
+export interface ListRateLimitsRequest {
+  /** Path param: Defines an identifier. */
+  zoneId: string;
+}
+
+export const ListRateLimitsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(
+  T.Http({ method: "GET", path: "/zones/{zone_id}/rate_limits" }),
+) as unknown as Schema.Schema<ListRateLimitsRequest>;
+
+export interface ListRateLimitsResponse {
+  result: {
+    id?: string | null;
+    action?: {
+      mode?:
+        | "simulate"
+        | "ban"
+        | "challenge"
+        | "js_challenge"
+        | "managed_challenge"
+        | null;
+      response?: { body?: string | null; contentType?: string | null } | null;
+      timeout?: number | null;
+    } | null;
+    bypass?: { name?: "url" | null; value?: string | null }[] | null;
+    description?: string | null;
+    disabled?: boolean | null;
+    match?: {
+      headers?:
+        | {
+            name?: string | null;
+            op?: "eq" | "ne" | null;
+            value?: string | null;
+          }[]
+        | null;
+      request?: {
+        methods?:
+          | ("GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "_ALL_")[]
+          | null;
+        schemes?: string[] | null;
+        url?: string | null;
+      } | null;
+      response?: { originTraffic?: boolean | null } | null;
+    } | null;
+    period?: number | null;
+    threshold?: number | null;
+  }[];
+  resultInfo: {
+    count?: number | null;
+    page?: number | null;
+    perPage?: number | null;
+    totalCount?: number | null;
+  };
+}
+
+export const ListRateLimitsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    result: Schema.Array(
+      Schema.Struct({
+        id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        action: Schema.optional(
+          Schema.Union([
+            Schema.Struct({
+              mode: Schema.optional(
+                Schema.Union([
+                  Schema.Literals([
+                    "simulate",
+                    "ban",
+                    "challenge",
+                    "js_challenge",
+                    "managed_challenge",
+                  ]),
+                  Schema.Null,
+                ]),
+              ),
+              response: Schema.optional(
+                Schema.Union([
+                  Schema.Struct({
+                    body: Schema.optional(
+                      Schema.Union([Schema.String, Schema.Null]),
+                    ),
+                    contentType: Schema.optional(
+                      Schema.Union([Schema.String, Schema.Null]),
+                    ),
+                  }).pipe(
+                    Schema.encodeKeys({
+                      body: "body",
+                      contentType: "content_type",
+                    }),
+                  ),
+                  Schema.Null,
+                ]),
+              ),
+              timeout: Schema.optional(
+                Schema.Union([Schema.Number, Schema.Null]),
+              ),
+            }),
+            Schema.Null,
+          ]),
+        ),
+        bypass: Schema.optional(
+          Schema.Union([
+            Schema.Array(
+              Schema.Struct({
+                name: Schema.optional(
+                  Schema.Union([Schema.Literal("url"), Schema.Null]),
+                ),
+                value: Schema.optional(
+                  Schema.Union([Schema.String, Schema.Null]),
+                ),
+              }),
+            ),
+            Schema.Null,
+          ]),
+        ),
+        description: Schema.optional(
+          Schema.Union([Schema.String, Schema.Null]),
+        ),
+        disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        match: Schema.optional(
+          Schema.Union([
+            Schema.Struct({
+              headers: Schema.optional(
+                Schema.Union([
+                  Schema.Array(
+                    Schema.Struct({
+                      name: Schema.optional(
+                        Schema.Union([Schema.String, Schema.Null]),
+                      ),
+                      op: Schema.optional(
+                        Schema.Union([
+                          Schema.Literals(["eq", "ne"]),
+                          Schema.Null,
+                        ]),
+                      ),
+                      value: Schema.optional(
+                        Schema.Union([Schema.String, Schema.Null]),
+                      ),
+                    }),
+                  ),
+                  Schema.Null,
+                ]),
+              ),
+              request: Schema.optional(
+                Schema.Union([
+                  Schema.Struct({
+                    methods: Schema.optional(
+                      Schema.Union([
+                        Schema.Array(
+                          Schema.Literals([
+                            "GET",
+                            "POST",
+                            "PUT",
+                            "DELETE",
+                            "PATCH",
+                            "HEAD",
+                            "_ALL_",
+                          ]),
+                        ),
+                        Schema.Null,
+                      ]),
+                    ),
+                    schemes: Schema.optional(
+                      Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+                    ),
+                    url: Schema.optional(
+                      Schema.Union([Schema.String, Schema.Null]),
+                    ),
+                  }),
+                  Schema.Null,
+                ]),
+              ),
+              response: Schema.optional(
+                Schema.Union([
+                  Schema.Struct({
+                    originTraffic: Schema.optional(
+                      Schema.Union([Schema.Boolean, Schema.Null]),
+                    ),
+                  }).pipe(
+                    Schema.encodeKeys({ originTraffic: "origin_traffic" }),
+                  ),
+                  Schema.Null,
+                ]),
+              ),
+            }),
+            Schema.Null,
+          ]),
+        ),
+        period: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        threshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+      }),
+    ),
+    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<ListRateLimitsResponse>;
+
+export type ListRateLimitsError = DefaultErrors;
+
+export const listRateLimits: API.PaginatedOperationMethod<
+  ListRateLimitsRequest,
+  ListRateLimitsResponse,
+  ListRateLimitsError,
+  Credentials | HttpClient.HttpClient
+> & {
+  pages: (
+    input: ListRateLimitsRequest,
+  ) => stream.Stream<
+    ListRateLimitsResponse,
+    ListRateLimitsError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: ListRateLimitsRequest) => stream.Stream<
+    {
+      id?: string | null;
+      action?: {
+        mode?:
+          | "simulate"
+          | "ban"
+          | "challenge"
+          | "js_challenge"
+          | "managed_challenge"
+          | null;
+        response?: { body?: string | null; contentType?: string | null } | null;
+        timeout?: number | null;
+      } | null;
+      bypass?: { name?: "url" | null; value?: string | null }[] | null;
+      description?: string | null;
+      disabled?: boolean | null;
+      match?: {
+        headers?:
+          | {
+              name?: string | null;
+              op?: "eq" | "ne" | null;
+              value?: string | null;
+            }[]
+          | null;
+        request?: {
+          methods?:
+            | ("GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "_ALL_")[]
+            | null;
+          schemes?: string[] | null;
+          url?: string | null;
+        } | null;
+        response?: { originTraffic?: boolean | null } | null;
+      } | null;
+      period?: number | null;
+      threshold?: number | null;
+    },
+    ListRateLimitsError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
+  input: ListRateLimitsRequest,
+  output: ListRateLimitsResponse,
+  errors: [],
+  pagination: {
+    mode: "page",
+    inputToken: "page",
+    outputToken: "resultInfo.page",
+    items: "result",
+    pageSize: "perPage",
+  } as const,
+}));
+
+export interface CreateRateLimitRequest {
+  /** Path param: Defines an identifier. */
+  zoneId: string;
+  /** Body param: The action to perform when the threshold of matched traffic within the configured period is exceeded. */
+  action: {
+    mode?:
+      | "simulate"
+      | "ban"
+      | "challenge"
+      | "js_challenge"
+      | "managed_challenge";
+    response?: { body?: string; contentType?: string };
+    timeout?: number;
+  };
+  /** Body param: Determines which traffic the rate limit counts towards the threshold. */
+  match: {
+    headers?: { name?: string; op?: "eq" | "ne"; value?: string }[];
+    request?: {
+      methods?: (
+        | "GET"
+        | "POST"
+        | "PUT"
+        | "DELETE"
+        | "PATCH"
+        | "HEAD"
+        | "_ALL_"
+      )[];
+      schemes?: string[];
+      url?: string;
+    };
+    response?: { originTraffic?: boolean };
+  };
+  /** Body param: The time in seconds (an integer value) to count matching traffic. If the count exceeds the configured threshold within this period, Cloudflare will perform the configured action. */
+  period: number;
+  /** Body param: The threshold that will trigger the configured mitigation action. Configure this value along with the `period` property to establish a threshold per period. */
+  threshold: number;
+}
+
+export const CreateRateLimitRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    action: Schema.Struct({
+      mode: Schema.optional(
+        Schema.Literals([
+          "simulate",
+          "ban",
+          "challenge",
+          "js_challenge",
+          "managed_challenge",
+        ]),
+      ),
+      response: Schema.optional(
+        Schema.Struct({
+          body: Schema.optional(Schema.String),
+          contentType: Schema.optional(Schema.String),
+        }).pipe(
+          Schema.encodeKeys({ body: "body", contentType: "content_type" }),
+        ),
+      ),
+      timeout: Schema.optional(Schema.Number),
+    }),
+    match: Schema.Struct({
+      headers: Schema.optional(
+        Schema.Array(
+          Schema.Struct({
+            name: Schema.optional(Schema.String),
+            op: Schema.optional(Schema.Literals(["eq", "ne"])),
+            value: Schema.optional(Schema.String),
+          }),
+        ),
+      ),
+      request: Schema.optional(
+        Schema.Struct({
+          methods: Schema.optional(
+            Schema.Array(
+              Schema.Literals([
+                "GET",
+                "POST",
+                "PUT",
+                "DELETE",
+                "PATCH",
+                "HEAD",
+                "_ALL_",
+              ]),
+            ),
+          ),
+          schemes: Schema.optional(Schema.Array(Schema.String)),
+          url: Schema.optional(Schema.String),
+        }),
+      ),
+      response: Schema.optional(
+        Schema.Struct({
+          originTraffic: Schema.optional(Schema.Boolean),
+        }).pipe(Schema.encodeKeys({ originTraffic: "origin_traffic" })),
+      ),
+    }),
+    period: Schema.Number,
+    threshold: Schema.Number,
+  },
+).pipe(
+  T.Http({ method: "POST", path: "/zones/{zone_id}/rate_limits" }),
+) as unknown as Schema.Schema<CreateRateLimitRequest>;
+
+export interface CreateRateLimitResponse {
+  /** The unique identifier of the rate limit. */
+  id?: string | null;
+  /** The action to perform when the threshold of matched traffic within the configured period is exceeded. */
+  action?: {
+    mode?:
+      | "simulate"
+      | "ban"
+      | "challenge"
+      | "js_challenge"
+      | "managed_challenge"
+      | null;
+    response?: { body?: string | null; contentType?: string | null } | null;
+    timeout?: number | null;
+  } | null;
+  /** Criteria specifying when the current rate limit should be bypassed. You can specify that the rate limit should not apply to one or more URLs. */
+  bypass?: { name?: "url" | null; value?: string | null }[] | null;
+  /** An informative summary of the rule. This value is sanitized and any tags will be removed. */
+  description?: string | null;
+  /** When true, indicates that the rate limit is currently disabled. */
+  disabled?: boolean | null;
+  /** Determines which traffic the rate limit counts towards the threshold. */
+  match?: {
+    headers?:
+      | {
+          name?: string | null;
+          op?: "eq" | "ne" | null;
+          value?: string | null;
+        }[]
+      | null;
+    request?: {
+      methods?:
+        | ("GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "_ALL_")[]
+        | null;
+      schemes?: string[] | null;
+      url?: string | null;
+    } | null;
+    response?: { originTraffic?: boolean | null } | null;
+  } | null;
+  /** The time in seconds (an integer value) to count matching traffic. If the count exceeds the configured threshold within this period, Cloudflare will perform the configured action. */
+  period?: number | null;
+  /** The threshold that will trigger the configured mitigation action. Configure this value along with the `period` property to establish a threshold per period. */
+  threshold?: number | null;
+}
+
+export const CreateRateLimitResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    action: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          mode: Schema.optional(
+            Schema.Union([
+              Schema.Literals([
+                "simulate",
+                "ban",
+                "challenge",
+                "js_challenge",
+                "managed_challenge",
+              ]),
+              Schema.Null,
+            ]),
+          ),
+          response: Schema.optional(
+            Schema.Union([
+              Schema.Struct({
+                body: Schema.optional(
+                  Schema.Union([Schema.String, Schema.Null]),
+                ),
+                contentType: Schema.optional(
+                  Schema.Union([Schema.String, Schema.Null]),
+                ),
+              }).pipe(
+                Schema.encodeKeys({
+                  body: "body",
+                  contentType: "content_type",
+                }),
+              ),
+              Schema.Null,
+            ]),
+          ),
+          timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }),
+        Schema.Null,
+      ]),
+    ),
+    bypass: Schema.optional(
+      Schema.Union([
+        Schema.Array(
+          Schema.Struct({
+            name: Schema.optional(
+              Schema.Union([Schema.Literal("url"), Schema.Null]),
+            ),
+            value: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+          }),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    match: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          headers: Schema.optional(
+            Schema.Union([
+              Schema.Array(
+                Schema.Struct({
+                  name: Schema.optional(
+                    Schema.Union([Schema.String, Schema.Null]),
+                  ),
+                  op: Schema.optional(
+                    Schema.Union([Schema.Literals(["eq", "ne"]), Schema.Null]),
+                  ),
+                  value: Schema.optional(
+                    Schema.Union([Schema.String, Schema.Null]),
+                  ),
+                }),
+              ),
+              Schema.Null,
+            ]),
+          ),
+          request: Schema.optional(
+            Schema.Union([
+              Schema.Struct({
+                methods: Schema.optional(
+                  Schema.Union([
+                    Schema.Array(
+                      Schema.Literals([
+                        "GET",
+                        "POST",
+                        "PUT",
+                        "DELETE",
+                        "PATCH",
+                        "HEAD",
+                        "_ALL_",
+                      ]),
+                    ),
+                    Schema.Null,
+                  ]),
+                ),
+                schemes: Schema.optional(
+                  Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+                ),
+                url: Schema.optional(
+                  Schema.Union([Schema.String, Schema.Null]),
+                ),
+              }),
+              Schema.Null,
+            ]),
+          ),
+          response: Schema.optional(
+            Schema.Union([
+              Schema.Struct({
+                originTraffic: Schema.optional(
+                  Schema.Union([Schema.Boolean, Schema.Null]),
+                ),
+              }).pipe(Schema.encodeKeys({ originTraffic: "origin_traffic" })),
+              Schema.Null,
+            ]),
+          ),
+        }),
+        Schema.Null,
+      ]),
+    ),
+    period: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    threshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+  }).pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<CreateRateLimitResponse>;
+
+export type CreateRateLimitError = DefaultErrors;
+
+export const createRateLimit: API.OperationMethod<
+  CreateRateLimitRequest,
+  CreateRateLimitResponse,
+  CreateRateLimitError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: CreateRateLimitRequest,
+  output: CreateRateLimitResponse,
+  errors: [],
+}));
+
+export interface DeleteRateLimitRequest {
+  rateLimitId: string;
+  /** Defines an identifier. */
+  zoneId: string;
+}
+
+export const DeleteRateLimitRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    rateLimitId: Schema.String.pipe(T.HttpPath("rateLimitId")),
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+  },
+).pipe(
+  T.Http({
+    method: "DELETE",
+    path: "/zones/{zone_id}/rate_limits/{rateLimitId}",
+  }),
+) as unknown as Schema.Schema<DeleteRateLimitRequest>;
+
+export interface DeleteRateLimitResponse {
+  /** The unique identifier of the rate limit. */
+  id?: string | null;
+  /** The action to perform when the threshold of matched traffic within the configured period is exceeded. */
+  action?: {
+    mode?:
+      | "simulate"
+      | "ban"
+      | "challenge"
+      | "js_challenge"
+      | "managed_challenge"
+      | null;
+    response?: { body?: string | null; contentType?: string | null } | null;
+    timeout?: number | null;
+  } | null;
+  /** Criteria specifying when the current rate limit should be bypassed. You can specify that the rate limit should not apply to one or more URLs. */
+  bypass?: { name?: "url" | null; value?: string | null }[] | null;
+  /** An informative summary of the rule. This value is sanitized and any tags will be removed. */
+  description?: string | null;
+  /** When true, indicates that the rate limit is currently disabled. */
+  disabled?: boolean | null;
+  /** Determines which traffic the rate limit counts towards the threshold. */
+  match?: {
+    headers?:
+      | {
+          name?: string | null;
+          op?: "eq" | "ne" | null;
+          value?: string | null;
+        }[]
+      | null;
+    request?: {
+      methods?:
+        | ("GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "_ALL_")[]
+        | null;
+      schemes?: string[] | null;
+      url?: string | null;
+    } | null;
+    response?: { originTraffic?: boolean | null } | null;
+  } | null;
+  /** The time in seconds (an integer value) to count matching traffic. If the count exceeds the configured threshold within this period, Cloudflare will perform the configured action. */
+  period?: number | null;
+  /** The threshold that will trigger the configured mitigation action. Configure this value along with the `period` property to establish a threshold per period. */
+  threshold?: number | null;
+}
+
+export const DeleteRateLimitResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    action: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          mode: Schema.optional(
+            Schema.Union([
+              Schema.Literals([
+                "simulate",
+                "ban",
+                "challenge",
+                "js_challenge",
+                "managed_challenge",
+              ]),
+              Schema.Null,
+            ]),
+          ),
+          response: Schema.optional(
+            Schema.Union([
+              Schema.Struct({
+                body: Schema.optional(
+                  Schema.Union([Schema.String, Schema.Null]),
+                ),
+                contentType: Schema.optional(
+                  Schema.Union([Schema.String, Schema.Null]),
+                ),
+              }).pipe(
+                Schema.encodeKeys({
+                  body: "body",
+                  contentType: "content_type",
+                }),
+              ),
+              Schema.Null,
+            ]),
+          ),
+          timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }),
+        Schema.Null,
+      ]),
+    ),
+    bypass: Schema.optional(
+      Schema.Union([
+        Schema.Array(
+          Schema.Struct({
+            name: Schema.optional(
+              Schema.Union([Schema.Literal("url"), Schema.Null]),
+            ),
+            value: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+          }),
+        ),
+        Schema.Null,
+      ]),
+    ),
+    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    match: Schema.optional(
+      Schema.Union([
+        Schema.Struct({
+          headers: Schema.optional(
+            Schema.Union([
+              Schema.Array(
+                Schema.Struct({
+                  name: Schema.optional(
+                    Schema.Union([Schema.String, Schema.Null]),
+                  ),
+                  op: Schema.optional(
+                    Schema.Union([Schema.Literals(["eq", "ne"]), Schema.Null]),
+                  ),
+                  value: Schema.optional(
+                    Schema.Union([Schema.String, Schema.Null]),
+                  ),
+                }),
+              ),
+              Schema.Null,
+            ]),
+          ),
+          request: Schema.optional(
+            Schema.Union([
+              Schema.Struct({
+                methods: Schema.optional(
+                  Schema.Union([
+                    Schema.Array(
+                      Schema.Literals([
+                        "GET",
+                        "POST",
+                        "PUT",
+                        "DELETE",
+                        "PATCH",
+                        "HEAD",
+                        "_ALL_",
+                      ]),
+                    ),
+                    Schema.Null,
+                  ]),
+                ),
+                schemes: Schema.optional(
+                  Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+                ),
+                url: Schema.optional(
+                  Schema.Union([Schema.String, Schema.Null]),
+                ),
+              }),
+              Schema.Null,
+            ]),
+          ),
+          response: Schema.optional(
+            Schema.Union([
+              Schema.Struct({
+                originTraffic: Schema.optional(
+                  Schema.Union([Schema.Boolean, Schema.Null]),
+                ),
+              }).pipe(Schema.encodeKeys({ originTraffic: "origin_traffic" })),
+              Schema.Null,
+            ]),
+          ),
+        }),
+        Schema.Null,
+      ]),
+    ),
+    period: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    threshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+  }).pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<DeleteRateLimitResponse>;
+
+export type DeleteRateLimitError = DefaultErrors;
+
+export const deleteRateLimit: API.OperationMethod<
+  DeleteRateLimitRequest,
+  DeleteRateLimitResponse,
+  DeleteRateLimitError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: DeleteRateLimitRequest,
+  output: DeleteRateLimitResponse,
+  errors: [],
+}));
+
+export interface EditRateLimitRequest {
+  rateLimitId: string;
+  /** Path param: Defines an identifier. */
+  zoneId: string;
+  /** Body param: The action to perform when the threshold of matched traffic within the configured period is exceeded. */
+  action: {
+    mode?:
+      | "simulate"
+      | "ban"
+      | "challenge"
+      | "js_challenge"
+      | "managed_challenge";
+    response?: { body?: string; contentType?: string };
+    timeout?: number;
+  };
+  /** Body param: Determines which traffic the rate limit counts towards the threshold. */
+  match: {
+    headers?: { name?: string; op?: "eq" | "ne"; value?: string }[];
+    request?: {
+      methods?: (
+        | "GET"
+        | "POST"
+        | "PUT"
+        | "DELETE"
+        | "PATCH"
+        | "HEAD"
+        | "_ALL_"
+      )[];
+      schemes?: string[];
+      url?: string;
+    };
+    response?: { originTraffic?: boolean };
+  };
+  /** Body param: The time in seconds (an integer value) to count matching traffic. If the count exceeds the configured threshold within this period, Cloudflare will perform the configured action. */
+  period: number;
+  /** Body param: The threshold that will trigger the configured mitigation action. Configure this value along with the `period` property to establish a threshold per period. */
+  threshold: number;
+}
+
+export const EditRateLimitRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  rateLimitId: Schema.String.pipe(T.HttpPath("rateLimitId")),
+  zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+  action: Schema.Struct({
+    mode: Schema.optional(
+      Schema.Literals([
+        "simulate",
+        "ban",
+        "challenge",
+        "js_challenge",
+        "managed_challenge",
+      ]),
+    ),
+    response: Schema.optional(
+      Schema.Struct({
+        body: Schema.optional(Schema.String),
+        contentType: Schema.optional(Schema.String),
+      }).pipe(Schema.encodeKeys({ body: "body", contentType: "content_type" })),
+    ),
+    timeout: Schema.optional(Schema.Number),
+  }),
+  match: Schema.Struct({
+    headers: Schema.optional(
+      Schema.Array(
+        Schema.Struct({
+          name: Schema.optional(Schema.String),
+          op: Schema.optional(Schema.Literals(["eq", "ne"])),
+          value: Schema.optional(Schema.String),
+        }),
+      ),
+    ),
+    request: Schema.optional(
+      Schema.Struct({
+        methods: Schema.optional(
+          Schema.Array(
+            Schema.Literals([
+              "GET",
+              "POST",
+              "PUT",
+              "DELETE",
+              "PATCH",
+              "HEAD",
+              "_ALL_",
+            ]),
+          ),
+        ),
+        schemes: Schema.optional(Schema.Array(Schema.String)),
+        url: Schema.optional(Schema.String),
+      }),
+    ),
+    response: Schema.optional(
+      Schema.Struct({
+        originTraffic: Schema.optional(Schema.Boolean),
+      }).pipe(Schema.encodeKeys({ originTraffic: "origin_traffic" })),
+    ),
+  }),
+  period: Schema.Number,
+  threshold: Schema.Number,
+}).pipe(
+  T.Http({ method: "PUT", path: "/zones/{zone_id}/rate_limits/{rateLimitId}" }),
+) as unknown as Schema.Schema<EditRateLimitRequest>;
+
+export interface EditRateLimitResponse {
+  /** The unique identifier of the rate limit. */
+  id?: string | null;
+  /** The action to perform when the threshold of matched traffic within the configured period is exceeded. */
+  action?: {
+    mode?:
+      | "simulate"
+      | "ban"
+      | "challenge"
+      | "js_challenge"
+      | "managed_challenge"
+      | null;
+    response?: { body?: string | null; contentType?: string | null } | null;
+    timeout?: number | null;
+  } | null;
+  /** Criteria specifying when the current rate limit should be bypassed. You can specify that the rate limit should not apply to one or more URLs. */
+  bypass?: { name?: "url" | null; value?: string | null }[] | null;
+  /** An informative summary of the rule. This value is sanitized and any tags will be removed. */
+  description?: string | null;
+  /** When true, indicates that the rate limit is currently disabled. */
+  disabled?: boolean | null;
+  /** Determines which traffic the rate limit counts towards the threshold. */
+  match?: {
+    headers?:
+      | {
+          name?: string | null;
+          op?: "eq" | "ne" | null;
+          value?: string | null;
+        }[]
+      | null;
+    request?: {
+      methods?:
+        | ("GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "_ALL_")[]
+        | null;
+      schemes?: string[] | null;
+      url?: string | null;
+    } | null;
+    response?: { originTraffic?: boolean | null } | null;
+  } | null;
+  /** The time in seconds (an integer value) to count matching traffic. If the count exceeds the configured threshold within this period, Cloudflare will perform the configured action. */
+  period?: number | null;
+  /** The threshold that will trigger the configured mitigation action. Configure this value along with the `period` property to establish a threshold per period. */
+  threshold?: number | null;
+}
+
+export const EditRateLimitResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  action: Schema.optional(
+    Schema.Union([
+      Schema.Struct({
+        mode: Schema.optional(
+          Schema.Union([
+            Schema.Literals([
+              "simulate",
+              "ban",
+              "challenge",
+              "js_challenge",
+              "managed_challenge",
+            ]),
+            Schema.Null,
+          ]),
+        ),
+        response: Schema.optional(
+          Schema.Union([
+            Schema.Struct({
+              body: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+              contentType: Schema.optional(
+                Schema.Union([Schema.String, Schema.Null]),
+              ),
+            }).pipe(
+              Schema.encodeKeys({ body: "body", contentType: "content_type" }),
+            ),
+            Schema.Null,
+          ]),
+        ),
+        timeout: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+      }),
+      Schema.Null,
+    ]),
+  ),
+  bypass: Schema.optional(
+    Schema.Union([
+      Schema.Array(
+        Schema.Struct({
+          name: Schema.optional(
+            Schema.Union([Schema.Literal("url"), Schema.Null]),
+          ),
+          value: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }),
+      ),
+      Schema.Null,
+    ]),
+  ),
+  description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+  match: Schema.optional(
+    Schema.Union([
+      Schema.Struct({
+        headers: Schema.optional(
+          Schema.Union([
+            Schema.Array(
+              Schema.Struct({
+                name: Schema.optional(
+                  Schema.Union([Schema.String, Schema.Null]),
+                ),
+                op: Schema.optional(
+                  Schema.Union([Schema.Literals(["eq", "ne"]), Schema.Null]),
+                ),
+                value: Schema.optional(
+                  Schema.Union([Schema.String, Schema.Null]),
+                ),
+              }),
+            ),
+            Schema.Null,
+          ]),
+        ),
+        request: Schema.optional(
+          Schema.Union([
+            Schema.Struct({
+              methods: Schema.optional(
+                Schema.Union([
+                  Schema.Array(
+                    Schema.Literals([
+                      "GET",
+                      "POST",
+                      "PUT",
+                      "DELETE",
+                      "PATCH",
+                      "HEAD",
+                      "_ALL_",
+                    ]),
+                  ),
+                  Schema.Null,
+                ]),
+              ),
+              schemes: Schema.optional(
+                Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+              ),
+              url: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }),
+            Schema.Null,
+          ]),
+        ),
+        response: Schema.optional(
+          Schema.Union([
+            Schema.Struct({
+              originTraffic: Schema.optional(
+                Schema.Union([Schema.Boolean, Schema.Null]),
+              ),
+            }).pipe(Schema.encodeKeys({ originTraffic: "origin_traffic" })),
+            Schema.Null,
+          ]),
+        ),
+      }),
+      Schema.Null,
+    ]),
+  ),
+  period: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+  threshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+}).pipe(
+  T.ResponsePath("result"),
+) as unknown as Schema.Schema<EditRateLimitResponse>;
+
+export type EditRateLimitError = DefaultErrors;
+
+export const editRateLimit: API.OperationMethod<
+  EditRateLimitRequest,
+  EditRateLimitResponse,
+  EditRateLimitError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: EditRateLimitRequest,
+  output: EditRateLimitResponse,
+  errors: [],
+}));