@distilled.cloud/cloudflare 0.2.6 → 0.3.0-alpha

package/src/services/api-gateway.ts

@@ -5,6 +5,7 @@
  * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service api-gateway
  */
 
+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";
@@ -84,9 +85,13 @@ export const GetConfigurationResponse =
         }),
       ]),
     ),
-  }).pipe(
-    Schema.encodeKeys({ authIdCharacteristics: "auth_id_characteristics" }),
-  ) as unknown as Schema.Schema<GetConfigurationResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({ authIdCharacteristics: "auth_id_characteristics" }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<GetConfigurationResponse>;
 
 export type GetConfigurationError =
   | DefaultErrors
@@ -161,9 +166,13 @@ export const PutConfigurationResponse =
         }),
       ]),
     ),
-  }).pipe(
-    Schema.encodeKeys({ authIdCharacteristics: "auth_id_characteristics" }),
-  ) as unknown as Schema.Schema<PutConfigurationResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({ authIdCharacteristics: "auth_id_characteristics" }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<PutConfigurationResponse>;
 
 export type PutConfigurationError =
   | DefaultErrors
@@ -204,7 +213,9 @@ export interface GetDiscoveryResponse {
 export const GetDiscoveryResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   schemas: Schema.Array(Schema.Unknown),
   timestamp: Schema.String,
-}) as unknown as Schema.Schema<GetDiscoveryResponse>;
+}).pipe(
+  T.ResponsePath("result"),
+) as unknown as Schema.Schema<GetDiscoveryResponse>;
 
 export type GetDiscoveryError =
   | DefaultErrors
@@ -339,7 +350,9 @@ export const PatchDiscoveryOperationResponse =
         Schema.Null,
       ]),
     ),
-  }) as unknown as Schema.Schema<PatchDiscoveryOperationResponse>;
+  }).pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<PatchDiscoveryOperationResponse>;
 
 export type PatchDiscoveryOperationError =
   | DefaultErrors
@@ -378,8 +391,8 @@ export const BulkPatchDiscoveryOperationsRequest =
 export type BulkPatchDiscoveryOperationsResponse = Record<string, unknown>;
 
 export const BulkPatchDiscoveryOperationsResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
-    {},
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
+    T.ResponsePath("result"),
   ) as unknown as Schema.Schema<BulkPatchDiscoveryOperationsResponse>;
 
 export type BulkPatchDiscoveryOperationsError =
@@ -431,7 +444,9 @@ export const CreateExpressionTemplateFallthroughResponse =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     expression: Schema.String,
     title: Schema.String,
-  }) as unknown as Schema.Schema<CreateExpressionTemplateFallthroughResponse>;
+  }).pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<CreateExpressionTemplateFallthroughResponse>;
 
 export type CreateExpressionTemplateFallthroughError =
   | DefaultErrors
@@ -797,16 +812,20 @@ export const GetOperationResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       Schema.Null,
     ]),
   ),
-}).pipe(
-  Schema.encodeKeys({
-    endpoint: "endpoint",
-    host: "host",
-    lastUpdated: "last_updated",
-    method: "method",
-    operationId: "operation_id",
-    features: "features",
-  }),
-) as unknown as Schema.Schema<GetOperationResponse>;
+})
+  .pipe(
+    Schema.encodeKeys({
+      endpoint: "endpoint",
+      host: "host",
+      lastUpdated: "last_updated",
+      method: "method",
+      operationId: "operation_id",
+      features: "features",
+    }),
+  )
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<GetOperationResponse>;
 
 export type GetOperationError =
   | DefaultErrors
@@ -863,366 +882,490 @@ export const ListOperationsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   T.Http({ method: "GET", path: "/zones/{zone_id}/api_gateway/operations" }),
 ) as unknown as Schema.Schema<ListOperationsRequest>;
 
-export type ListOperationsResponse = {
-  endpoint: string;
-  host: string;
-  lastUpdated: string;
-  method:
-    | "GET"
-    | "POST"
-    | "HEAD"
-    | "OPTIONS"
-    | "PUT"
-    | "DELETE"
-    | "CONNECT"
-    | "PATCH"
-    | "TRACE";
-  operationId: string;
-  features?:
-    | {
-        thresholds?: {
-          authIdTokens?: number | null;
-          dataPoints?: number | null;
-          lastUpdated?: string | null;
-          p50?: number | null;
-          p90?: number | null;
-          p99?: number | null;
-          periodSeconds?: number | null;
-          requests?: number | null;
-          suggestedThreshold?: number | null;
-        } | null;
-      }
-    | {
-        parameterSchemas: {
-          lastUpdated?: string | null;
-          parameterSchemas?: {
-            parameters?: unknown[] | null;
-            responses?: null;
+export interface ListOperationsResponse {
+  result: {
+    endpoint: string;
+    host: string;
+    lastUpdated: string;
+    method:
+      | "GET"
+      | "POST"
+      | "HEAD"
+      | "OPTIONS"
+      | "PUT"
+      | "DELETE"
+      | "CONNECT"
+      | "PATCH"
+      | "TRACE";
+    operationId: string;
+    features?:
+      | {
+          thresholds?: {
+            authIdTokens?: number | null;
+            dataPoints?: number | null;
+            lastUpdated?: string | null;
+            p50?: number | null;
+            p90?: number | null;
+            p99?: number | null;
+            periodSeconds?: number | null;
+            requests?: number | null;
+            suggestedThreshold?: number | null;
           } | null;
-        };
-      }
-    | {
-        apiRouting?: {
-          lastUpdated?: string | null;
-          route?: string | null;
-        } | null;
-      }
-    | {
-        confidenceIntervals?: {
-          lastUpdated?: string | null;
-          suggestedThreshold?: {
-            confidenceIntervals?: {
-              p90?: { lower?: number | null; upper?: number | null } | null;
-              p95?: { lower?: number | null; upper?: number | null } | null;
-              p99?: { lower?: number | null; upper?: number | null } | null;
+        }
+      | {
+          parameterSchemas: {
+            lastUpdated?: string | null;
+            parameterSchemas?: {
+              parameters?: unknown[] | null;
+              responses?: null;
             } | null;
-            mean?: number | null;
+          };
+        }
+      | {
+          apiRouting?: {
+            lastUpdated?: string | null;
+            route?: string | null;
           } | null;
-        } | null;
-      }
-    | {
-        schemaInfo?: {
-          activeSchema?: {
-            id?: string | null;
-            createdAt?: string | null;
-            isLearned?: boolean | null;
-            name?: string | null;
+        }
+      | {
+          confidenceIntervals?: {
+            lastUpdated?: string | null;
+            suggestedThreshold?: {
+              confidenceIntervals?: {
+                p90?: { lower?: number | null; upper?: number | null } | null;
+                p95?: { lower?: number | null; upper?: number | null } | null;
+                p99?: { lower?: number | null; upper?: number | null } | null;
+              } | null;
+              mean?: number | null;
+            } | null;
           } | null;
-          learnedAvailable?: boolean | null;
-          mitigationAction?: "none" | "log" | "block" | null;
-        } | null;
-      }
-    | null;
-}[];
+        }
+      | {
+          schemaInfo?: {
+            activeSchema?: {
+              id?: string | null;
+              createdAt?: string | null;
+              isLearned?: boolean | null;
+              name?: string | null;
+            } | null;
+            learnedAvailable?: boolean | null;
+            mitigationAction?: "none" | "log" | "block" | null;
+          } | null;
+        }
+      | null;
+  }[];
+  resultInfo: {
+    count?: number | null;
+    page?: number | null;
+    perPage?: number | null;
+    totalCount?: number | null;
+  };
+}
 
-export const ListOperationsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-  Schema.Struct({
-    endpoint: Schema.String,
-    host: Schema.String,
-    lastUpdated: Schema.String,
-    method: Schema.Literals([
-      "GET",
-      "POST",
-      "HEAD",
-      "OPTIONS",
-      "PUT",
-      "DELETE",
-      "CONNECT",
-      "PATCH",
-      "TRACE",
-    ]),
-    operationId: Schema.String,
-    features: Schema.optional(
-      Schema.Union([
-        Schema.Union([
-          Schema.Struct({
-            thresholds: Schema.optional(
-              Schema.Union([
-                Schema.Struct({
-                  authIdTokens: Schema.optional(
-                    Schema.Union([Schema.Number, Schema.Null]),
-                  ),
-                  dataPoints: Schema.optional(
-                    Schema.Union([Schema.Number, Schema.Null]),
-                  ),
+export const ListOperationsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    result: Schema.Array(
+      Schema.Struct({
+        endpoint: Schema.String,
+        host: Schema.String,
+        lastUpdated: Schema.String,
+        method: Schema.Literals([
+          "GET",
+          "POST",
+          "HEAD",
+          "OPTIONS",
+          "PUT",
+          "DELETE",
+          "CONNECT",
+          "PATCH",
+          "TRACE",
+        ]),
+        operationId: Schema.String,
+        features: Schema.optional(
+          Schema.Union([
+            Schema.Union([
+              Schema.Struct({
+                thresholds: Schema.optional(
+                  Schema.Union([
+                    Schema.Struct({
+                      authIdTokens: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                      dataPoints: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                      lastUpdated: Schema.optional(
+                        Schema.Union([Schema.String, Schema.Null]),
+                      ),
+                      p50: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                      p90: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                      p99: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                      periodSeconds: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                      requests: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                      suggestedThreshold: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                    }).pipe(
+                      Schema.encodeKeys({
+                        authIdTokens: "auth_id_tokens",
+                        dataPoints: "data_points",
+                        lastUpdated: "last_updated",
+                        p50: "p50",
+                        p90: "p90",
+                        p99: "p99",
+                        periodSeconds: "period_seconds",
+                        requests: "requests",
+                        suggestedThreshold: "suggested_threshold",
+                      }),
+                    ),
+                    Schema.Null,
+                  ]),
+                ),
+              }),
+              Schema.Struct({
+                parameterSchemas: Schema.Struct({
                   lastUpdated: Schema.optional(
                     Schema.Union([Schema.String, Schema.Null]),
                   ),
-                  p50: Schema.optional(
-                    Schema.Union([Schema.Number, Schema.Null]),
-                  ),
-                  p90: Schema.optional(
-                    Schema.Union([Schema.Number, Schema.Null]),
-                  ),
-                  p99: Schema.optional(
-                    Schema.Union([Schema.Number, Schema.Null]),
-                  ),
-                  periodSeconds: Schema.optional(
-                    Schema.Union([Schema.Number, Schema.Null]),
-                  ),
-                  requests: Schema.optional(
-                    Schema.Union([Schema.Number, Schema.Null]),
-                  ),
-                  suggestedThreshold: Schema.optional(
-                    Schema.Union([Schema.Number, Schema.Null]),
+                  parameterSchemas: Schema.optional(
+                    Schema.Union([
+                      Schema.Struct({
+                        parameters: Schema.optional(
+                          Schema.Union([
+                            Schema.Array(Schema.Unknown),
+                            Schema.Null,
+                          ]),
+                        ),
+                        responses: Schema.optional(Schema.Null),
+                      }),
+                      Schema.Null,
+                    ]),
                   ),
                 }).pipe(
                   Schema.encodeKeys({
-                    authIdTokens: "auth_id_tokens",
-                    dataPoints: "data_points",
                     lastUpdated: "last_updated",
-                    p50: "p50",
-                    p90: "p90",
-                    p99: "p99",
-                    periodSeconds: "period_seconds",
-                    requests: "requests",
-                    suggestedThreshold: "suggested_threshold",
+                    parameterSchemas: "parameter_schemas",
                   }),
                 ),
-                Schema.Null,
-              ]),
-            ),
-          }),
-          Schema.Struct({
-            parameterSchemas: Schema.Struct({
-              lastUpdated: Schema.optional(
-                Schema.Union([Schema.String, Schema.Null]),
+              }).pipe(
+                Schema.encodeKeys({ parameterSchemas: "parameter_schemas" }),
               ),
-              parameterSchemas: Schema.optional(
-                Schema.Union([
-                  Schema.Struct({
-                    parameters: Schema.optional(
-                      Schema.Union([Schema.Array(Schema.Unknown), Schema.Null]),
-                    ),
-                    responses: Schema.optional(Schema.Null),
-                  }),
-                  Schema.Null,
-                ]),
-              ),
-            }).pipe(
-              Schema.encodeKeys({
-                lastUpdated: "last_updated",
-                parameterSchemas: "parameter_schemas",
-              }),
-            ),
-          }).pipe(Schema.encodeKeys({ parameterSchemas: "parameter_schemas" })),
-          Schema.Struct({
-            apiRouting: Schema.optional(
-              Schema.Union([
-                Schema.Struct({
-                  lastUpdated: Schema.optional(
-                    Schema.Union([Schema.String, Schema.Null]),
-                  ),
-                  route: Schema.optional(
-                    Schema.Union([Schema.String, Schema.Null]),
-                  ),
-                }).pipe(
-                  Schema.encodeKeys({
-                    lastUpdated: "last_updated",
-                    route: "route",
-                  }),
+              Schema.Struct({
+                apiRouting: Schema.optional(
+                  Schema.Union([
+                    Schema.Struct({
+                      lastUpdated: Schema.optional(
+                        Schema.Union([Schema.String, Schema.Null]),
+                      ),
+                      route: Schema.optional(
+                        Schema.Union([Schema.String, Schema.Null]),
+                      ),
+                    }).pipe(
+                      Schema.encodeKeys({
+                        lastUpdated: "last_updated",
+                        route: "route",
+                      }),
+                    ),
+                    Schema.Null,
+                  ]),
                 ),
-                Schema.Null,
-              ]),
-            ),
-          }).pipe(Schema.encodeKeys({ apiRouting: "api_routing" })),
-          Schema.Struct({
-            confidenceIntervals: Schema.optional(
-              Schema.Union([
-                Schema.Struct({
-                  lastUpdated: Schema.optional(
-                    Schema.Union([Schema.String, Schema.Null]),
-                  ),
-                  suggestedThreshold: Schema.optional(
-                    Schema.Union([
-                      Schema.Struct({
-                        confidenceIntervals: Schema.optional(
-                          Schema.Union([
-                            Schema.Struct({
-                              p90: Schema.optional(
-                                Schema.Union([
-                                  Schema.Struct({
-                                    lower: Schema.optional(
-                                      Schema.Union([
-                                        Schema.Number,
-                                        Schema.Null,
-                                      ]),
-                                    ),
-                                    upper: Schema.optional(
-                                      Schema.Union([
-                                        Schema.Number,
-                                        Schema.Null,
-                                      ]),
-                                    ),
-                                  }),
-                                  Schema.Null,
-                                ]),
-                              ),
-                              p95: Schema.optional(
-                                Schema.Union([
-                                  Schema.Struct({
-                                    lower: Schema.optional(
-                                      Schema.Union([
-                                        Schema.Number,
-                                        Schema.Null,
-                                      ]),
-                                    ),
-                                    upper: Schema.optional(
-                                      Schema.Union([
-                                        Schema.Number,
-                                        Schema.Null,
-                                      ]),
-                                    ),
-                                  }),
-                                  Schema.Null,
-                                ]),
-                              ),
-                              p99: Schema.optional(
-                                Schema.Union([
-                                  Schema.Struct({
-                                    lower: Schema.optional(
-                                      Schema.Union([
-                                        Schema.Number,
-                                        Schema.Null,
-                                      ]),
-                                    ),
-                                    upper: Schema.optional(
-                                      Schema.Union([
-                                        Schema.Number,
-                                        Schema.Null,
-                                      ]),
-                                    ),
-                                  }),
-                                  Schema.Null,
-                                ]),
-                              ),
+              }).pipe(Schema.encodeKeys({ apiRouting: "api_routing" })),
+              Schema.Struct({
+                confidenceIntervals: Schema.optional(
+                  Schema.Union([
+                    Schema.Struct({
+                      lastUpdated: Schema.optional(
+                        Schema.Union([Schema.String, Schema.Null]),
+                      ),
+                      suggestedThreshold: Schema.optional(
+                        Schema.Union([
+                          Schema.Struct({
+                            confidenceIntervals: Schema.optional(
+                              Schema.Union([
+                                Schema.Struct({
+                                  p90: Schema.optional(
+                                    Schema.Union([
+                                      Schema.Struct({
+                                        lower: Schema.optional(
+                                          Schema.Union([
+                                            Schema.Number,
+                                            Schema.Null,
+                                          ]),
+                                        ),
+                                        upper: Schema.optional(
+                                          Schema.Union([
+                                            Schema.Number,
+                                            Schema.Null,
+                                          ]),
+                                        ),
+                                      }),
+                                      Schema.Null,
+                                    ]),
+                                  ),
+                                  p95: Schema.optional(
+                                    Schema.Union([
+                                      Schema.Struct({
+                                        lower: Schema.optional(
+                                          Schema.Union([
+                                            Schema.Number,
+                                            Schema.Null,
+                                          ]),
+                                        ),
+                                        upper: Schema.optional(
+                                          Schema.Union([
+                                            Schema.Number,
+                                            Schema.Null,
+                                          ]),
+                                        ),
+                                      }),
+                                      Schema.Null,
+                                    ]),
+                                  ),
+                                  p99: Schema.optional(
+                                    Schema.Union([
+                                      Schema.Struct({
+                                        lower: Schema.optional(
+                                          Schema.Union([
+                                            Schema.Number,
+                                            Schema.Null,
+                                          ]),
+                                        ),
+                                        upper: Schema.optional(
+                                          Schema.Union([
+                                            Schema.Number,
+                                            Schema.Null,
+                                          ]),
+                                        ),
+                                      }),
+                                      Schema.Null,
+                                    ]),
+                                  ),
+                                }),
+                                Schema.Null,
+                              ]),
+                            ),
+                            mean: Schema.optional(
+                              Schema.Union([Schema.Number, Schema.Null]),
+                            ),
+                          }).pipe(
+                            Schema.encodeKeys({
+                              confidenceIntervals: "confidence_intervals",
+                              mean: "mean",
                             }),
-                            Schema.Null,
-                          ]),
-                        ),
-                        mean: Schema.optional(
-                          Schema.Union([Schema.Number, Schema.Null]),
-                        ),
-                      }).pipe(
-                        Schema.encodeKeys({
-                          confidenceIntervals: "confidence_intervals",
-                          mean: "mean",
-                        }),
+                          ),
+                          Schema.Null,
+                        ]),
                       ),
-                      Schema.Null,
-                    ]),
-                  ),
-                }).pipe(
-                  Schema.encodeKeys({
-                    lastUpdated: "last_updated",
-                    suggestedThreshold: "suggested_threshold",
-                  }),
+                    }).pipe(
+                      Schema.encodeKeys({
+                        lastUpdated: "last_updated",
+                        suggestedThreshold: "suggested_threshold",
+                      }),
+                    ),
+                    Schema.Null,
+                  ]),
                 ),
-                Schema.Null,
-              ]),
-            ),
-          }).pipe(
-            Schema.encodeKeys({ confidenceIntervals: "confidence_intervals" }),
-          ),
-          Schema.Struct({
-            schemaInfo: Schema.optional(
-              Schema.Union([
-                Schema.Struct({
-                  activeSchema: Schema.optional(
-                    Schema.Union([
-                      Schema.Struct({
-                        id: Schema.optional(
-                          Schema.Union([Schema.String, Schema.Null]),
-                        ),
-                        createdAt: Schema.optional(
-                          Schema.Union([Schema.String, Schema.Null]),
-                        ),
-                        isLearned: Schema.optional(
-                          Schema.Union([Schema.Boolean, Schema.Null]),
-                        ),
-                        name: Schema.optional(
-                          Schema.Union([Schema.String, Schema.Null]),
-                        ),
-                      }).pipe(
-                        Schema.encodeKeys({
-                          id: "id",
-                          createdAt: "created_at",
-                          isLearned: "is_learned",
-                          name: "name",
-                        }),
+              }).pipe(
+                Schema.encodeKeys({
+                  confidenceIntervals: "confidence_intervals",
+                }),
+              ),
+              Schema.Struct({
+                schemaInfo: Schema.optional(
+                  Schema.Union([
+                    Schema.Struct({
+                      activeSchema: Schema.optional(
+                        Schema.Union([
+                          Schema.Struct({
+                            id: Schema.optional(
+                              Schema.Union([Schema.String, Schema.Null]),
+                            ),
+                            createdAt: Schema.optional(
+                              Schema.Union([Schema.String, Schema.Null]),
+                            ),
+                            isLearned: Schema.optional(
+                              Schema.Union([Schema.Boolean, Schema.Null]),
+                            ),
+                            name: Schema.optional(
+                              Schema.Union([Schema.String, Schema.Null]),
+                            ),
+                          }).pipe(
+                            Schema.encodeKeys({
+                              id: "id",
+                              createdAt: "created_at",
+                              isLearned: "is_learned",
+                              name: "name",
+                            }),
+                          ),
+                          Schema.Null,
+                        ]),
                       ),
-                      Schema.Null,
-                    ]),
-                  ),
-                  learnedAvailable: Schema.optional(
-                    Schema.Union([Schema.Boolean, Schema.Null]),
-                  ),
-                  mitigationAction: Schema.optional(
-                    Schema.Union([
-                      Schema.Literal("none"),
-                      Schema.Literal("log"),
-                      Schema.Literal("block"),
-                      Schema.Null,
-                    ]),
-                  ),
-                }).pipe(
-                  Schema.encodeKeys({
-                    activeSchema: "active_schema",
-                    learnedAvailable: "learned_available",
-                    mitigationAction: "mitigation_action",
-                  }),
+                      learnedAvailable: Schema.optional(
+                        Schema.Union([Schema.Boolean, Schema.Null]),
+                      ),
+                      mitigationAction: Schema.optional(
+                        Schema.Union([
+                          Schema.Literal("none"),
+                          Schema.Literal("log"),
+                          Schema.Literal("block"),
+                          Schema.Null,
+                        ]),
+                      ),
+                    }).pipe(
+                      Schema.encodeKeys({
+                        activeSchema: "active_schema",
+                        learnedAvailable: "learned_available",
+                        mitigationAction: "mitigation_action",
+                      }),
+                    ),
+                    Schema.Null,
+                  ]),
                 ),
-                Schema.Null,
-              ]),
-            ),
-          }).pipe(Schema.encodeKeys({ schemaInfo: "schema_info" })),
-        ]),
-        Schema.Null,
-      ]),
+              }).pipe(Schema.encodeKeys({ schemaInfo: "schema_info" })),
+            ]),
+            Schema.Null,
+          ]),
+        ),
+      }).pipe(
+        Schema.encodeKeys({
+          endpoint: "endpoint",
+          host: "host",
+          lastUpdated: "last_updated",
+          method: "method",
+          operationId: "operation_id",
+          features: "features",
+        }),
+      ),
     ),
-  }).pipe(
-    Schema.encodeKeys({
-      endpoint: "endpoint",
-      host: "host",
-      lastUpdated: "last_updated",
-      method: "method",
-      operationId: "operation_id",
-      features: "features",
-    }),
-  ),
+    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<ListOperationsResponse>;
 
 export type ListOperationsError = DefaultErrors;
 
-export const listOperations: API.OperationMethod<
+export const listOperations: API.PaginatedOperationMethod<
   ListOperationsRequest,
   ListOperationsResponse,
   ListOperationsError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: ListOperationsRequest,
+  ) => stream.Stream<
+    ListOperationsResponse,
+    ListOperationsError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: ListOperationsRequest) => stream.Stream<
+    {
+      endpoint: string;
+      host: string;
+      lastUpdated: string;
+      method:
+        | "GET"
+        | "POST"
+        | "HEAD"
+        | "OPTIONS"
+        | "PUT"
+        | "DELETE"
+        | "CONNECT"
+        | "PATCH"
+        | "TRACE";
+      operationId: string;
+      features?:
+        | {
+            thresholds?: {
+              authIdTokens?: number | null;
+              dataPoints?: number | null;
+              lastUpdated?: string | null;
+              p50?: number | null;
+              p90?: number | null;
+              p99?: number | null;
+              periodSeconds?: number | null;
+              requests?: number | null;
+              suggestedThreshold?: number | null;
+            } | null;
+          }
+        | {
+            parameterSchemas: {
+              lastUpdated?: string | null;
+              parameterSchemas?: {
+                parameters?: unknown[] | null;
+                responses?: null;
+              } | null;
+            };
+          }
+        | {
+            apiRouting?: {
+              lastUpdated?: string | null;
+              route?: string | null;
+            } | null;
+          }
+        | {
+            confidenceIntervals?: {
+              lastUpdated?: string | null;
+              suggestedThreshold?: {
+                confidenceIntervals?: {
+                  p90?: { lower?: number | null; upper?: number | null } | null;
+                  p95?: { lower?: number | null; upper?: number | null } | null;
+                  p99?: { lower?: number | null; upper?: number | null } | null;
+                } | null;
+                mean?: number | null;
+              } | null;
+            } | null;
+          }
+        | {
+            schemaInfo?: {
+              activeSchema?: {
+                id?: string | null;
+                createdAt?: string | null;
+                isLearned?: boolean | null;
+                name?: string | null;
+              } | null;
+              learnedAvailable?: boolean | null;
+              mitigationAction?: "none" | "log" | "block" | null;
+            } | null;
+          }
+        | null;
+    },
+    ListOperationsError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: ListOperationsRequest,
   output: ListOperationsResponse,
   errors: [],
+  pagination: {
+    mode: "page",
+    inputToken: "page",
+    outputToken: "resultInfo.page",
+    items: "result",
+    pageSize: "perPage",
+  } as const,
 }));
 
 export interface CreateOperationRequest {
@@ -1610,16 +1753,20 @@ export const CreateOperationResponse =
         Schema.Null,
       ]),
     ),
-  }).pipe(
-    Schema.encodeKeys({
-      endpoint: "endpoint",
-      host: "host",
-      lastUpdated: "last_updated",
-      method: "method",
-      operationId: "operation_id",
-      features: "features",
-    }),
-  ) as unknown as Schema.Schema<CreateOperationResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        endpoint: "endpoint",
+        host: "host",
+        lastUpdated: "last_updated",
+        method: "method",
+        operationId: "operation_id",
+        features: "features",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<CreateOperationResponse>;
 
 export type CreateOperationError = DefaultErrors | InvalidObjectIdentifier;
 
@@ -1726,374 +1873,465 @@ export const BulkCreateOperationsRequest =
     T.Http({ method: "POST", path: "/zones/{zone_id}/api_gateway/operations" }),
   ) as unknown as Schema.Schema<BulkCreateOperationsRequest>;
 
-export type BulkCreateOperationsResponse = {
-  endpoint: string;
-  host: string;
-  lastUpdated: string;
-  method:
-    | "GET"
-    | "POST"
-    | "HEAD"
-    | "OPTIONS"
-    | "PUT"
-    | "DELETE"
-    | "CONNECT"
-    | "PATCH"
-    | "TRACE";
-  operationId: string;
-  features?:
-    | {
-        thresholds?: {
-          authIdTokens?: number | null;
-          dataPoints?: number | null;
-          lastUpdated?: string | null;
-          p50?: number | null;
-          p90?: number | null;
-          p99?: number | null;
-          periodSeconds?: number | null;
-          requests?: number | null;
-          suggestedThreshold?: number | null;
-        } | null;
-      }
-    | {
-        parameterSchemas: {
-          lastUpdated?: string | null;
-          parameterSchemas?: {
-            parameters?: unknown[] | null;
-            responses?: null;
+export interface BulkCreateOperationsResponse {
+  result: {
+    endpoint: string;
+    host: string;
+    lastUpdated: string;
+    method:
+      | "GET"
+      | "POST"
+      | "HEAD"
+      | "OPTIONS"
+      | "PUT"
+      | "DELETE"
+      | "CONNECT"
+      | "PATCH"
+      | "TRACE";
+    operationId: string;
+    features?:
+      | {
+          thresholds?: {
+            authIdTokens?: number | null;
+            dataPoints?: number | null;
+            lastUpdated?: string | null;
+            p50?: number | null;
+            p90?: number | null;
+            p99?: number | null;
+            periodSeconds?: number | null;
+            requests?: number | null;
+            suggestedThreshold?: number | null;
           } | null;
-        };
-      }
-    | {
-        apiRouting?: {
-          lastUpdated?: string | null;
-          route?: string | null;
-        } | null;
-      }
-    | {
-        confidenceIntervals?: {
-          lastUpdated?: string | null;
-          suggestedThreshold?: {
-            confidenceIntervals?: {
-              p90?: { lower?: number | null; upper?: number | null } | null;
-              p95?: { lower?: number | null; upper?: number | null } | null;
-              p99?: { lower?: number | null; upper?: number | null } | null;
+        }
+      | {
+          parameterSchemas: {
+            lastUpdated?: string | null;
+            parameterSchemas?: {
+              parameters?: unknown[] | null;
+              responses?: null;
             } | null;
-            mean?: number | null;
+          };
+        }
+      | {
+          apiRouting?: {
+            lastUpdated?: string | null;
+            route?: string | null;
           } | null;
-        } | null;
-      }
-    | {
-        schemaInfo?: {
-          activeSchema?: {
-            id?: string | null;
-            createdAt?: string | null;
-            isLearned?: boolean | null;
-            name?: string | null;
+        }
+      | {
+          confidenceIntervals?: {
+            lastUpdated?: string | null;
+            suggestedThreshold?: {
+              confidenceIntervals?: {
+                p90?: { lower?: number | null; upper?: number | null } | null;
+                p95?: { lower?: number | null; upper?: number | null } | null;
+                p99?: { lower?: number | null; upper?: number | null } | null;
+              } | null;
+              mean?: number | null;
+            } | null;
           } | null;
-          learnedAvailable?: boolean | null;
-          mitigationAction?: "none" | "log" | "block" | null;
-        } | null;
-      }
-    | null;
-}[];
-
-export const BulkCreateOperationsResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-    Schema.Struct({
-      endpoint: Schema.String,
-      host: Schema.String,
-      lastUpdated: Schema.String,
-      method: Schema.Literals([
-        "GET",
-        "POST",
-        "HEAD",
-        "OPTIONS",
-        "PUT",
-        "DELETE",
-        "CONNECT",
-        "PATCH",
-        "TRACE",
-      ]),
-      operationId: Schema.String,
-      features: Schema.optional(
-        Schema.Union([
-          Schema.Union([
-            Schema.Struct({
-              thresholds: Schema.optional(
-                Schema.Union([
-                  Schema.Struct({
-                    authIdTokens: Schema.optional(
-                      Schema.Union([Schema.Number, Schema.Null]),
-                    ),
-                    dataPoints: Schema.optional(
-                      Schema.Union([Schema.Number, Schema.Null]),
-                    ),
-                    lastUpdated: Schema.optional(
-                      Schema.Union([Schema.String, Schema.Null]),
-                    ),
-                    p50: Schema.optional(
-                      Schema.Union([Schema.Number, Schema.Null]),
-                    ),
-                    p90: Schema.optional(
-                      Schema.Union([Schema.Number, Schema.Null]),
-                    ),
-                    p99: Schema.optional(
-                      Schema.Union([Schema.Number, Schema.Null]),
-                    ),
-                    periodSeconds: Schema.optional(
-                      Schema.Union([Schema.Number, Schema.Null]),
-                    ),
-                    requests: Schema.optional(
-                      Schema.Union([Schema.Number, Schema.Null]),
-                    ),
-                    suggestedThreshold: Schema.optional(
-                      Schema.Union([Schema.Number, Schema.Null]),
-                    ),
-                  }).pipe(
-                    Schema.encodeKeys({
-                      authIdTokens: "auth_id_tokens",
-                      dataPoints: "data_points",
-                      lastUpdated: "last_updated",
-                      p50: "p50",
-                      p90: "p90",
-                      p99: "p99",
-                      periodSeconds: "period_seconds",
-                      requests: "requests",
-                      suggestedThreshold: "suggested_threshold",
-                    }),
-                  ),
-                  Schema.Null,
-                ]),
-              ),
-            }),
-            Schema.Struct({
-              parameterSchemas: Schema.Struct({
-                lastUpdated: Schema.optional(
-                  Schema.Union([Schema.String, Schema.Null]),
-                ),
-                parameterSchemas: Schema.optional(
+        }
+      | {
+          schemaInfo?: {
+            activeSchema?: {
+              id?: string | null;
+              createdAt?: string | null;
+              isLearned?: boolean | null;
+              name?: string | null;
+            } | null;
+            learnedAvailable?: boolean | null;
+            mitigationAction?: "none" | "log" | "block" | null;
+          } | null;
+        }
+      | null;
+  }[];
+}
+
+export const BulkCreateOperationsResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(
+      Schema.Struct({
+        endpoint: Schema.String,
+        host: Schema.String,
+        lastUpdated: Schema.String,
+        method: Schema.Literals([
+          "GET",
+          "POST",
+          "HEAD",
+          "OPTIONS",
+          "PUT",
+          "DELETE",
+          "CONNECT",
+          "PATCH",
+          "TRACE",
+        ]),
+        operationId: Schema.String,
+        features: Schema.optional(
+          Schema.Union([
+            Schema.Union([
+              Schema.Struct({
+                thresholds: Schema.optional(
                   Schema.Union([
                     Schema.Struct({
-                      parameters: Schema.optional(
-                        Schema.Union([
-                          Schema.Array(Schema.Unknown),
-                          Schema.Null,
-                        ]),
+                      authIdTokens: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
                       ),
-                      responses: Schema.optional(Schema.Null),
-                    }),
+                      dataPoints: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                      lastUpdated: Schema.optional(
+                        Schema.Union([Schema.String, Schema.Null]),
+                      ),
+                      p50: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                      p90: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                      p99: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                      periodSeconds: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                      requests: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                      suggestedThreshold: Schema.optional(
+                        Schema.Union([Schema.Number, Schema.Null]),
+                      ),
+                    }).pipe(
+                      Schema.encodeKeys({
+                        authIdTokens: "auth_id_tokens",
+                        dataPoints: "data_points",
+                        lastUpdated: "last_updated",
+                        p50: "p50",
+                        p90: "p90",
+                        p99: "p99",
+                        periodSeconds: "period_seconds",
+                        requests: "requests",
+                        suggestedThreshold: "suggested_threshold",
+                      }),
+                    ),
                     Schema.Null,
                   ]),
                 ),
-              }).pipe(
-                Schema.encodeKeys({
-                  lastUpdated: "last_updated",
-                  parameterSchemas: "parameter_schemas",
-                }),
-              ),
-            }).pipe(
-              Schema.encodeKeys({ parameterSchemas: "parameter_schemas" }),
-            ),
-            Schema.Struct({
-              apiRouting: Schema.optional(
-                Schema.Union([
-                  Schema.Struct({
-                    lastUpdated: Schema.optional(
-                      Schema.Union([Schema.String, Schema.Null]),
-                    ),
-                    route: Schema.optional(
-                      Schema.Union([Schema.String, Schema.Null]),
-                    ),
-                  }).pipe(
-                    Schema.encodeKeys({
-                      lastUpdated: "last_updated",
-                      route: "route",
-                    }),
+              }),
+              Schema.Struct({
+                parameterSchemas: Schema.Struct({
+                  lastUpdated: Schema.optional(
+                    Schema.Union([Schema.String, Schema.Null]),
                   ),
-                  Schema.Null,
-                ]),
-              ),
-            }).pipe(Schema.encodeKeys({ apiRouting: "api_routing" })),
-            Schema.Struct({
-              confidenceIntervals: Schema.optional(
-                Schema.Union([
-                  Schema.Struct({
-                    lastUpdated: Schema.optional(
-                      Schema.Union([Schema.String, Schema.Null]),
-                    ),
-                    suggestedThreshold: Schema.optional(
-                      Schema.Union([
-                        Schema.Struct({
-                          confidenceIntervals: Schema.optional(
-                            Schema.Union([
-                              Schema.Struct({
-                                p90: Schema.optional(
-                                  Schema.Union([
-                                    Schema.Struct({
-                                      lower: Schema.optional(
-                                        Schema.Union([
-                                          Schema.Number,
-                                          Schema.Null,
-                                        ]),
-                                      ),
-                                      upper: Schema.optional(
-                                        Schema.Union([
-                                          Schema.Number,
-                                          Schema.Null,
-                                        ]),
-                                      ),
-                                    }),
-                                    Schema.Null,
-                                  ]),
-                                ),
-                                p95: Schema.optional(
-                                  Schema.Union([
-                                    Schema.Struct({
-                                      lower: Schema.optional(
-                                        Schema.Union([
-                                          Schema.Number,
-                                          Schema.Null,
-                                        ]),
-                                      ),
-                                      upper: Schema.optional(
-                                        Schema.Union([
-                                          Schema.Number,
-                                          Schema.Null,
-                                        ]),
-                                      ),
-                                    }),
-                                    Schema.Null,
-                                  ]),
-                                ),
-                                p99: Schema.optional(
-                                  Schema.Union([
-                                    Schema.Struct({
-                                      lower: Schema.optional(
-                                        Schema.Union([
-                                          Schema.Number,
-                                          Schema.Null,
-                                        ]),
-                                      ),
-                                      upper: Schema.optional(
-                                        Schema.Union([
-                                          Schema.Number,
-                                          Schema.Null,
-                                        ]),
-                                      ),
-                                    }),
-                                    Schema.Null,
-                                  ]),
-                                ),
-                              }),
-                              Schema.Null,
-                            ]),
-                          ),
-                          mean: Schema.optional(
-                            Schema.Union([Schema.Number, Schema.Null]),
-                          ),
-                        }).pipe(
-                          Schema.encodeKeys({
-                            confidenceIntervals: "confidence_intervals",
-                            mean: "mean",
-                          }),
+                  parameterSchemas: Schema.optional(
+                    Schema.Union([
+                      Schema.Struct({
+                        parameters: Schema.optional(
+                          Schema.Union([
+                            Schema.Array(Schema.Unknown),
+                            Schema.Null,
+                          ]),
                         ),
-                        Schema.Null,
-                      ]),
-                    ),
-                  }).pipe(
-                    Schema.encodeKeys({
-                      lastUpdated: "last_updated",
-                      suggestedThreshold: "suggested_threshold",
-                    }),
+                        responses: Schema.optional(Schema.Null),
+                      }),
+                      Schema.Null,
+                    ]),
                   ),
-                  Schema.Null,
-                ]),
+                }).pipe(
+                  Schema.encodeKeys({
+                    lastUpdated: "last_updated",
+                    parameterSchemas: "parameter_schemas",
+                  }),
+                ),
+              }).pipe(
+                Schema.encodeKeys({ parameterSchemas: "parameter_schemas" }),
               ),
-            }).pipe(
-              Schema.encodeKeys({
-                confidenceIntervals: "confidence_intervals",
-              }),
-            ),
-            Schema.Struct({
-              schemaInfo: Schema.optional(
-                Schema.Union([
-                  Schema.Struct({
-                    activeSchema: Schema.optional(
-                      Schema.Union([
-                        Schema.Struct({
-                          id: Schema.optional(
-                            Schema.Union([Schema.String, Schema.Null]),
-                          ),
-                          createdAt: Schema.optional(
-                            Schema.Union([Schema.String, Schema.Null]),
-                          ),
-                          isLearned: Schema.optional(
-                            Schema.Union([Schema.Boolean, Schema.Null]),
-                          ),
-                          name: Schema.optional(
-                            Schema.Union([Schema.String, Schema.Null]),
-                          ),
-                        }).pipe(
-                          Schema.encodeKeys({
-                            id: "id",
-                            createdAt: "created_at",
-                            isLearned: "is_learned",
-                            name: "name",
-                          }),
-                        ),
-                        Schema.Null,
-                      ]),
-                    ),
-                    learnedAvailable: Schema.optional(
-                      Schema.Union([Schema.Boolean, Schema.Null]),
+              Schema.Struct({
+                apiRouting: Schema.optional(
+                  Schema.Union([
+                    Schema.Struct({
+                      lastUpdated: Schema.optional(
+                        Schema.Union([Schema.String, Schema.Null]),
+                      ),
+                      route: Schema.optional(
+                        Schema.Union([Schema.String, Schema.Null]),
+                      ),
+                    }).pipe(
+                      Schema.encodeKeys({
+                        lastUpdated: "last_updated",
+                        route: "route",
+                      }),
                     ),
-                    mitigationAction: Schema.optional(
-                      Schema.Union([
-                        Schema.Literal("none"),
-                        Schema.Literal("log"),
-                        Schema.Literal("block"),
-                        Schema.Null,
-                      ]),
+                    Schema.Null,
+                  ]),
+                ),
+              }).pipe(Schema.encodeKeys({ apiRouting: "api_routing" })),
+              Schema.Struct({
+                confidenceIntervals: Schema.optional(
+                  Schema.Union([
+                    Schema.Struct({
+                      lastUpdated: Schema.optional(
+                        Schema.Union([Schema.String, Schema.Null]),
+                      ),
+                      suggestedThreshold: Schema.optional(
+                        Schema.Union([
+                          Schema.Struct({
+                            confidenceIntervals: Schema.optional(
+                              Schema.Union([
+                                Schema.Struct({
+                                  p90: Schema.optional(
+                                    Schema.Union([
+                                      Schema.Struct({
+                                        lower: Schema.optional(
+                                          Schema.Union([
+                                            Schema.Number,
+                                            Schema.Null,
+                                          ]),
+                                        ),
+                                        upper: Schema.optional(
+                                          Schema.Union([
+                                            Schema.Number,
+                                            Schema.Null,
+                                          ]),
+                                        ),
+                                      }),
+                                      Schema.Null,
+                                    ]),
+                                  ),
+                                  p95: Schema.optional(
+                                    Schema.Union([
+                                      Schema.Struct({
+                                        lower: Schema.optional(
+                                          Schema.Union([
+                                            Schema.Number,
+                                            Schema.Null,
+                                          ]),
+                                        ),
+                                        upper: Schema.optional(
+                                          Schema.Union([
+                                            Schema.Number,
+                                            Schema.Null,
+                                          ]),
+                                        ),
+                                      }),
+                                      Schema.Null,
+                                    ]),
+                                  ),
+                                  p99: Schema.optional(
+                                    Schema.Union([
+                                      Schema.Struct({
+                                        lower: Schema.optional(
+                                          Schema.Union([
+                                            Schema.Number,
+                                            Schema.Null,
+                                          ]),
+                                        ),
+                                        upper: Schema.optional(
+                                          Schema.Union([
+                                            Schema.Number,
+                                            Schema.Null,
+                                          ]),
+                                        ),
+                                      }),
+                                      Schema.Null,
+                                    ]),
+                                  ),
+                                }),
+                                Schema.Null,
+                              ]),
+                            ),
+                            mean: Schema.optional(
+                              Schema.Union([Schema.Number, Schema.Null]),
+                            ),
+                          }).pipe(
+                            Schema.encodeKeys({
+                              confidenceIntervals: "confidence_intervals",
+                              mean: "mean",
+                            }),
+                          ),
+                          Schema.Null,
+                        ]),
+                      ),
+                    }).pipe(
+                      Schema.encodeKeys({
+                        lastUpdated: "last_updated",
+                        suggestedThreshold: "suggested_threshold",
+                      }),
                     ),
-                  }).pipe(
-                    Schema.encodeKeys({
-                      activeSchema: "active_schema",
-                      learnedAvailable: "learned_available",
-                      mitigationAction: "mitigation_action",
-                    }),
-                  ),
-                  Schema.Null,
-                ]),
+                    Schema.Null,
+                  ]),
+                ),
+              }).pipe(
+                Schema.encodeKeys({
+                  confidenceIntervals: "confidence_intervals",
+                }),
               ),
-            }).pipe(Schema.encodeKeys({ schemaInfo: "schema_info" })),
+              Schema.Struct({
+                schemaInfo: Schema.optional(
+                  Schema.Union([
+                    Schema.Struct({
+                      activeSchema: Schema.optional(
+                        Schema.Union([
+                          Schema.Struct({
+                            id: Schema.optional(
+                              Schema.Union([Schema.String, Schema.Null]),
+                            ),
+                            createdAt: Schema.optional(
+                              Schema.Union([Schema.String, Schema.Null]),
+                            ),
+                            isLearned: Schema.optional(
+                              Schema.Union([Schema.Boolean, Schema.Null]),
+                            ),
+                            name: Schema.optional(
+                              Schema.Union([Schema.String, Schema.Null]),
+                            ),
+                          }).pipe(
+                            Schema.encodeKeys({
+                              id: "id",
+                              createdAt: "created_at",
+                              isLearned: "is_learned",
+                              name: "name",
+                            }),
+                          ),
+                          Schema.Null,
+                        ]),
+                      ),
+                      learnedAvailable: Schema.optional(
+                        Schema.Union([Schema.Boolean, Schema.Null]),
+                      ),
+                      mitigationAction: Schema.optional(
+                        Schema.Union([
+                          Schema.Literal("none"),
+                          Schema.Literal("log"),
+                          Schema.Literal("block"),
+                          Schema.Null,
+                        ]),
+                      ),
+                    }).pipe(
+                      Schema.encodeKeys({
+                        activeSchema: "active_schema",
+                        learnedAvailable: "learned_available",
+                        mitigationAction: "mitigation_action",
+                      }),
+                    ),
+                    Schema.Null,
+                  ]),
+                ),
+              }).pipe(Schema.encodeKeys({ schemaInfo: "schema_info" })),
+            ]),
+            Schema.Null,
           ]),
-          Schema.Null,
-        ]),
+        ),
+      }).pipe(
+        Schema.encodeKeys({
+          endpoint: "endpoint",
+          host: "host",
+          lastUpdated: "last_updated",
+          method: "method",
+          operationId: "operation_id",
+          features: "features",
+        }),
       ),
-    }).pipe(
-      Schema.encodeKeys({
-        endpoint: "endpoint",
-        host: "host",
-        lastUpdated: "last_updated",
-        method: "method",
-        operationId: "operation_id",
-        features: "features",
-      }),
     ),
-  ) as unknown as Schema.Schema<BulkCreateOperationsResponse>;
+  }) as unknown as Schema.Schema<BulkCreateOperationsResponse>;
 
 export type BulkCreateOperationsError = DefaultErrors;
 
-export const bulkCreateOperations: API.OperationMethod<
+export const bulkCreateOperations: API.PaginatedOperationMethod<
   BulkCreateOperationsRequest,
   BulkCreateOperationsResponse,
   BulkCreateOperationsError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: BulkCreateOperationsRequest,
+  ) => stream.Stream<
+    BulkCreateOperationsResponse,
+    BulkCreateOperationsError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: BulkCreateOperationsRequest) => stream.Stream<
+    {
+      endpoint: string;
+      host: string;
+      lastUpdated: string;
+      method:
+        | "GET"
+        | "POST"
+        | "HEAD"
+        | "OPTIONS"
+        | "PUT"
+        | "DELETE"
+        | "CONNECT"
+        | "PATCH"
+        | "TRACE";
+      operationId: string;
+      features?:
+        | {
+            thresholds?: {
+              authIdTokens?: number | null;
+              dataPoints?: number | null;
+              lastUpdated?: string | null;
+              p50?: number | null;
+              p90?: number | null;
+              p99?: number | null;
+              periodSeconds?: number | null;
+              requests?: number | null;
+              suggestedThreshold?: number | null;
+            } | null;
+          }
+        | {
+            parameterSchemas: {
+              lastUpdated?: string | null;
+              parameterSchemas?: {
+                parameters?: unknown[] | null;
+                responses?: null;
+              } | null;
+            };
+          }
+        | {
+            apiRouting?: {
+              lastUpdated?: string | null;
+              route?: string | null;
+            } | null;
+          }
+        | {
+            confidenceIntervals?: {
+              lastUpdated?: string | null;
+              suggestedThreshold?: {
+                confidenceIntervals?: {
+                  p90?: { lower?: number | null; upper?: number | null } | null;
+                  p95?: { lower?: number | null; upper?: number | null } | null;
+                  p99?: { lower?: number | null; upper?: number | null } | null;
+                } | null;
+                mean?: number | null;
+              } | null;
+            } | null;
+          }
+        | {
+            schemaInfo?: {
+              activeSchema?: {
+                id?: string | null;
+                createdAt?: string | null;
+                isLearned?: boolean | null;
+                name?: string | null;
+              } | null;
+              learnedAvailable?: boolean | null;
+              mitigationAction?: "none" | "log" | "block" | null;
+            } | null;
+          }
+        | null;
+    },
+    BulkCreateOperationsError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: BulkCreateOperationsRequest,
   output: BulkCreateOperationsResponse,
   errors: [],
+  pagination: {
+    mode: "single",
+    items: "result",
+  } as const,
 }));
 
 export interface BulkDeleteOperationsRequest {
@@ -2291,8 +2529,8 @@ export const PatchOperationSchemaValidationRequest =
 export type PatchOperationSchemaValidationResponse = Record<string, unknown>;
 
 export const PatchOperationSchemaValidationResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
-    {},
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
+    T.ResponsePath("result"),
   ) as unknown as Schema.Schema<PatchOperationSchemaValidationResponse>;
 
 export type PatchOperationSchemaValidationError =
@@ -2345,7 +2583,9 @@ export const ListSchemasResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     Schema.Union([Schema.Array(Schema.Unknown), Schema.Null]),
   ),
   timestamp: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-}) as unknown as Schema.Schema<ListSchemasResponse>;
+}).pipe(
+  T.ResponsePath("result"),
+) as unknown as Schema.Schema<ListSchemasResponse>;
 
 export type ListSchemasError = DefaultErrors | InvalidObjectIdentifier;
 
@@ -2560,16 +2800,20 @@ export const GetUserSchemaResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   validationEnabled: Schema.optional(
     Schema.Union([Schema.Boolean, Schema.Null]),
   ),
-}).pipe(
-  Schema.encodeKeys({
-    createdAt: "created_at",
-    kind: "kind",
-    name: "name",
-    schemaId: "schema_id",
-    source: "source",
-    validationEnabled: "validation_enabled",
-  }),
-) as unknown as Schema.Schema<GetUserSchemaResponse>;
+})
+  .pipe(
+    Schema.encodeKeys({
+      createdAt: "created_at",
+      kind: "kind",
+      name: "name",
+      schemaId: "schema_id",
+      source: "source",
+      validationEnabled: "validation_enabled",
+    }),
+  )
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<GetUserSchemaResponse>;
 
 export type GetUserSchemaError =
   | DefaultErrors
@@ -2610,48 +2854,101 @@ export const ListUserSchemasRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   T.Http({ method: "GET", path: "/zones/{zone_id}/api_gateway/user_schemas" }),
 ) as unknown as Schema.Schema<ListUserSchemasRequest>;
 
-export type ListUserSchemasResponse = {
-  createdAt: string;
-  kind: "openapi_v3";
-  name: string;
-  schemaId: string;
-  source?: string | null;
-  validationEnabled?: boolean | null;
-}[];
+export interface ListUserSchemasResponse {
+  result: {
+    createdAt: string;
+    kind: "openapi_v3";
+    name: string;
+    schemaId: string;
+    source?: string | null;
+    validationEnabled?: boolean | null;
+  }[];
+  resultInfo: {
+    count?: number | null;
+    page?: number | null;
+    perPage?: number | null;
+    totalCount?: number | null;
+  };
+}
 
-export const ListUserSchemasResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-  Schema.Struct({
-    createdAt: Schema.String,
-    kind: Schema.Literal("openapi_v3"),
-    name: Schema.String,
-    schemaId: Schema.String,
-    source: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    validationEnabled: Schema.optional(
-      Schema.Union([Schema.Boolean, Schema.Null]),
+export const ListUserSchemasResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(
+      Schema.Struct({
+        createdAt: Schema.String,
+        kind: Schema.Literal("openapi_v3"),
+        name: Schema.String,
+        schemaId: Schema.String,
+        source: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        validationEnabled: Schema.optional(
+          Schema.Union([Schema.Boolean, Schema.Null]),
+        ),
+      }).pipe(
+        Schema.encodeKeys({
+          createdAt: "created_at",
+          kind: "kind",
+          name: "name",
+          schemaId: "schema_id",
+          source: "source",
+          validationEnabled: "validation_enabled",
+        }),
+      ),
+    ),
+    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({
-      createdAt: "created_at",
-      kind: "kind",
-      name: "name",
-      schemaId: "schema_id",
-      source: "source",
-      validationEnabled: "validation_enabled",
-    }),
-  ),
-) as unknown as Schema.Schema<ListUserSchemasResponse>;
+    Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
+  ) as unknown as Schema.Schema<ListUserSchemasResponse>;
 
 export type ListUserSchemasError = DefaultErrors;
 
-export const listUserSchemas: API.OperationMethod<
+export const listUserSchemas: API.PaginatedOperationMethod<
   ListUserSchemasRequest,
   ListUserSchemasResponse,
   ListUserSchemasError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: ListUserSchemasRequest,
+  ) => stream.Stream<
+    ListUserSchemasResponse,
+    ListUserSchemasError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: ListUserSchemasRequest) => stream.Stream<
+    {
+      createdAt: string;
+      kind: "openapi_v3";
+      name: string;
+      schemaId: string;
+      source?: string | null;
+      validationEnabled?: boolean | null;
+    },
+    ListUserSchemasError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: ListUserSchemasRequest,
   output: ListUserSchemasResponse,
   errors: [],
+  pagination: {
+    mode: "page",
+    inputToken: "page",
+    outputToken: "resultInfo.page",
+    items: "result",
+    pageSize: "perPage",
+  } as const,
 }));
 
 export interface CreateUserSchemaRequest {
@@ -2748,9 +3045,13 @@ export const CreateUserSchemaResponse =
         Schema.Null,
       ]),
     ),
-  }).pipe(
-    Schema.encodeKeys({ schema: "schema", uploadDetails: "upload_details" }),
-  ) as unknown as Schema.Schema<CreateUserSchemaResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({ schema: "schema", uploadDetails: "upload_details" }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<CreateUserSchemaResponse>;
 
 export type CreateUserSchemaError = DefaultErrors | InvalidObjectIdentifier;
 
@@ -2811,16 +3112,20 @@ export const PatchUserSchemaResponse =
     validationEnabled: Schema.optional(
       Schema.Union([Schema.Boolean, Schema.Null]),
     ),
-  }).pipe(
-    Schema.encodeKeys({
-      createdAt: "created_at",
-      kind: "kind",
-      name: "name",
-      schemaId: "schema_id",
-      source: "source",
-      validationEnabled: "validation_enabled",
-    }),
-  ) as unknown as Schema.Schema<PatchUserSchemaResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        createdAt: "created_at",
+        kind: "kind",
+        name: "name",
+        schemaId: "schema_id",
+        source: "source",
+        validationEnabled: "validation_enabled",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<PatchUserSchemaResponse>;
 
 export type PatchUserSchemaError =
   | DefaultErrors
@@ -2904,41 +3209,88 @@ export const ListUserSchemaHostsRequest =
     }),
   ) as unknown as Schema.Schema<ListUserSchemaHostsRequest>;
 
-export type ListUserSchemaHostsResponse = {
-  createdAt: string;
-  hosts: string[];
-  name: string;
-  schemaId: string;
-}[];
+export interface ListUserSchemaHostsResponse {
+  result: {
+    createdAt: string;
+    hosts: string[];
+    name: string;
+    schemaId: string;
+  }[];
+  resultInfo: {
+    count?: number | null;
+    page?: number | null;
+    perPage?: number | null;
+    totalCount?: number | null;
+  };
+}
 
 export const ListUserSchemaHostsResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-    Schema.Struct({
-      createdAt: Schema.String,
-      hosts: Schema.Array(Schema.String),
-      name: Schema.String,
-      schemaId: Schema.String,
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(
+      Schema.Struct({
+        createdAt: Schema.String,
+        hosts: Schema.Array(Schema.String),
+        name: Schema.String,
+        schemaId: Schema.String,
+      }).pipe(
+        Schema.encodeKeys({
+          createdAt: "created_at",
+          hosts: "hosts",
+          name: "name",
+          schemaId: "schema_id",
+        }),
+      ),
+    ),
+    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({
-        createdAt: "created_at",
-        hosts: "hosts",
-        name: "name",
-        schemaId: "schema_id",
+        count: "count",
+        page: "page",
+        perPage: "per_page",
+        totalCount: "total_count",
       }),
     ),
+  }).pipe(
+    Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
   ) as unknown as Schema.Schema<ListUserSchemaHostsResponse>;
 
 export type ListUserSchemaHostsError = DefaultErrors;
 
-export const listUserSchemaHosts: API.OperationMethod<
+export const listUserSchemaHosts: API.PaginatedOperationMethod<
   ListUserSchemaHostsRequest,
   ListUserSchemaHostsResponse,
   ListUserSchemaHostsError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: ListUserSchemaHostsRequest,
+  ) => stream.Stream<
+    ListUserSchemaHostsResponse,
+    ListUserSchemaHostsError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (
+    input: ListUserSchemaHostsRequest,
+  ) => stream.Stream<
+    { createdAt: string; hosts: string[]; name: string; schemaId: string },
+    ListUserSchemaHostsError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: ListUserSchemaHostsRequest,
   output: ListUserSchemaHostsResponse,
   errors: [],
+  pagination: {
+    mode: "page",
+    inputToken: "page",
+    outputToken: "resultInfo.page",
+    items: "result",
+    pageSize: "perPage",
+  } as const,
 }));
 
 // =============================================================================
@@ -2987,405 +3339,552 @@ export const ListUserSchemaOperationsRequest =
     }),
   ) as unknown as Schema.Schema<ListUserSchemaOperationsRequest>;
 
-export type ListUserSchemaOperationsResponse = (
-  | {
-      endpoint: string;
-      host: string;
-      lastUpdated: string;
-      method:
-        | "GET"
-        | "POST"
-        | "HEAD"
-        | "OPTIONS"
-        | "PUT"
-        | "DELETE"
-        | "CONNECT"
-        | "PATCH"
-        | "TRACE";
-      operationId: string;
-      features?:
-        | {
-            thresholds?: {
-              authIdTokens?: number | null;
-              dataPoints?: number | null;
-              lastUpdated?: string | null;
-              p50?: number | null;
-              p90?: number | null;
-              p99?: number | null;
-              periodSeconds?: number | null;
-              requests?: number | null;
-              suggestedThreshold?: number | null;
-            } | null;
-          }
-        | {
-            parameterSchemas: {
-              lastUpdated?: string | null;
-              parameterSchemas?: {
-                parameters?: unknown[] | null;
-                responses?: null;
+export interface ListUserSchemaOperationsResponse {
+  result: (
+    | {
+        endpoint: string;
+        host: string;
+        lastUpdated: string;
+        method:
+          | "GET"
+          | "POST"
+          | "HEAD"
+          | "OPTIONS"
+          | "PUT"
+          | "DELETE"
+          | "CONNECT"
+          | "PATCH"
+          | "TRACE";
+        operationId: string;
+        features?:
+          | {
+              thresholds?: {
+                authIdTokens?: number | null;
+                dataPoints?: number | null;
+                lastUpdated?: string | null;
+                p50?: number | null;
+                p90?: number | null;
+                p99?: number | null;
+                periodSeconds?: number | null;
+                requests?: number | null;
+                suggestedThreshold?: number | null;
               } | null;
-            };
-          }
-        | {
-            apiRouting?: {
-              lastUpdated?: string | null;
-              route?: string | null;
-            } | null;
-          }
-        | {
-            confidenceIntervals?: {
-              lastUpdated?: string | null;
-              suggestedThreshold?: {
-                confidenceIntervals?: {
-                  p90?: { lower?: number | null; upper?: number | null } | null;
-                  p95?: { lower?: number | null; upper?: number | null } | null;
-                  p99?: { lower?: number | null; upper?: number | null } | null;
+            }
+          | {
+              parameterSchemas: {
+                lastUpdated?: string | null;
+                parameterSchemas?: {
+                  parameters?: unknown[] | null;
+                  responses?: null;
                 } | null;
-                mean?: number | null;
+              };
+            }
+          | {
+              apiRouting?: {
+                lastUpdated?: string | null;
+                route?: string | null;
               } | null;
-            } | null;
-          }
-        | {
-            schemaInfo?: {
-              activeSchema?: {
-                id?: string | null;
-                createdAt?: string | null;
-                isLearned?: boolean | null;
-                name?: string | null;
+            }
+          | {
+              confidenceIntervals?: {
+                lastUpdated?: string | null;
+                suggestedThreshold?: {
+                  confidenceIntervals?: {
+                    p90?: {
+                      lower?: number | null;
+                      upper?: number | null;
+                    } | null;
+                    p95?: {
+                      lower?: number | null;
+                      upper?: number | null;
+                    } | null;
+                    p99?: {
+                      lower?: number | null;
+                      upper?: number | null;
+                    } | null;
+                  } | null;
+                  mean?: number | null;
+                } | null;
               } | null;
-              learnedAvailable?: boolean | null;
-              mitigationAction?: "none" | "log" | "block" | null;
-            } | null;
-          }
-        | null;
-    }
-  | {
-      endpoint: string;
-      host: string;
-      method:
-        | "GET"
-        | "POST"
-        | "HEAD"
-        | "OPTIONS"
-        | "PUT"
-        | "DELETE"
-        | "CONNECT"
-        | "PATCH"
-        | "TRACE";
-    }
-)[];
+            }
+          | {
+              schemaInfo?: {
+                activeSchema?: {
+                  id?: string | null;
+                  createdAt?: string | null;
+                  isLearned?: boolean | null;
+                  name?: string | null;
+                } | null;
+                learnedAvailable?: boolean | null;
+                mitigationAction?: "none" | "log" | "block" | null;
+              } | null;
+            }
+          | null;
+      }
+    | {
+        endpoint: string;
+        host: string;
+        method:
+          | "GET"
+          | "POST"
+          | "HEAD"
+          | "OPTIONS"
+          | "PUT"
+          | "DELETE"
+          | "CONNECT"
+          | "PATCH"
+          | "TRACE";
+      }
+  )[];
+  resultInfo: {
+    count?: number | null;
+    page?: number | null;
+    perPage?: number | null;
+    totalCount?: number | null;
+  };
+}
 
 export const ListUserSchemaOperationsResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-    Schema.Union([
-      Schema.Struct({
-        endpoint: Schema.String,
-        host: Schema.String,
-        lastUpdated: Schema.String,
-        method: Schema.Literals([
-          "GET",
-          "POST",
-          "HEAD",
-          "OPTIONS",
-          "PUT",
-          "DELETE",
-          "CONNECT",
-          "PATCH",
-          "TRACE",
-        ]),
-        operationId: Schema.String,
-        features: Schema.optional(
-          Schema.Union([
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(
+      Schema.Union([
+        Schema.Struct({
+          endpoint: Schema.String,
+          host: Schema.String,
+          lastUpdated: Schema.String,
+          method: Schema.Literals([
+            "GET",
+            "POST",
+            "HEAD",
+            "OPTIONS",
+            "PUT",
+            "DELETE",
+            "CONNECT",
+            "PATCH",
+            "TRACE",
+          ]),
+          operationId: Schema.String,
+          features: Schema.optional(
             Schema.Union([
-              Schema.Struct({
-                thresholds: Schema.optional(
-                  Schema.Union([
-                    Schema.Struct({
-                      authIdTokens: Schema.optional(
-                        Schema.Union([Schema.Number, Schema.Null]),
-                      ),
-                      dataPoints: Schema.optional(
-                        Schema.Union([Schema.Number, Schema.Null]),
-                      ),
-                      lastUpdated: Schema.optional(
-                        Schema.Union([Schema.String, Schema.Null]),
-                      ),
-                      p50: Schema.optional(
-                        Schema.Union([Schema.Number, Schema.Null]),
-                      ),
-                      p90: Schema.optional(
-                        Schema.Union([Schema.Number, Schema.Null]),
-                      ),
-                      p99: Schema.optional(
-                        Schema.Union([Schema.Number, Schema.Null]),
-                      ),
-                      periodSeconds: Schema.optional(
-                        Schema.Union([Schema.Number, Schema.Null]),
-                      ),
-                      requests: Schema.optional(
-                        Schema.Union([Schema.Number, Schema.Null]),
-                      ),
-                      suggestedThreshold: Schema.optional(
-                        Schema.Union([Schema.Number, Schema.Null]),
+              Schema.Union([
+                Schema.Struct({
+                  thresholds: Schema.optional(
+                    Schema.Union([
+                      Schema.Struct({
+                        authIdTokens: Schema.optional(
+                          Schema.Union([Schema.Number, Schema.Null]),
+                        ),
+                        dataPoints: Schema.optional(
+                          Schema.Union([Schema.Number, Schema.Null]),
+                        ),
+                        lastUpdated: Schema.optional(
+                          Schema.Union([Schema.String, Schema.Null]),
+                        ),
+                        p50: Schema.optional(
+                          Schema.Union([Schema.Number, Schema.Null]),
+                        ),
+                        p90: Schema.optional(
+                          Schema.Union([Schema.Number, Schema.Null]),
+                        ),
+                        p99: Schema.optional(
+                          Schema.Union([Schema.Number, Schema.Null]),
+                        ),
+                        periodSeconds: Schema.optional(
+                          Schema.Union([Schema.Number, Schema.Null]),
+                        ),
+                        requests: Schema.optional(
+                          Schema.Union([Schema.Number, Schema.Null]),
+                        ),
+                        suggestedThreshold: Schema.optional(
+                          Schema.Union([Schema.Number, Schema.Null]),
+                        ),
+                      }).pipe(
+                        Schema.encodeKeys({
+                          authIdTokens: "auth_id_tokens",
+                          dataPoints: "data_points",
+                          lastUpdated: "last_updated",
+                          p50: "p50",
+                          p90: "p90",
+                          p99: "p99",
+                          periodSeconds: "period_seconds",
+                          requests: "requests",
+                          suggestedThreshold: "suggested_threshold",
+                        }),
                       ),
-                    }).pipe(
-                      Schema.encodeKeys({
-                        authIdTokens: "auth_id_tokens",
-                        dataPoints: "data_points",
-                        lastUpdated: "last_updated",
-                        p50: "p50",
-                        p90: "p90",
-                        p99: "p99",
-                        periodSeconds: "period_seconds",
-                        requests: "requests",
-                        suggestedThreshold: "suggested_threshold",
-                      }),
+                      Schema.Null,
+                    ]),
+                  ),
+                }),
+                Schema.Struct({
+                  parameterSchemas: Schema.Struct({
+                    lastUpdated: Schema.optional(
+                      Schema.Union([Schema.String, Schema.Null]),
                     ),
-                    Schema.Null,
-                  ]),
+                    parameterSchemas: Schema.optional(
+                      Schema.Union([
+                        Schema.Struct({
+                          parameters: Schema.optional(
+                            Schema.Union([
+                              Schema.Array(Schema.Unknown),
+                              Schema.Null,
+                            ]),
+                          ),
+                          responses: Schema.optional(Schema.Null),
+                        }),
+                        Schema.Null,
+                      ]),
+                    ),
+                  }).pipe(
+                    Schema.encodeKeys({
+                      lastUpdated: "last_updated",
+                      parameterSchemas: "parameter_schemas",
+                    }),
+                  ),
+                }).pipe(
+                  Schema.encodeKeys({ parameterSchemas: "parameter_schemas" }),
                 ),
-              }),
-              Schema.Struct({
-                parameterSchemas: Schema.Struct({
-                  lastUpdated: Schema.optional(
-                    Schema.Union([Schema.String, Schema.Null]),
+                Schema.Struct({
+                  apiRouting: Schema.optional(
+                    Schema.Union([
+                      Schema.Struct({
+                        lastUpdated: Schema.optional(
+                          Schema.Union([Schema.String, Schema.Null]),
+                        ),
+                        route: Schema.optional(
+                          Schema.Union([Schema.String, Schema.Null]),
+                        ),
+                      }).pipe(
+                        Schema.encodeKeys({
+                          lastUpdated: "last_updated",
+                          route: "route",
+                        }),
+                      ),
+                      Schema.Null,
+                    ]),
                   ),
-                  parameterSchemas: Schema.optional(
+                }).pipe(Schema.encodeKeys({ apiRouting: "api_routing" })),
+                Schema.Struct({
+                  confidenceIntervals: Schema.optional(
                     Schema.Union([
                       Schema.Struct({
-                        parameters: Schema.optional(
+                        lastUpdated: Schema.optional(
+                          Schema.Union([Schema.String, Schema.Null]),
+                        ),
+                        suggestedThreshold: Schema.optional(
                           Schema.Union([
-                            Schema.Array(Schema.Unknown),
+                            Schema.Struct({
+                              confidenceIntervals: Schema.optional(
+                                Schema.Union([
+                                  Schema.Struct({
+                                    p90: Schema.optional(
+                                      Schema.Union([
+                                        Schema.Struct({
+                                          lower: Schema.optional(
+                                            Schema.Union([
+                                              Schema.Number,
+                                              Schema.Null,
+                                            ]),
+                                          ),
+                                          upper: Schema.optional(
+                                            Schema.Union([
+                                              Schema.Number,
+                                              Schema.Null,
+                                            ]),
+                                          ),
+                                        }),
+                                        Schema.Null,
+                                      ]),
+                                    ),
+                                    p95: Schema.optional(
+                                      Schema.Union([
+                                        Schema.Struct({
+                                          lower: Schema.optional(
+                                            Schema.Union([
+                                              Schema.Number,
+                                              Schema.Null,
+                                            ]),
+                                          ),
+                                          upper: Schema.optional(
+                                            Schema.Union([
+                                              Schema.Number,
+                                              Schema.Null,
+                                            ]),
+                                          ),
+                                        }),
+                                        Schema.Null,
+                                      ]),
+                                    ),
+                                    p99: Schema.optional(
+                                      Schema.Union([
+                                        Schema.Struct({
+                                          lower: Schema.optional(
+                                            Schema.Union([
+                                              Schema.Number,
+                                              Schema.Null,
+                                            ]),
+                                          ),
+                                          upper: Schema.optional(
+                                            Schema.Union([
+                                              Schema.Number,
+                                              Schema.Null,
+                                            ]),
+                                          ),
+                                        }),
+                                        Schema.Null,
+                                      ]),
+                                    ),
+                                  }),
+                                  Schema.Null,
+                                ]),
+                              ),
+                              mean: Schema.optional(
+                                Schema.Union([Schema.Number, Schema.Null]),
+                              ),
+                            }).pipe(
+                              Schema.encodeKeys({
+                                confidenceIntervals: "confidence_intervals",
+                                mean: "mean",
+                              }),
+                            ),
                             Schema.Null,
                           ]),
                         ),
-                        responses: Schema.optional(Schema.Null),
-                      }),
+                      }).pipe(
+                        Schema.encodeKeys({
+                          lastUpdated: "last_updated",
+                          suggestedThreshold: "suggested_threshold",
+                        }),
+                      ),
                       Schema.Null,
                     ]),
                   ),
                 }).pipe(
                   Schema.encodeKeys({
-                    lastUpdated: "last_updated",
-                    parameterSchemas: "parameter_schemas",
+                    confidenceIntervals: "confidence_intervals",
                   }),
                 ),
-              }).pipe(
-                Schema.encodeKeys({ parameterSchemas: "parameter_schemas" }),
-              ),
-              Schema.Struct({
-                apiRouting: Schema.optional(
-                  Schema.Union([
-                    Schema.Struct({
-                      lastUpdated: Schema.optional(
-                        Schema.Union([Schema.String, Schema.Null]),
-                      ),
-                      route: Schema.optional(
-                        Schema.Union([Schema.String, Schema.Null]),
-                      ),
-                    }).pipe(
-                      Schema.encodeKeys({
-                        lastUpdated: "last_updated",
-                        route: "route",
-                      }),
-                    ),
-                    Schema.Null,
-                  ]),
-                ),
-              }).pipe(Schema.encodeKeys({ apiRouting: "api_routing" })),
-              Schema.Struct({
-                confidenceIntervals: Schema.optional(
-                  Schema.Union([
-                    Schema.Struct({
-                      lastUpdated: Schema.optional(
-                        Schema.Union([Schema.String, Schema.Null]),
-                      ),
-                      suggestedThreshold: Schema.optional(
-                        Schema.Union([
-                          Schema.Struct({
-                            confidenceIntervals: Schema.optional(
-                              Schema.Union([
-                                Schema.Struct({
-                                  p90: Schema.optional(
-                                    Schema.Union([
-                                      Schema.Struct({
-                                        lower: Schema.optional(
-                                          Schema.Union([
-                                            Schema.Number,
-                                            Schema.Null,
-                                          ]),
-                                        ),
-                                        upper: Schema.optional(
-                                          Schema.Union([
-                                            Schema.Number,
-                                            Schema.Null,
-                                          ]),
-                                        ),
-                                      }),
-                                      Schema.Null,
-                                    ]),
-                                  ),
-                                  p95: Schema.optional(
-                                    Schema.Union([
-                                      Schema.Struct({
-                                        lower: Schema.optional(
-                                          Schema.Union([
-                                            Schema.Number,
-                                            Schema.Null,
-                                          ]),
-                                        ),
-                                        upper: Schema.optional(
-                                          Schema.Union([
-                                            Schema.Number,
-                                            Schema.Null,
-                                          ]),
-                                        ),
-                                      }),
-                                      Schema.Null,
-                                    ]),
-                                  ),
-                                  p99: Schema.optional(
-                                    Schema.Union([
-                                      Schema.Struct({
-                                        lower: Schema.optional(
-                                          Schema.Union([
-                                            Schema.Number,
-                                            Schema.Null,
-                                          ]),
-                                        ),
-                                        upper: Schema.optional(
-                                          Schema.Union([
-                                            Schema.Number,
-                                            Schema.Null,
-                                          ]),
-                                        ),
-                                      }),
-                                      Schema.Null,
-                                    ]),
-                                  ),
-                                }),
-                                Schema.Null,
-                              ]),
-                            ),
-                            mean: Schema.optional(
-                              Schema.Union([Schema.Number, Schema.Null]),
-                            ),
-                          }).pipe(
-                            Schema.encodeKeys({
-                              confidenceIntervals: "confidence_intervals",
-                              mean: "mean",
-                            }),
-                          ),
-                          Schema.Null,
-                        ]),
-                      ),
-                    }).pipe(
-                      Schema.encodeKeys({
-                        lastUpdated: "last_updated",
-                        suggestedThreshold: "suggested_threshold",
-                      }),
-                    ),
-                    Schema.Null,
-                  ]),
-                ),
-              }).pipe(
-                Schema.encodeKeys({
-                  confidenceIntervals: "confidence_intervals",
-                }),
-              ),
-              Schema.Struct({
-                schemaInfo: Schema.optional(
-                  Schema.Union([
-                    Schema.Struct({
-                      activeSchema: Schema.optional(
-                        Schema.Union([
-                          Schema.Struct({
-                            id: Schema.optional(
-                              Schema.Union([Schema.String, Schema.Null]),
-                            ),
-                            createdAt: Schema.optional(
-                              Schema.Union([Schema.String, Schema.Null]),
-                            ),
-                            isLearned: Schema.optional(
-                              Schema.Union([Schema.Boolean, Schema.Null]),
-                            ),
-                            name: Schema.optional(
-                              Schema.Union([Schema.String, Schema.Null]),
+                Schema.Struct({
+                  schemaInfo: Schema.optional(
+                    Schema.Union([
+                      Schema.Struct({
+                        activeSchema: Schema.optional(
+                          Schema.Union([
+                            Schema.Struct({
+                              id: Schema.optional(
+                                Schema.Union([Schema.String, Schema.Null]),
+                              ),
+                              createdAt: Schema.optional(
+                                Schema.Union([Schema.String, Schema.Null]),
+                              ),
+                              isLearned: Schema.optional(
+                                Schema.Union([Schema.Boolean, Schema.Null]),
+                              ),
+                              name: Schema.optional(
+                                Schema.Union([Schema.String, Schema.Null]),
+                              ),
+                            }).pipe(
+                              Schema.encodeKeys({
+                                id: "id",
+                                createdAt: "created_at",
+                                isLearned: "is_learned",
+                                name: "name",
+                              }),
                             ),
-                          }).pipe(
-                            Schema.encodeKeys({
-                              id: "id",
-                              createdAt: "created_at",
-                              isLearned: "is_learned",
-                              name: "name",
-                            }),
-                          ),
-                          Schema.Null,
-                        ]),
-                      ),
-                      learnedAvailable: Schema.optional(
-                        Schema.Union([Schema.Boolean, Schema.Null]),
-                      ),
-                      mitigationAction: Schema.optional(
-                        Schema.Union([
-                          Schema.Literal("none"),
-                          Schema.Literal("log"),
-                          Schema.Literal("block"),
-                          Schema.Null,
-                        ]),
+                            Schema.Null,
+                          ]),
+                        ),
+                        learnedAvailable: Schema.optional(
+                          Schema.Union([Schema.Boolean, Schema.Null]),
+                        ),
+                        mitigationAction: Schema.optional(
+                          Schema.Union([
+                            Schema.Literal("none"),
+                            Schema.Literal("log"),
+                            Schema.Literal("block"),
+                            Schema.Null,
+                          ]),
+                        ),
+                      }).pipe(
+                        Schema.encodeKeys({
+                          activeSchema: "active_schema",
+                          learnedAvailable: "learned_available",
+                          mitigationAction: "mitigation_action",
+                        }),
                       ),
-                    }).pipe(
-                      Schema.encodeKeys({
-                        activeSchema: "active_schema",
-                        learnedAvailable: "learned_available",
-                        mitigationAction: "mitigation_action",
-                      }),
-                    ),
-                    Schema.Null,
-                  ]),
-                ),
-              }).pipe(Schema.encodeKeys({ schemaInfo: "schema_info" })),
+                      Schema.Null,
+                    ]),
+                  ),
+                }).pipe(Schema.encodeKeys({ schemaInfo: "schema_info" })),
+              ]),
+              Schema.Null,
             ]),
-            Schema.Null,
-          ]),
+          ),
+        }).pipe(
+          Schema.encodeKeys({
+            endpoint: "endpoint",
+            host: "host",
+            lastUpdated: "last_updated",
+            method: "method",
+            operationId: "operation_id",
+            features: "features",
+          }),
         ),
-      }).pipe(
-        Schema.encodeKeys({
-          endpoint: "endpoint",
-          host: "host",
-          lastUpdated: "last_updated",
-          method: "method",
-          operationId: "operation_id",
-          features: "features",
+        Schema.Struct({
+          endpoint: Schema.String,
+          host: Schema.String,
+          method: Schema.Literals([
+            "GET",
+            "POST",
+            "HEAD",
+            "OPTIONS",
+            "PUT",
+            "DELETE",
+            "CONNECT",
+            "PATCH",
+            "TRACE",
+          ]),
         }),
-      ),
-      Schema.Struct({
-        endpoint: Schema.String,
-        host: Schema.String,
-        method: Schema.Literals([
-          "GET",
-          "POST",
-          "HEAD",
-          "OPTIONS",
-          "PUT",
-          "DELETE",
-          "CONNECT",
-          "PATCH",
-          "TRACE",
-        ]),
+      ]),
+    ),
+    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<ListUserSchemaOperationsResponse>;
 
 export type ListUserSchemaOperationsError = DefaultErrors;
 
-export const listUserSchemaOperations: API.OperationMethod<
+export const listUserSchemaOperations: API.PaginatedOperationMethod<
   ListUserSchemaOperationsRequest,
   ListUserSchemaOperationsResponse,
   ListUserSchemaOperationsError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: ListUserSchemaOperationsRequest,
+  ) => stream.Stream<
+    ListUserSchemaOperationsResponse,
+    ListUserSchemaOperationsError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: ListUserSchemaOperationsRequest) => stream.Stream<
+    | {
+        endpoint: string;
+        host: string;
+        lastUpdated: string;
+        method:
+          | "GET"
+          | "POST"
+          | "HEAD"
+          | "OPTIONS"
+          | "PUT"
+          | "DELETE"
+          | "CONNECT"
+          | "PATCH"
+          | "TRACE";
+        operationId: string;
+        features?:
+          | {
+              thresholds?: {
+                authIdTokens?: number | null;
+                dataPoints?: number | null;
+                lastUpdated?: string | null;
+                p50?: number | null;
+                p90?: number | null;
+                p99?: number | null;
+                periodSeconds?: number | null;
+                requests?: number | null;
+                suggestedThreshold?: number | null;
+              } | null;
+            }
+          | {
+              parameterSchemas: {
+                lastUpdated?: string | null;
+                parameterSchemas?: {
+                  parameters?: unknown[] | null;
+                  responses?: null;
+                } | null;
+              };
+            }
+          | {
+              apiRouting?: {
+                lastUpdated?: string | null;
+                route?: string | null;
+              } | null;
+            }
+          | {
+              confidenceIntervals?: {
+                lastUpdated?: string | null;
+                suggestedThreshold?: {
+                  confidenceIntervals?: {
+                    p90?: {
+                      lower?: number | null;
+                      upper?: number | null;
+                    } | null;
+                    p95?: {
+                      lower?: number | null;
+                      upper?: number | null;
+                    } | null;
+                    p99?: {
+                      lower?: number | null;
+                      upper?: number | null;
+                    } | null;
+                  } | null;
+                  mean?: number | null;
+                } | null;
+              } | null;
+            }
+          | {
+              schemaInfo?: {
+                activeSchema?: {
+                  id?: string | null;
+                  createdAt?: string | null;
+                  isLearned?: boolean | null;
+                  name?: string | null;
+                } | null;
+                learnedAvailable?: boolean | null;
+                mitigationAction?: "none" | "log" | "block" | null;
+              } | null;
+            }
+          | null;
+      }
+    | {
+        endpoint: string;
+        host: string;
+        method:
+          | "GET"
+          | "POST"
+          | "HEAD"
+          | "OPTIONS"
+          | "PUT"
+          | "DELETE"
+          | "CONNECT"
+          | "PATCH"
+          | "TRACE";
+      },
+    ListUserSchemaOperationsError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: ListUserSchemaOperationsRequest,
   output: ListUserSchemaOperationsResponse,
   errors: [],
+  pagination: {
+    mode: "page",
+    inputToken: "page",
+    outputToken: "resultInfo.page",
+    items: "result",
+    pageSize: "perPage",
+  } as const,
 }));