@distilled.cloud/cloudflare 0.18.2 → 0.19.1

package/src/services/firewall.ts

@@ -16,18 +16,45 @@ import { type DefaultErrors } from "../errors.ts";
 // AccessRule
 // =============================================================================
 
-export interface GetAccessRuleRequest {
+const GetAccessRuleBaseFields = {
+  ruleId: Schema.String.pipe(T.HttpPath("ruleId")),
+} as const;
+
+interface GetAccessRuleBaseRequest {
   ruleId: string;
 }
 
-export const GetAccessRuleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
-  ruleId: Schema.String.pipe(T.HttpPath("ruleId")),
-}).pipe(
-  T.Http({
-    method: "GET",
-    path: "/{accountOrZone}/{accountOrZoneId}/firewall/access_rules/rules/{ruleId}",
-  }),
-) as unknown as Schema.Schema<GetAccessRuleRequest>;
+export interface GetAccessRuleForAccountRequest extends GetAccessRuleBaseRequest {
+  /** Path param: The Account ID to use for this endpoint. */
+  accountId: string;
+}
+
+export interface GetAccessRuleForZoneRequest extends GetAccessRuleBaseRequest {
+  /** Path param: The Zone ID to use for this endpoint. */
+  zoneId: string;
+}
+
+export const GetAccessRuleForAccountRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    ...GetAccessRuleBaseFields,
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/accounts/{account_id}/firewall/access_rules/rules/{ruleId}",
+    }),
+  ) as unknown as Schema.Schema<GetAccessRuleForAccountRequest>;
+
+export const GetAccessRuleForZoneRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    ...GetAccessRuleBaseFields,
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/zones/{zone_id}/firewall/access_rules/rules/{ruleId}",
+    }),
+  ) as unknown as Schema.Schema<GetAccessRuleForZoneRequest>;
 
 export interface GetAccessRuleResponse {
   /** The unique identifier of the IP Access rule. */
@@ -155,27 +182,63 @@ export const GetAccessRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
 
 export type GetAccessRuleError = DefaultErrors;
 
-export const getAccessRule: API.OperationMethod<
-  GetAccessRuleRequest,
+export const getAccessRuleForAccount: API.OperationMethod<
+  GetAccessRuleForAccountRequest,
   GetAccessRuleResponse,
   GetAccessRuleError,
   Credentials | HttpClient.HttpClient
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
-  input: GetAccessRuleRequest,
+  input: GetAccessRuleForAccountRequest,
   output: GetAccessRuleResponse,
   errors: [],
 }));
 
-export interface ListAccessRulesRequest {}
+export const getAccessRuleForZone: API.OperationMethod<
+  GetAccessRuleForZoneRequest,
+  GetAccessRuleResponse,
+  GetAccessRuleError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: GetAccessRuleForZoneRequest,
+  output: GetAccessRuleResponse,
+  errors: [],
+}));
 
-export const ListAccessRulesRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
-  {},
-).pipe(
-  T.Http({
-    method: "GET",
-    path: "/{accountOrZone}/{accountOrZoneId}/firewall/access_rules/rules",
-  }),
-) as unknown as Schema.Schema<ListAccessRulesRequest>;
+const ListAccessRulesBaseFields = {} as const;
+
+interface ListAccessRulesBaseRequest {}
+
+export interface ListAccessRulesForAccountRequest extends ListAccessRulesBaseRequest {
+  /** Path param: The Account ID to use for this endpoint. */
+  accountId: string;
+}
+
+export interface ListAccessRulesForZoneRequest extends ListAccessRulesBaseRequest {
+  /** Path param: The Zone ID to use for this endpoint. */
+  zoneId: string;
+}
+
+export const ListAccessRulesForAccountRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    ...ListAccessRulesBaseFields,
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/accounts/{account_id}/firewall/access_rules/rules",
+    }),
+  ) as unknown as Schema.Schema<ListAccessRulesForAccountRequest>;
+
+export const ListAccessRulesForZoneRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    ...ListAccessRulesBaseFields,
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/zones/{zone_id}/firewall/access_rules/rules",
+    }),
+  ) as unknown as Schema.Schema<ListAccessRulesForZoneRequest>;
 
 export interface ListAccessRulesResponse {
   result: {
@@ -208,12 +271,12 @@ export interface ListAccessRulesResponse {
       type?: "user" | "organization" | null;
     } | null;
   }[];
-  resultInfo: {
+  resultInfo?: {
     count?: number | null;
     page?: number | null;
     perPage?: number | null;
     totalCount?: number | null;
-  };
+  } | null;
 }
 
 export const ListAccessRulesResponse =
@@ -302,18 +365,25 @@ export const ListAccessRulesResponse =
         }),
       ),
     ),
-    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",
-      }),
+    resultInfo: Schema.optional(
+      Schema.Union([
+        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",
+          }),
+        ),
+        Schema.Null,
+      ]),
     ),
   }).pipe(
     Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
@@ -321,13 +391,13 @@ export const ListAccessRulesResponse =
 
 export type ListAccessRulesError = DefaultErrors;
 
-export const listAccessRules: API.PaginatedOperationMethod<
-  ListAccessRulesRequest,
+export const listAccessRulesForAccount: API.PaginatedOperationMethod<
+  ListAccessRulesForAccountRequest,
   ListAccessRulesResponse,
   ListAccessRulesError,
   Credentials | HttpClient.HttpClient
 > = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
-  input: ListAccessRulesRequest,
+  input: ListAccessRulesForAccountRequest,
   output: ListAccessRulesResponse,
   errors: [],
   pagination: {
@@ -339,11 +409,58 @@ export const listAccessRules: API.PaginatedOperationMethod<
   } as const,
 }));
 
-export interface CreateAccessRuleRequest {
-  /** Path param: The Account ID to use for this endpoint. Mutually exclusive with the Zone ID. */
-  accountId?: string;
-  /** Path param: The Zone ID to use for this endpoint. Mutually exclusive with the Account ID. */
-  zoneId?: string;
+export const listAccessRulesForZone: API.PaginatedOperationMethod<
+  ListAccessRulesForZoneRequest,
+  ListAccessRulesResponse,
+  ListAccessRulesError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
+  input: ListAccessRulesForZoneRequest,
+  output: ListAccessRulesResponse,
+  errors: [],
+  pagination: {
+    mode: "page",
+    inputToken: "page",
+    outputToken: "resultInfo.page",
+    items: "result",
+    pageSize: "perPage",
+  } as const,
+}));
+
+const CreateAccessRuleBaseFields = {
+  configuration: Schema.Union([
+    Schema.Struct({
+      target: Schema.optional(Schema.Literal("ip")),
+      value: Schema.optional(Schema.String),
+    }),
+    Schema.Struct({
+      target: Schema.optional(Schema.Literal("ip6")),
+      value: Schema.optional(Schema.String),
+    }),
+    Schema.Struct({
+      target: Schema.optional(Schema.Literal("ip_range")),
+      value: Schema.optional(Schema.String),
+    }),
+    Schema.Struct({
+      target: Schema.optional(Schema.Literal("asn")),
+      value: Schema.optional(Schema.String),
+    }),
+    Schema.Struct({
+      target: Schema.optional(Schema.Literal("country")),
+      value: Schema.optional(Schema.String),
+    }),
+  ]),
+  mode: Schema.Literals([
+    "block",
+    "challenge",
+    "whitelist",
+    "js_challenge",
+    "managed_challenge",
+  ]),
+  notes: Schema.optional(Schema.String),
+} as const;
+
+interface CreateAccessRuleBaseRequest {
   /** Body param: The rule configuration. */
   configuration:
     | { target?: "ip"; value?: string }
@@ -362,46 +479,37 @@ export interface CreateAccessRuleRequest {
   notes?: string;
 }
 
-export const CreateAccessRuleRequest =
+export interface CreateAccessRuleForAccountRequest extends CreateAccessRuleBaseRequest {
+  /** Path param: The Account ID to use for this endpoint. */
+  accountId: string;
+}
+
+export interface CreateAccessRuleForZoneRequest extends CreateAccessRuleBaseRequest {
+  /** Path param: The Zone ID to use for this endpoint. */
+  zoneId: string;
+}
+
+export const CreateAccessRuleForAccountRequest =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    ...CreateAccessRuleBaseFields,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/accounts/{account_id}/firewall/access_rules/rules",
+    }),
+  ) as unknown as Schema.Schema<CreateAccessRuleForAccountRequest>;
+
+export const CreateAccessRuleForZoneRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
-    configuration: Schema.Union([
-      Schema.Struct({
-        target: Schema.optional(Schema.Literal("ip")),
-        value: Schema.optional(Schema.String),
-      }),
-      Schema.Struct({
-        target: Schema.optional(Schema.Literal("ip6")),
-        value: Schema.optional(Schema.String),
-      }),
-      Schema.Struct({
-        target: Schema.optional(Schema.Literal("ip_range")),
-        value: Schema.optional(Schema.String),
-      }),
-      Schema.Struct({
-        target: Schema.optional(Schema.Literal("asn")),
-        value: Schema.optional(Schema.String),
-      }),
-      Schema.Struct({
-        target: Schema.optional(Schema.Literal("country")),
-        value: Schema.optional(Schema.String),
-      }),
-    ]),
-    mode: Schema.Literals([
-      "block",
-      "challenge",
-      "whitelist",
-      "js_challenge",
-      "managed_challenge",
-    ]),
-    notes: Schema.optional(Schema.String),
+    ...CreateAccessRuleBaseFields,
   }).pipe(
     T.Http({
       method: "POST",
-      path: "/{accountOrZone}/{accountOrZoneId}/firewall/access_rules/rules",
+      path: "/zones/{zone_id}/firewall/access_rules/rules",
     }),
-  ) as unknown as Schema.Schema<CreateAccessRuleRequest>;
+  ) as unknown as Schema.Schema<CreateAccessRuleForZoneRequest>;
 
 export interface CreateAccessRuleResponse {
   /** The unique identifier of the IP Access rule. */
@@ -530,23 +638,64 @@ export const CreateAccessRuleResponse =
 
 export type CreateAccessRuleError = DefaultErrors;
 
-export const createAccessRule: API.OperationMethod<
-  CreateAccessRuleRequest,
+export const createAccessRuleForAccount: API.OperationMethod<
+  CreateAccessRuleForAccountRequest,
   CreateAccessRuleResponse,
   CreateAccessRuleError,
   Credentials | HttpClient.HttpClient
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
-  input: CreateAccessRuleRequest,
+  input: CreateAccessRuleForAccountRequest,
   output: CreateAccessRuleResponse,
   errors: [],
 }));
 
-export interface PatchAccessRuleRequest {
+export const createAccessRuleForZone: API.OperationMethod<
+  CreateAccessRuleForZoneRequest,
+  CreateAccessRuleResponse,
+  CreateAccessRuleError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: CreateAccessRuleForZoneRequest,
+  output: CreateAccessRuleResponse,
+  errors: [],
+}));
+
+const PatchAccessRuleBaseFields = {
+  ruleId: Schema.String.pipe(T.HttpPath("ruleId")),
+  configuration: Schema.Union([
+    Schema.Struct({
+      target: Schema.optional(Schema.Literal("ip")),
+      value: Schema.optional(Schema.String),
+    }),
+    Schema.Struct({
+      target: Schema.optional(Schema.Literal("ip6")),
+      value: Schema.optional(Schema.String),
+    }),
+    Schema.Struct({
+      target: Schema.optional(Schema.Literal("ip_range")),
+      value: Schema.optional(Schema.String),
+    }),
+    Schema.Struct({
+      target: Schema.optional(Schema.Literal("asn")),
+      value: Schema.optional(Schema.String),
+    }),
+    Schema.Struct({
+      target: Schema.optional(Schema.Literal("country")),
+      value: Schema.optional(Schema.String),
+    }),
+  ]),
+  mode: Schema.Literals([
+    "block",
+    "challenge",
+    "whitelist",
+    "js_challenge",
+    "managed_challenge",
+  ]),
+  notes: Schema.optional(Schema.String),
+} as const;
+
+interface PatchAccessRuleBaseRequest {
   ruleId: string;
-  /** Path param: The Account ID to use for this endpoint. Mutually exclusive with the Zone ID. */
-  accountId?: string;
-  /** Path param: The Zone ID to use for this endpoint. Mutually exclusive with the Account ID. */
-  zoneId?: string;
   /** Body param: The rule configuration. */
   configuration:
     | { target?: "ip"; value?: string }
@@ -565,48 +714,37 @@ export interface PatchAccessRuleRequest {
   notes?: string;
 }
 
-export const PatchAccessRuleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
-  {
-    ruleId: Schema.String.pipe(T.HttpPath("ruleId")),
+export interface PatchAccessRuleForAccountRequest extends PatchAccessRuleBaseRequest {
+  /** Path param: The Account ID to use for this endpoint. */
+  accountId: string;
+}
+
+export interface PatchAccessRuleForZoneRequest extends PatchAccessRuleBaseRequest {
+  /** Path param: The Zone ID to use for this endpoint. */
+  zoneId: string;
+}
+
+export const PatchAccessRuleForAccountRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    ...PatchAccessRuleBaseFields,
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      path: "/accounts/{account_id}/firewall/access_rules/rules/{ruleId}",
+    }),
+  ) as unknown as Schema.Schema<PatchAccessRuleForAccountRequest>;
+
+export const PatchAccessRuleForZoneRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
-    configuration: Schema.Union([
-      Schema.Struct({
-        target: Schema.optional(Schema.Literal("ip")),
-        value: Schema.optional(Schema.String),
-      }),
-      Schema.Struct({
-        target: Schema.optional(Schema.Literal("ip6")),
-        value: Schema.optional(Schema.String),
-      }),
-      Schema.Struct({
-        target: Schema.optional(Schema.Literal("ip_range")),
-        value: Schema.optional(Schema.String),
-      }),
-      Schema.Struct({
-        target: Schema.optional(Schema.Literal("asn")),
-        value: Schema.optional(Schema.String),
-      }),
-      Schema.Struct({
-        target: Schema.optional(Schema.Literal("country")),
-        value: Schema.optional(Schema.String),
-      }),
-    ]),
-    mode: Schema.Literals([
-      "block",
-      "challenge",
-      "whitelist",
-      "js_challenge",
-      "managed_challenge",
-    ]),
-    notes: Schema.optional(Schema.String),
-  },
-).pipe(
-  T.Http({
-    method: "PATCH",
-    path: "/{accountOrZone}/{accountOrZoneId}/firewall/access_rules/rules/{ruleId}",
-  }),
-) as unknown as Schema.Schema<PatchAccessRuleRequest>;
+    ...PatchAccessRuleBaseFields,
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      path: "/zones/{zone_id}/firewall/access_rules/rules/{ruleId}",
+    }),
+  ) as unknown as Schema.Schema<PatchAccessRuleForZoneRequest>;
 
 export interface PatchAccessRuleResponse {
   /** The unique identifier of the IP Access rule. */
@@ -735,30 +873,67 @@ export const PatchAccessRuleResponse =
 
 export type PatchAccessRuleError = DefaultErrors;
 
-export const patchAccessRule: API.OperationMethod<
-  PatchAccessRuleRequest,
+export const patchAccessRuleForAccount: API.OperationMethod<
+  PatchAccessRuleForAccountRequest,
   PatchAccessRuleResponse,
   PatchAccessRuleError,
   Credentials | HttpClient.HttpClient
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
-  input: PatchAccessRuleRequest,
+  input: PatchAccessRuleForAccountRequest,
   output: PatchAccessRuleResponse,
   errors: [],
 }));
 
-export interface DeleteAccessRuleRequest {
+export const patchAccessRuleForZone: API.OperationMethod<
+  PatchAccessRuleForZoneRequest,
+  PatchAccessRuleResponse,
+  PatchAccessRuleError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: PatchAccessRuleForZoneRequest,
+  output: PatchAccessRuleResponse,
+  errors: [],
+}));
+
+const DeleteAccessRuleBaseFields = {
+  ruleId: Schema.String.pipe(T.HttpPath("ruleId")),
+} as const;
+
+interface DeleteAccessRuleBaseRequest {
   ruleId: string;
 }
 
-export const DeleteAccessRuleRequest =
+export interface DeleteAccessRuleForAccountRequest extends DeleteAccessRuleBaseRequest {
+  /** Path param: The Account ID to use for this endpoint. */
+  accountId: string;
+}
+
+export interface DeleteAccessRuleForZoneRequest extends DeleteAccessRuleBaseRequest {
+  /** Path param: The Zone ID to use for this endpoint. */
+  zoneId: string;
+}
+
+export const DeleteAccessRuleForAccountRequest =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
-    ruleId: Schema.String.pipe(T.HttpPath("ruleId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    ...DeleteAccessRuleBaseFields,
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      path: "/accounts/{account_id}/firewall/access_rules/rules/{ruleId}",
+    }),
+  ) as unknown as Schema.Schema<DeleteAccessRuleForAccountRequest>;
+
+export const DeleteAccessRuleForZoneRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    ...DeleteAccessRuleBaseFields,
   }).pipe(
     T.Http({
       method: "DELETE",
-      path: "/{accountOrZone}/{accountOrZoneId}/firewall/access_rules/rules/{ruleId}",
+      path: "/zones/{zone_id}/firewall/access_rules/rules/{ruleId}",
     }),
-  ) as unknown as Schema.Schema<DeleteAccessRuleRequest>;
+  ) as unknown as Schema.Schema<DeleteAccessRuleForZoneRequest>;
 
 export interface DeleteAccessRuleResponse {
   /** Defines an identifier. */
@@ -774,13 +949,24 @@ export const DeleteAccessRuleResponse =
 
 export type DeleteAccessRuleError = DefaultErrors;
 
-export const deleteAccessRule: API.OperationMethod<
-  DeleteAccessRuleRequest,
+export const deleteAccessRuleForAccount: API.OperationMethod<
+  DeleteAccessRuleForAccountRequest,
   DeleteAccessRuleResponse,
   DeleteAccessRuleError,
   Credentials | HttpClient.HttpClient
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
-  input: DeleteAccessRuleRequest,
+  input: DeleteAccessRuleForAccountRequest,
+  output: DeleteAccessRuleResponse,
+  errors: [],
+}));
+
+export const deleteAccessRuleForZone: API.OperationMethod<
+  DeleteAccessRuleForZoneRequest,
+  DeleteAccessRuleResponse,
+  DeleteAccessRuleError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: DeleteAccessRuleForZoneRequest,
   output: DeleteAccessRuleResponse,
   errors: [],
 }));
@@ -936,12 +1122,12 @@ export interface ListLockdownsResponse {
     paused: boolean;
     urls: string[];
   }[];
-  resultInfo: {
+  resultInfo?: {
     count?: number | null;
     page?: number | null;
     perPage?: number | null;
     totalCount?: number | null;
-  };
+  } | null;
 }
 
 export const ListLockdownsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
@@ -981,18 +1167,23 @@ export const ListLockdownsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       }),
     ),
   ),
-  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",
-    }),
+  resultInfo: Schema.optional(
+    Schema.Union([
+      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",
+        }),
+      ),
+      Schema.Null,
+    ]),
   ),
 }).pipe(
   Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
@@ -1624,12 +1815,12 @@ export interface ListRulesResponse {
       | null;
     ref?: string | null;
   }[];
-  resultInfo: {
+  resultInfo?: {
     count?: number | null;
     page?: number | null;
     perPage?: number | null;
     totalCount?: number | null;
-  };
+  } | null;
 }
 
 export const ListRulesResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
@@ -1696,18 +1887,23 @@ export const ListRulesResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       ref: Schema.optional(Schema.Union([Schema.String, 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",
-    }),
+  resultInfo: Schema.optional(
+    Schema.Union([
+      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",
+        }),
+      ),
+      Schema.Null,
+    ]),
   ),
 }).pipe(
   Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
@@ -2744,12 +2940,12 @@ export interface ListUaRulesResponse {
     mode?: "block" | "challenge" | "js_challenge" | "managed_challenge" | null;
     paused?: boolean | null;
   }[];
-  resultInfo: {
+  resultInfo?: {
     count?: number | null;
     page?: number | null;
     perPage?: number | null;
     totalCount?: number | null;
-  };
+  } | null;
 }
 
 export const ListUaRulesResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
@@ -2780,18 +2976,23 @@ export const ListUaRulesResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       paused: Schema.optional(Schema.Union([Schema.Boolean, 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",
-    }),
+  resultInfo: Schema.optional(
+    Schema.Union([
+      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",
+        }),
+      ),
+      Schema.Null,
+    ]),
   ),
 }).pipe(
   Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
@@ -3324,12 +3525,12 @@ export interface ListWafOverridesResponse {
     rules?: Record<string, unknown> | null;
     urls?: string[] | null;
   }[];
-  resultInfo: {
+  resultInfo?: {
     count?: number | null;
     page?: number | null;
     perPage?: number | null;
     totalCount?: number | null;
-  };
+  } | null;
 }
 
 export const ListWafOverridesResponse =
@@ -3437,18 +3638,25 @@ export const ListWafOverridesResponse =
         }),
       ),
     ),
-    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",
-      }),
+    resultInfo: Schema.optional(
+      Schema.Union([
+        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",
+          }),
+        ),
+        Schema.Null,
+      ]),
     ),
   }).pipe(
     Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
@@ -4065,29 +4273,36 @@ export const ListWafPackagesRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
 
 export interface ListWafPackagesResponse {
   result: unknown[];
-  resultInfo: {
+  resultInfo?: {
     count?: number | null;
     page?: number | null;
     perPage?: number | null;
     totalCount?: number | null;
-  };
+  } | null;
 }
 
 export const ListWafPackagesResponse =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     result: Schema.Array(Schema.Unknown),
-    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",
-      }),
+    resultInfo: Schema.optional(
+      Schema.Union([
+        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",
+          }),
+        ),
+        Schema.Null,
+      ]),
     ),
   }).pipe(
     Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
@@ -4214,12 +4429,12 @@ export interface ListWafPackageGroupsResponse {
     modifiedRulesCount?: number | null;
     packageId?: string | null;
   }[];
-  resultInfo: {
+  resultInfo?: {
     count?: number | null;
     page?: number | null;
     perPage?: number | null;
     totalCount?: number | null;
-  };
+  } | null;
 }
 
 export const ListWafPackageGroupsResponse =
@@ -4254,18 +4469,25 @@ export const ListWafPackageGroupsResponse =
         }),
       ),
     ),
-    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",
-      }),
+    resultInfo: Schema.optional(
+      Schema.Union([
+        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",
+          }),
+        ),
+        Schema.Null,
+      ]),
     ),
   }).pipe(
     Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
@@ -4456,12 +4678,12 @@ export interface ListWafPackageRulesResponse {
         priority: string;
       }
   )[];
-  resultInfo: {
+  resultInfo?: {
     count?: number | null;
     page?: number | null;
     perPage?: number | null;
     totalCount?: number | null;
-  };
+  } | null;
 }
 
 export const ListWafPackageRulesResponse =
@@ -4535,18 +4757,25 @@ export const ListWafPackageRulesResponse =
         ),
       ]),
     ),
-    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",
-      }),
+    resultInfo: Schema.optional(
+      Schema.Union([
+        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",
+          }),
+        ),
+        Schema.Null,
+      ]),
     ),
   }).pipe(
     Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),