@distilled.cloud/cloudflare 0.2.5-alpha2 → 0.3.0-alpha

package/lib/services/pipelines.js

@@ -4,10 +4,12 @@
  * Generated from Cloudflare TypeScript SDK.
  * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service pipelines
  */
+import * as stream from "effect/Stream";
 import * as Schema from "effect/Schema";
 import * as API from "../client/api.js";
 import * as T from "../traits.js";
 import {} from "../errors.js";
+import { SensitiveString } from "../sensitive.js";
 // =============================================================================
 // Errors
 // =============================================================================
@@ -89,7 +91,7 @@ export const GetPipelineResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
         }),
     ])),
     version: Schema.Number,
-});
+}).pipe(T.ResponsePath("result"));
 export const getPipeline = API.make(() => ({
     input: GetPipelineRequest,
     output: GetPipelineResponse,
@@ -101,7 +103,7 @@ export const ListPipelinesRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     perPage: Schema.optional(Schema.String).pipe(T.HttpQuery("per_page")),
     search: Schema.optional(Schema.String).pipe(T.HttpQuery("search")),
 }).pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/pipelines" }));
-export const ListPipelinesResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(Schema.Struct({
+export const ListPipelinesResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     resultInfo: Schema.optional(Schema.Union([
         Schema.Struct({
             count: Schema.Number,
@@ -116,66 +118,60 @@ export const ListPipelinesResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(Sc
         })),
         Schema.Null,
     ])),
-    results: Schema.optional(Schema.Union([
-        Schema.Array(Schema.Struct({
-            id: Schema.String,
-            destination: Schema.Struct({
-                batch: Schema.Struct({
-                    maxBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-                    maxDurationS: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-                    maxRows: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-                }).pipe(Schema.encodeKeys({
-                    maxBytes: "max_bytes",
-                    maxDurationS: "max_duration_s",
-                    maxRows: "max_rows",
-                })),
-                compression: Schema.Struct({
-                    type: Schema.optional(Schema.Union([
-                        Schema.Literals(["none", "gzip", "deflate"]),
-                        Schema.Null,
-                    ])),
-                }),
+    results: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        destination: Schema.Struct({
+            batch: Schema.Struct({
+                maxBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                maxDurationS: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                maxRows: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                maxBytes: "max_bytes",
+                maxDurationS: "max_duration_s",
+                maxRows: "max_rows",
+            })),
+            compression: Schema.Struct({
+                type: Schema.optional(Schema.Union([
+                    Schema.Literals(["none", "gzip", "deflate"]),
+                    Schema.Null,
+                ])),
+            }),
+            format: Schema.Literal("json"),
+            path: Schema.Struct({
+                bucket: Schema.String,
+                filename: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                filepath: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                prefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }),
+            type: Schema.Literal("r2"),
+        }),
+        endpoint: Schema.String,
+        name: Schema.String,
+        source: Schema.Array(Schema.Union([
+            Schema.Struct({
                 format: Schema.Literal("json"),
-                path: Schema.Struct({
-                    bucket: Schema.String,
-                    filename: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    filepath: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    prefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                }),
-                type: Schema.Literal("r2"),
+                type: Schema.String,
+                authentication: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                cors: Schema.optional(Schema.Union([
+                    Schema.Struct({
+                        origins: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                    }),
+                    Schema.Null,
+                ])),
             }),
-            endpoint: Schema.String,
-            name: Schema.String,
-            source: Schema.Array(Schema.Union([
-                Schema.Struct({
-                    format: Schema.Literal("json"),
-                    type: Schema.String,
-                    authentication: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                    cors: Schema.optional(Schema.Union([
-                        Schema.Struct({
-                            origins: Schema.optional(Schema.Union([
-                                Schema.Array(Schema.String),
-                                Schema.Null,
-                            ])),
-                        }),
-                        Schema.Null,
-                    ])),
-                }),
-                Schema.Struct({
-                    format: Schema.Literal("json"),
-                    type: Schema.String,
-                }),
-            ])),
-            version: Schema.Number,
-        })),
-        Schema.Null,
-    ])),
-    success: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            Schema.Struct({
+                format: Schema.Literal("json"),
+                type: Schema.String,
+            }),
+        ])),
+        version: Schema.Number,
+    })),
+    success: Schema.Boolean,
 }).pipe(Schema.encodeKeys({
     resultInfo: "result_info",
-    results: "results",
+    results: "result",
     success: "success",
-})));
+}));
 export const listPipelines = API.make(() => ({
     input: ListPipelinesRequest,
     output: ListPipelinesResponse,
@@ -197,9 +193,9 @@ export const CreatePipelineRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
             type: Schema.optional(Schema.Literals(["none", "gzip", "deflate"])),
         }),
         credentials: Schema.Struct({
-            accessKeyId: Schema.String,
+            accessKeyId: SensitiveString,
             endpoint: Schema.String,
-            secretAccessKey: Schema.String,
+            secretAccessKey: SensitiveString,
         }).pipe(Schema.encodeKeys({
             accessKeyId: "access_key_id",
             endpoint: "endpoint",
@@ -277,7 +273,7 @@ export const CreatePipelineResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
         }),
     ])),
     version: Schema.Number,
-});
+}).pipe(T.ResponsePath("result"));
 export const createPipeline = API.make(() => ({
     input: CreatePipelineRequest,
     output: CreatePipelineResponse,
@@ -308,9 +304,9 @@ export const UpdatePipelineRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
         }),
         type: Schema.Literal("r2"),
         credentials: Schema.optional(Schema.Struct({
-            accessKeyId: Schema.String,
+            accessKeyId: SensitiveString,
             endpoint: Schema.String,
-            secretAccessKey: Schema.String,
+            secretAccessKey: SensitiveString,
         }).pipe(Schema.encodeKeys({
             accessKeyId: "access_key_id",
             endpoint: "endpoint",
@@ -383,7 +379,7 @@ export const UpdatePipelineResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
         }),
     ])),
     version: Schema.Number,
-});
+}).pipe(T.ResponsePath("result"));
 export const updatePipeline = API.make(() => ({
     input: UpdatePipelineRequest,
     output: UpdatePipelineResponse,
@@ -422,8 +418,8 @@ export const GetSinkResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
                 accountId: Schema.String,
                 bucket: Schema.String,
                 credentials: Schema.Struct({
-                    accessKeyId: Schema.String,
-                    secretAccessKey: Schema.String,
+                    accessKeyId: SensitiveString,
+                    secretAccessKey: SensitiveString,
                 }).pipe(Schema.encodeKeys({
                     accessKeyId: "access_key_id",
                     secretAccessKey: "secret_access_key",
@@ -721,7 +717,8 @@ export const GetSinkResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
         }),
         Schema.Null,
     ])),
-}).pipe(Schema.encodeKeys({
+})
+    .pipe(Schema.encodeKeys({
     id: "id",
     createdAt: "created_at",
     modifiedAt: "modified_at",
@@ -730,7 +727,8 @@ export const GetSinkResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     config: "config",
     format: "format",
     schema: "schema",
-}));
+}))
+    .pipe(T.ResponsePath("result"));
 export const getSink = API.make(() => ({
     input: GetSinkRequest,
     output: GetSinkResponse,
@@ -740,343 +738,366 @@ export const ListSinksRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     accountId: Schema.String.pipe(T.HttpPath("account_id")),
     pipelineId: Schema.optional(Schema.String).pipe(T.HttpQuery("pipeline_id")),
 }).pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/pipelines/v1/sinks" }));
-export const ListSinksResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(Schema.Struct({
-    id: Schema.String,
-    createdAt: Schema.String,
-    modifiedAt: Schema.String,
-    name: Schema.String,
-    type: Schema.Literals(["r2", "r2_data_catalog"]),
-    config: Schema.optional(Schema.Union([
-        Schema.Union([
-            Schema.Struct({
-                accountId: Schema.String,
-                bucket: Schema.String,
-                credentials: Schema.Struct({
-                    accessKeyId: Schema.String,
-                    secretAccessKey: Schema.String,
-                }).pipe(Schema.encodeKeys({
-                    accessKeyId: "access_key_id",
-                    secretAccessKey: "secret_access_key",
-                })),
-                fileNaming: Schema.optional(Schema.Union([
-                    Schema.Struct({
-                        prefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        strategy: Schema.optional(Schema.Union([
-                            Schema.Literals(["serial", "uuid", "uuid_v7", "ulid"]),
-                            Schema.Null,
-                        ])),
-                        suffix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }),
-                    Schema.Null,
-                ])),
-                jurisdiction: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                partitioning: Schema.optional(Schema.Union([
-                    Schema.Struct({
-                        timePattern: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({ timePattern: "time_pattern" })),
-                    Schema.Null,
-                ])),
-                path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                rollingPolicy: Schema.optional(Schema.Union([
-                    Schema.Struct({
-                        fileSizeBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-                        inactivitySeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-                        intervalSeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        fileSizeBytes: "file_size_bytes",
-                        inactivitySeconds: "inactivity_seconds",
-                        intervalSeconds: "interval_seconds",
-                    })),
-                    Schema.Null,
-                ])),
-            }).pipe(Schema.encodeKeys({
-                accountId: "account_id",
-                bucket: "bucket",
-                credentials: "credentials",
-                fileNaming: "file_naming",
-                jurisdiction: "jurisdiction",
-                partitioning: "partitioning",
-                path: "path",
-                rollingPolicy: "rolling_policy",
-            })),
-            Schema.Struct({
-                token: Schema.String,
-                accountId: Schema.String,
-                bucket: Schema.String,
-                tableName: Schema.String,
-                namespace: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                rollingPolicy: Schema.optional(Schema.Union([
-                    Schema.Struct({
-                        fileSizeBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-                        inactivitySeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-                        intervalSeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+export const ListSinksResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        createdAt: Schema.String,
+        modifiedAt: Schema.String,
+        name: Schema.String,
+        type: Schema.Literals(["r2", "r2_data_catalog"]),
+        config: Schema.optional(Schema.Union([
+            Schema.Union([
+                Schema.Struct({
+                    accountId: Schema.String,
+                    bucket: Schema.String,
+                    credentials: Schema.Struct({
+                        accessKeyId: SensitiveString,
+                        secretAccessKey: SensitiveString,
                     }).pipe(Schema.encodeKeys({
-                        fileSizeBytes: "file_size_bytes",
-                        inactivitySeconds: "inactivity_seconds",
-                        intervalSeconds: "interval_seconds",
+                        accessKeyId: "access_key_id",
+                        secretAccessKey: "secret_access_key",
                     })),
-                    Schema.Null,
-                ])),
-            }).pipe(Schema.encodeKeys({
-                token: "token",
-                accountId: "account_id",
-                bucket: "bucket",
-                tableName: "table_name",
-                namespace: "namespace",
-                rollingPolicy: "rolling_policy",
-            })),
-        ]),
-        Schema.Null,
-    ])),
-    format: Schema.optional(Schema.Union([
-        Schema.Union([
+                    fileNaming: Schema.optional(Schema.Union([
+                        Schema.Struct({
+                            prefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            strategy: Schema.optional(Schema.Union([
+                                Schema.Literals(["serial", "uuid", "uuid_v7", "ulid"]),
+                                Schema.Null,
+                            ])),
+                            suffix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }),
+                        Schema.Null,
+                    ])),
+                    jurisdiction: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    partitioning: Schema.optional(Schema.Union([
+                        Schema.Struct({
+                            timePattern: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({ timePattern: "time_pattern" })),
+                        Schema.Null,
+                    ])),
+                    path: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    rollingPolicy: Schema.optional(Schema.Union([
+                        Schema.Struct({
+                            fileSizeBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                            inactivitySeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                            intervalSeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            fileSizeBytes: "file_size_bytes",
+                            inactivitySeconds: "inactivity_seconds",
+                            intervalSeconds: "interval_seconds",
+                        })),
+                        Schema.Null,
+                    ])),
+                }).pipe(Schema.encodeKeys({
+                    accountId: "account_id",
+                    bucket: "bucket",
+                    credentials: "credentials",
+                    fileNaming: "file_naming",
+                    jurisdiction: "jurisdiction",
+                    partitioning: "partitioning",
+                    path: "path",
+                    rollingPolicy: "rolling_policy",
+                })),
+                Schema.Struct({
+                    token: Schema.String,
+                    accountId: Schema.String,
+                    bucket: Schema.String,
+                    tableName: Schema.String,
+                    namespace: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                    rollingPolicy: Schema.optional(Schema.Union([
+                        Schema.Struct({
+                            fileSizeBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                            inactivitySeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                            intervalSeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            fileSizeBytes: "file_size_bytes",
+                            inactivitySeconds: "inactivity_seconds",
+                            intervalSeconds: "interval_seconds",
+                        })),
+                        Schema.Null,
+                    ])),
+                }).pipe(Schema.encodeKeys({
+                    token: "token",
+                    accountId: "account_id",
+                    bucket: "bucket",
+                    tableName: "table_name",
+                    namespace: "namespace",
+                    rollingPolicy: "rolling_policy",
+                })),
+            ]),
+            Schema.Null,
+        ])),
+        format: Schema.optional(Schema.Union([
+            Schema.Union([
+                Schema.Struct({
+                    type: Schema.Literal("json"),
+                    decimalEncoding: Schema.optional(Schema.Union([
+                        Schema.Literals(["number", "string", "bytes"]),
+                        Schema.Null,
+                    ])),
+                    timestampFormat: Schema.optional(Schema.Union([
+                        Schema.Literals(["rfc3339", "unix_millis"]),
+                        Schema.Null,
+                    ])),
+                    unstructured: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    type: "type",
+                    decimalEncoding: "decimal_encoding",
+                    timestampFormat: "timestamp_format",
+                    unstructured: "unstructured",
+                })),
+                Schema.Struct({
+                    type: Schema.Literal("parquet"),
+                    compression: Schema.optional(Schema.Union([
+                        Schema.Literals([
+                            "uncompressed",
+                            "snappy",
+                            "gzip",
+                            "zstd",
+                            "lz4",
+                        ]),
+                        Schema.Null,
+                    ])),
+                    rowGroupBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    type: "type",
+                    compression: "compression",
+                    rowGroupBytes: "row_group_bytes",
+                })),
+            ]),
+            Schema.Null,
+        ])),
+        schema: Schema.optional(Schema.Union([
             Schema.Struct({
-                type: Schema.Literal("json"),
-                decimalEncoding: Schema.optional(Schema.Union([
-                    Schema.Literals(["number", "string", "bytes"]),
-                    Schema.Null,
-                ])),
-                timestampFormat: Schema.optional(Schema.Union([
-                    Schema.Literals(["rfc3339", "unix_millis"]),
+                fields: Schema.optional(Schema.Union([
+                    Schema.Array(Schema.Union([
+                        Schema.Struct({
+                            type: Schema.Literal("int32"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("int64"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("float32"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("float64"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("bool"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("string"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("binary"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("timestamp"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            unit: Schema.optional(Schema.Union([
+                                Schema.Literals([
+                                    "second",
+                                    "millisecond",
+                                    "microsecond",
+                                    "nanosecond",
+                                ]),
+                                Schema.Null,
+                            ])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                            unit: "unit",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("json"),
+                            decimalEncoding: Schema.optional(Schema.Union([
+                                Schema.Literals(["number", "string", "bytes"]),
+                                Schema.Null,
+                            ])),
+                            timestampFormat: Schema.optional(Schema.Union([
+                                Schema.Literals(["rfc3339", "unix_millis"]),
+                                Schema.Null,
+                            ])),
+                            unstructured: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            decimalEncoding: "decimal_encoding",
+                            timestampFormat: "timestamp_format",
+                            unstructured: "unstructured",
+                        })),
+                        Schema.Unknown,
+                    ])),
                     Schema.Null,
                 ])),
-                unstructured: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-            }).pipe(Schema.encodeKeys({
-                type: "type",
-                decimalEncoding: "decimal_encoding",
-                timestampFormat: "timestamp_format",
-                unstructured: "unstructured",
-            })),
-            Schema.Struct({
-                type: Schema.Literal("parquet"),
-                compression: Schema.optional(Schema.Union([
-                    Schema.Literals([
-                        "uncompressed",
-                        "snappy",
-                        "gzip",
-                        "zstd",
-                        "lz4",
+                format: Schema.optional(Schema.Union([
+                    Schema.Union([
+                        Schema.Struct({
+                            type: Schema.Literal("json"),
+                            decimalEncoding: Schema.optional(Schema.Union([
+                                Schema.Literals(["number", "string", "bytes"]),
+                                Schema.Null,
+                            ])),
+                            timestampFormat: Schema.optional(Schema.Union([
+                                Schema.Literals(["rfc3339", "unix_millis"]),
+                                Schema.Null,
+                            ])),
+                            unstructured: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            decimalEncoding: "decimal_encoding",
+                            timestampFormat: "timestamp_format",
+                            unstructured: "unstructured",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("parquet"),
+                            compression: Schema.optional(Schema.Union([
+                                Schema.Literals([
+                                    "uncompressed",
+                                    "snappy",
+                                    "gzip",
+                                    "zstd",
+                                    "lz4",
+                                ]),
+                                Schema.Null,
+                            ])),
+                            rowGroupBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            compression: "compression",
+                            rowGroupBytes: "row_group_bytes",
+                        })),
                     ]),
                     Schema.Null,
                 ])),
-                rowGroupBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-            }).pipe(Schema.encodeKeys({
-                type: "type",
-                compression: "compression",
-                rowGroupBytes: "row_group_bytes",
-            })),
-        ]),
+                inferred: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            }),
+            Schema.Null,
+        ])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        createdAt: "created_at",
+        modifiedAt: "modified_at",
+        name: "name",
+        type: "type",
+        config: "config",
+        format: "format",
+        schema: "schema",
+    }))),
+    resultInfo: Schema.optional(Schema.Union([
+        Schema.Struct({
+            count: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            page: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            perPage: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            totalCount: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            count: "count",
+            page: "page",
+            perPage: "per_page",
+            totalCount: "total_count",
+        })),
         Schema.Null,
     ])),
-    schema: Schema.optional(Schema.Union([
-        Schema.Struct({
-            fields: Schema.optional(Schema.Union([
-                Schema.Array(Schema.Union([
-                    Schema.Struct({
-                        type: Schema.Literal("int32"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("int64"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("float32"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("float64"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("bool"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("string"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("binary"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("timestamp"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        unit: Schema.optional(Schema.Union([
-                            Schema.Literals([
-                                "second",
-                                "millisecond",
-                                "microsecond",
-                                "nanosecond",
-                            ]),
-                            Schema.Null,
-                        ])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                        unit: "unit",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("json"),
-                        decimalEncoding: Schema.optional(Schema.Union([
-                            Schema.Literals(["number", "string", "bytes"]),
-                            Schema.Null,
-                        ])),
-                        timestampFormat: Schema.optional(Schema.Union([
-                            Schema.Literals(["rfc3339", "unix_millis"]),
-                            Schema.Null,
-                        ])),
-                        unstructured: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        decimalEncoding: "decimal_encoding",
-                        timestampFormat: "timestamp_format",
-                        unstructured: "unstructured",
-                    })),
-                    Schema.Unknown,
-                ])),
-                Schema.Null,
-            ])),
-            format: Schema.optional(Schema.Union([
-                Schema.Union([
-                    Schema.Struct({
-                        type: Schema.Literal("json"),
-                        decimalEncoding: Schema.optional(Schema.Union([
-                            Schema.Literals(["number", "string", "bytes"]),
-                            Schema.Null,
-                        ])),
-                        timestampFormat: Schema.optional(Schema.Union([
-                            Schema.Literals(["rfc3339", "unix_millis"]),
-                            Schema.Null,
-                        ])),
-                        unstructured: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        decimalEncoding: "decimal_encoding",
-                        timestampFormat: "timestamp_format",
-                        unstructured: "unstructured",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("parquet"),
-                        compression: Schema.optional(Schema.Union([
-                            Schema.Literals([
-                                "uncompressed",
-                                "snappy",
-                                "gzip",
-                                "zstd",
-                                "lz4",
-                            ]),
-                            Schema.Null,
-                        ])),
-                        rowGroupBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        compression: "compression",
-                        rowGroupBytes: "row_group_bytes",
-                    })),
-                ]),
-                Schema.Null,
-            ])),
-            inferred: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-        }),
-        Schema.Null,
-    ])),
-}).pipe(Schema.encodeKeys({
-    id: "id",
-    createdAt: "created_at",
-    modifiedAt: "modified_at",
-    name: "name",
-    type: "type",
-    config: "config",
-    format: "format",
-    schema: "schema",
-})));
-export const listSinks = API.make(() => ({
-    input: ListSinksRequest,
-    output: ListSinksResponse,
-    errors: [],
-}));
-export const CreateSinkRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
-    accountId: Schema.String.pipe(T.HttpPath("account_id")),
-    name: Schema.String,
-    type: Schema.Literals(["r2", "r2_data_catalog"]),
-    config: Schema.optional(Schema.Union([
+}).pipe(Schema.encodeKeys({ result: "result", resultInfo: "result_info" }));
+export const listSinks = API.makePaginated(() => ({
+    input: ListSinksRequest,
+    output: ListSinksResponse,
+    errors: [],
+    pagination: {
+        mode: "page",
+        inputToken: "page",
+        outputToken: "resultInfo.page",
+        items: "result",
+        pageSize: "perPage",
+    },
+}));
+export const CreateSinkRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    name: Schema.String,
+    type: Schema.Literals(["r2", "r2_data_catalog"]),
+    config: Schema.optional(Schema.Union([
         Schema.Struct({
             accountId: Schema.String,
             bucket: Schema.String,
             credentials: Schema.Struct({
-                accessKeyId: Schema.String,
-                secretAccessKey: Schema.String,
+                accessKeyId: SensitiveString,
+                secretAccessKey: SensitiveString,
             }).pipe(Schema.encodeKeys({
                 accessKeyId: "access_key_id",
                 secretAccessKey: "secret_access_key",
@@ -1325,8 +1346,8 @@ export const CreateSinkResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
                 accountId: Schema.String,
                 bucket: Schema.String,
                 credentials: Schema.Struct({
-                    accessKeyId: Schema.String,
-                    secretAccessKey: Schema.String,
+                    accessKeyId: SensitiveString,
+                    secretAccessKey: SensitiveString,
                 }).pipe(Schema.encodeKeys({
                     accessKeyId: "access_key_id",
                     secretAccessKey: "secret_access_key",
@@ -1376,357 +1397,31 @@ export const CreateSinkResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
                 token: Schema.String,
                 accountId: Schema.String,
                 bucket: Schema.String,
-                tableName: Schema.String,
-                namespace: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                rollingPolicy: Schema.optional(Schema.Union([
-                    Schema.Struct({
-                        fileSizeBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-                        inactivitySeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-                        intervalSeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        fileSizeBytes: "file_size_bytes",
-                        inactivitySeconds: "inactivity_seconds",
-                        intervalSeconds: "interval_seconds",
-                    })),
-                    Schema.Null,
-                ])),
-            }).pipe(Schema.encodeKeys({
-                token: "token",
-                accountId: "account_id",
-                bucket: "bucket",
-                tableName: "table_name",
-                namespace: "namespace",
-                rollingPolicy: "rolling_policy",
-            })),
-        ]),
-        Schema.Null,
-    ])),
-    format: Schema.optional(Schema.Union([
-        Schema.Union([
-            Schema.Struct({
-                type: Schema.Literal("json"),
-                decimalEncoding: Schema.optional(Schema.Union([
-                    Schema.Literals(["number", "string", "bytes"]),
-                    Schema.Null,
-                ])),
-                timestampFormat: Schema.optional(Schema.Union([
-                    Schema.Literals(["rfc3339", "unix_millis"]),
-                    Schema.Null,
-                ])),
-                unstructured: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-            }).pipe(Schema.encodeKeys({
-                type: "type",
-                decimalEncoding: "decimal_encoding",
-                timestampFormat: "timestamp_format",
-                unstructured: "unstructured",
-            })),
-            Schema.Struct({
-                type: Schema.Literal("parquet"),
-                compression: Schema.optional(Schema.Union([
-                    Schema.Literals([
-                        "uncompressed",
-                        "snappy",
-                        "gzip",
-                        "zstd",
-                        "lz4",
-                    ]),
-                    Schema.Null,
-                ])),
-                rowGroupBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-            }).pipe(Schema.encodeKeys({
-                type: "type",
-                compression: "compression",
-                rowGroupBytes: "row_group_bytes",
-            })),
-        ]),
-        Schema.Null,
-    ])),
-    schema: Schema.optional(Schema.Union([
-        Schema.Struct({
-            fields: Schema.optional(Schema.Union([
-                Schema.Array(Schema.Union([
-                    Schema.Struct({
-                        type: Schema.Literal("int32"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("int64"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("float32"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("float64"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("bool"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("string"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("binary"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("timestamp"),
-                        metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                        sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-                        unit: Schema.optional(Schema.Union([
-                            Schema.Literals([
-                                "second",
-                                "millisecond",
-                                "microsecond",
-                                "nanosecond",
-                            ]),
-                            Schema.Null,
-                        ])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        metadataKey: "metadata_key",
-                        name: "name",
-                        required: "required",
-                        sqlName: "sql_name",
-                        unit: "unit",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("json"),
-                        decimalEncoding: Schema.optional(Schema.Union([
-                            Schema.Literals(["number", "string", "bytes"]),
-                            Schema.Null,
-                        ])),
-                        timestampFormat: Schema.optional(Schema.Union([
-                            Schema.Literals(["rfc3339", "unix_millis"]),
-                            Schema.Null,
-                        ])),
-                        unstructured: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        decimalEncoding: "decimal_encoding",
-                        timestampFormat: "timestamp_format",
-                        unstructured: "unstructured",
-                    })),
-                    Schema.Unknown,
-                ])),
-                Schema.Null,
-            ])),
-            format: Schema.optional(Schema.Union([
-                Schema.Union([
-                    Schema.Struct({
-                        type: Schema.Literal("json"),
-                        decimalEncoding: Schema.optional(Schema.Union([
-                            Schema.Literals(["number", "string", "bytes"]),
-                            Schema.Null,
-                        ])),
-                        timestampFormat: Schema.optional(Schema.Union([
-                            Schema.Literals(["rfc3339", "unix_millis"]),
-                            Schema.Null,
-                        ])),
-                        unstructured: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        decimalEncoding: "decimal_encoding",
-                        timestampFormat: "timestamp_format",
-                        unstructured: "unstructured",
-                    })),
-                    Schema.Struct({
-                        type: Schema.Literal("parquet"),
-                        compression: Schema.optional(Schema.Union([
-                            Schema.Literals([
-                                "uncompressed",
-                                "snappy",
-                                "gzip",
-                                "zstd",
-                                "lz4",
-                            ]),
-                            Schema.Null,
-                        ])),
-                        rowGroupBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-                    }).pipe(Schema.encodeKeys({
-                        type: "type",
-                        compression: "compression",
-                        rowGroupBytes: "row_group_bytes",
-                    })),
-                ]),
-                Schema.Null,
-            ])),
-            inferred: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-        }),
-        Schema.Null,
-    ])),
-}).pipe(Schema.encodeKeys({
-    id: "id",
-    createdAt: "created_at",
-    modifiedAt: "modified_at",
-    name: "name",
-    type: "type",
-    config: "config",
-    format: "format",
-    schema: "schema",
-}));
-export const createSink = API.make(() => ({
-    input: CreateSinkRequest,
-    output: CreateSinkResponse,
-    errors: [],
-}));
-export const DeleteSinkRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
-    sinkId: Schema.String.pipe(T.HttpPath("sinkId")),
-    accountId: Schema.String.pipe(T.HttpPath("account_id")),
-    force: Schema.optional(Schema.String).pipe(T.HttpQuery("force")),
-}).pipe(T.Http({
-    method: "DELETE",
-    path: "/accounts/{account_id}/pipelines/v1/sinks/{sinkId}",
-}));
-export const DeleteSinkResponse = 
-/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
-export const deleteSink = API.make(() => ({
-    input: DeleteSinkRequest,
-    output: DeleteSinkResponse,
-    errors: [],
-}));
-export const ValidateSqlPipelineRequest = 
-/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
-    accountId: Schema.String.pipe(T.HttpPath("account_id")),
-    sql: Schema.String,
-}).pipe(T.Http({
-    method: "POST",
-    path: "/accounts/{account_id}/pipelines/v1/validate_sql",
-}));
-export const ValidateSqlPipelineResponse = 
-/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
-    tables: Schema.Struct({}),
-    graph: Schema.optional(Schema.Union([
-        Schema.Struct({
-            edges: Schema.Array(Schema.Struct({
-                destId: Schema.Number,
-                edgeType: Schema.String,
-                keyType: Schema.String,
-                srcId: Schema.Number,
-                valueType: Schema.String,
-            }).pipe(Schema.encodeKeys({
-                destId: "dest_id",
-                edgeType: "edge_type",
-                keyType: "key_type",
-                srcId: "src_id",
-                valueType: "value_type",
-            }))),
-            nodes: Schema.Array(Schema.Struct({
-                description: Schema.String,
-                nodeId: Schema.Number,
-                operator: Schema.String,
-                parallelism: Schema.Number,
+                tableName: Schema.String,
+                namespace: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                rollingPolicy: Schema.optional(Schema.Union([
+                    Schema.Struct({
+                        fileSizeBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                        inactivitySeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                        intervalSeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                    }).pipe(Schema.encodeKeys({
+                        fileSizeBytes: "file_size_bytes",
+                        inactivitySeconds: "inactivity_seconds",
+                        intervalSeconds: "interval_seconds",
+                    })),
+                    Schema.Null,
+                ])),
             }).pipe(Schema.encodeKeys({
-                description: "description",
-                nodeId: "node_id",
-                operator: "operator",
-                parallelism: "parallelism",
-            }))),
-        }),
+                token: "token",
+                accountId: "account_id",
+                bucket: "bucket",
+                tableName: "table_name",
+                namespace: "namespace",
+                rollingPolicy: "rolling_policy",
+            })),
+        ]),
         Schema.Null,
     ])),
-});
-export const validateSqlPipeline = API.make(() => ({
-    input: ValidateSqlPipelineRequest,
-    output: ValidateSqlPipelineResponse,
-    errors: [TableNotFound],
-}));
-export const GetStreamRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
-    streamId: Schema.String.pipe(T.HttpPath("streamId")),
-    accountId: Schema.String.pipe(T.HttpPath("account_id")),
-}).pipe(T.Http({
-    method: "GET",
-    path: "/accounts/{account_id}/pipelines/v1/streams/{streamId}",
-}));
-export const GetStreamResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
-    id: Schema.String,
-    createdAt: Schema.String,
-    http: Schema.Struct({
-        authentication: Schema.Boolean,
-        enabled: Schema.Boolean,
-        cors: Schema.optional(Schema.Union([
-            Schema.Struct({
-                origins: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
-            }),
-            Schema.Null,
-        ])),
-    }),
-    modifiedAt: Schema.String,
-    name: Schema.String,
-    version: Schema.Number,
-    workerBinding: Schema.Struct({
-        enabled: Schema.Boolean,
-    }),
-    endpoint: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     format: Schema.optional(Schema.Union([
         Schema.Union([
             Schema.Struct({
@@ -1950,31 +1645,92 @@ export const GetStreamResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
         }),
         Schema.Null,
     ])),
-}).pipe(Schema.encodeKeys({
+})
+    .pipe(Schema.encodeKeys({
     id: "id",
     createdAt: "created_at",
-    http: "http",
     modifiedAt: "modified_at",
     name: "name",
-    version: "version",
-    workerBinding: "worker_binding",
-    endpoint: "endpoint",
+    type: "type",
+    config: "config",
     format: "format",
     schema: "schema",
+}))
+    .pipe(T.ResponsePath("result"));
+export const createSink = API.make(() => ({
+    input: CreateSinkRequest,
+    output: CreateSinkResponse,
+    errors: [],
 }));
-export const getStream = API.make(() => ({
-    input: GetStreamRequest,
-    output: GetStreamResponse,
-    errors: [StreamNotFound, InvalidStreamId],
+export const DeleteSinkRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    sinkId: Schema.String.pipe(T.HttpPath("sinkId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    force: Schema.optional(Schema.String).pipe(T.HttpQuery("force")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/pipelines/v1/sinks/{sinkId}",
 }));
-export const ListStreamsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+export const DeleteSinkResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
+export const deleteSink = API.make(() => ({
+    input: DeleteSinkRequest,
+    output: DeleteSinkResponse,
+    errors: [],
+}));
+export const ValidateSqlPipelineRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    sql: Schema.String,
+}).pipe(T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/pipelines/v1/validate_sql",
+}));
+export const ValidateSqlPipelineResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    tables: Schema.Struct({}),
+    graph: Schema.optional(Schema.Union([
+        Schema.Struct({
+            edges: Schema.Array(Schema.Struct({
+                destId: Schema.Number,
+                edgeType: Schema.String,
+                keyType: Schema.String,
+                srcId: Schema.Number,
+                valueType: Schema.String,
+            }).pipe(Schema.encodeKeys({
+                destId: "dest_id",
+                edgeType: "edge_type",
+                keyType: "key_type",
+                srcId: "src_id",
+                valueType: "value_type",
+            }))),
+            nodes: Schema.Array(Schema.Struct({
+                description: Schema.String,
+                nodeId: Schema.Number,
+                operator: Schema.String,
+                parallelism: Schema.Number,
+            }).pipe(Schema.encodeKeys({
+                description: "description",
+                nodeId: "node_id",
+                operator: "operator",
+                parallelism: "parallelism",
+            }))),
+        }),
+        Schema.Null,
+    ])),
+}).pipe(T.ResponsePath("result"));
+export const validateSqlPipeline = API.make(() => ({
+    input: ValidateSqlPipelineRequest,
+    output: ValidateSqlPipelineResponse,
+    errors: [TableNotFound],
+}));
+export const GetStreamRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    streamId: Schema.String.pipe(T.HttpPath("streamId")),
     accountId: Schema.String.pipe(T.HttpPath("account_id")),
-    pipelineId: Schema.optional(Schema.String).pipe(T.HttpQuery("pipeline_id")),
 }).pipe(T.Http({
     method: "GET",
-    path: "/accounts/{account_id}/pipelines/v1/streams",
+    path: "/accounts/{account_id}/pipelines/v1/streams/{streamId}",
 }));
-export const ListStreamsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(Schema.Struct({
+export const GetStreamResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.String,
     createdAt: Schema.String,
     http: Schema.Struct({
@@ -2217,7 +1973,8 @@ export const ListStreamsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(Sche
         }),
         Schema.Null,
     ])),
-}).pipe(Schema.encodeKeys({
+})
+    .pipe(Schema.encodeKeys({
     id: "id",
     createdAt: "created_at",
     http: "http",
@@ -2228,11 +1985,302 @@ export const ListStreamsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(Sche
     endpoint: "endpoint",
     format: "format",
     schema: "schema",
-})));
-export const listStreams = API.make(() => ({
+}))
+    .pipe(T.ResponsePath("result"));
+export const getStream = API.make(() => ({
+    input: GetStreamRequest,
+    output: GetStreamResponse,
+    errors: [StreamNotFound, InvalidStreamId],
+}));
+export const ListStreamsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    pipelineId: Schema.optional(Schema.String).pipe(T.HttpQuery("pipeline_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/pipelines/v1/streams",
+}));
+export const ListStreamsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        createdAt: Schema.String,
+        http: Schema.Struct({
+            authentication: Schema.Boolean,
+            enabled: Schema.Boolean,
+            cors: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    origins: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                }),
+                Schema.Null,
+            ])),
+        }),
+        modifiedAt: Schema.String,
+        name: Schema.String,
+        version: Schema.Number,
+        workerBinding: Schema.Struct({
+            enabled: Schema.Boolean,
+        }),
+        endpoint: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        format: Schema.optional(Schema.Union([
+            Schema.Union([
+                Schema.Struct({
+                    type: Schema.Literal("json"),
+                    decimalEncoding: Schema.optional(Schema.Union([
+                        Schema.Literals(["number", "string", "bytes"]),
+                        Schema.Null,
+                    ])),
+                    timestampFormat: Schema.optional(Schema.Union([
+                        Schema.Literals(["rfc3339", "unix_millis"]),
+                        Schema.Null,
+                    ])),
+                    unstructured: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    type: "type",
+                    decimalEncoding: "decimal_encoding",
+                    timestampFormat: "timestamp_format",
+                    unstructured: "unstructured",
+                })),
+                Schema.Struct({
+                    type: Schema.Literal("parquet"),
+                    compression: Schema.optional(Schema.Union([
+                        Schema.Literals([
+                            "uncompressed",
+                            "snappy",
+                            "gzip",
+                            "zstd",
+                            "lz4",
+                        ]),
+                        Schema.Null,
+                    ])),
+                    rowGroupBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    type: "type",
+                    compression: "compression",
+                    rowGroupBytes: "row_group_bytes",
+                })),
+            ]),
+            Schema.Null,
+        ])),
+        schema: Schema.optional(Schema.Union([
+            Schema.Struct({
+                fields: Schema.optional(Schema.Union([
+                    Schema.Array(Schema.Union([
+                        Schema.Struct({
+                            type: Schema.Literal("int32"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("int64"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("float32"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("float64"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("bool"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("string"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("binary"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("timestamp"),
+                            metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            required: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                            sqlName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            unit: Schema.optional(Schema.Union([
+                                Schema.Literals([
+                                    "second",
+                                    "millisecond",
+                                    "microsecond",
+                                    "nanosecond",
+                                ]),
+                                Schema.Null,
+                            ])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            metadataKey: "metadata_key",
+                            name: "name",
+                            required: "required",
+                            sqlName: "sql_name",
+                            unit: "unit",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("json"),
+                            decimalEncoding: Schema.optional(Schema.Union([
+                                Schema.Literals(["number", "string", "bytes"]),
+                                Schema.Null,
+                            ])),
+                            timestampFormat: Schema.optional(Schema.Union([
+                                Schema.Literals(["rfc3339", "unix_millis"]),
+                                Schema.Null,
+                            ])),
+                            unstructured: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            decimalEncoding: "decimal_encoding",
+                            timestampFormat: "timestamp_format",
+                            unstructured: "unstructured",
+                        })),
+                        Schema.Unknown,
+                    ])),
+                    Schema.Null,
+                ])),
+                format: Schema.optional(Schema.Union([
+                    Schema.Union([
+                        Schema.Struct({
+                            type: Schema.Literal("json"),
+                            decimalEncoding: Schema.optional(Schema.Union([
+                                Schema.Literals(["number", "string", "bytes"]),
+                                Schema.Null,
+                            ])),
+                            timestampFormat: Schema.optional(Schema.Union([
+                                Schema.Literals(["rfc3339", "unix_millis"]),
+                                Schema.Null,
+                            ])),
+                            unstructured: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            decimalEncoding: "decimal_encoding",
+                            timestampFormat: "timestamp_format",
+                            unstructured: "unstructured",
+                        })),
+                        Schema.Struct({
+                            type: Schema.Literal("parquet"),
+                            compression: Schema.optional(Schema.Union([
+                                Schema.Literals([
+                                    "uncompressed",
+                                    "snappy",
+                                    "gzip",
+                                    "zstd",
+                                    "lz4",
+                                ]),
+                                Schema.Null,
+                            ])),
+                            rowGroupBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                        }).pipe(Schema.encodeKeys({
+                            type: "type",
+                            compression: "compression",
+                            rowGroupBytes: "row_group_bytes",
+                        })),
+                    ]),
+                    Schema.Null,
+                ])),
+                inferred: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            }),
+            Schema.Null,
+        ])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        createdAt: "created_at",
+        http: "http",
+        modifiedAt: "modified_at",
+        name: "name",
+        version: "version",
+        workerBinding: "worker_binding",
+        endpoint: "endpoint",
+        format: "format",
+        schema: "schema",
+    }))),
+    resultInfo: Schema.optional(Schema.Union([
+        Schema.Struct({
+            count: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            page: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            perPage: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            totalCount: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            count: "count",
+            page: "page",
+            perPage: "per_page",
+            totalCount: "total_count",
+        })),
+        Schema.Null,
+    ])),
+}).pipe(Schema.encodeKeys({ result: "result", resultInfo: "result_info" }));
+export const listStreams = API.makePaginated(() => ({
     input: ListStreamsRequest,
     output: ListStreamsResponse,
     errors: [],
+    pagination: {
+        mode: "page",
+        inputToken: "page",
+        outputToken: "resultInfo.page",
+        items: "result",
+        pageSize: "perPage",
+    },
 }));
 export const CreateStreamRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     accountId: Schema.String.pipe(T.HttpPath("account_id")),
@@ -2678,7 +2726,8 @@ export const CreateStreamResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
         }),
         Schema.Null,
     ])),
-}).pipe(Schema.encodeKeys({
+})
+    .pipe(Schema.encodeKeys({
     id: "id",
     createdAt: "created_at",
     http: "http",
@@ -2689,7 +2738,8 @@ export const CreateStreamResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     endpoint: "endpoint",
     format: "format",
     schema: "schema",
-}));
+}))
+    .pipe(T.ResponsePath("result"));
 export const createStream = API.make(() => ({
     input: CreateStreamRequest,
     output: CreateStreamResponse,
@@ -2772,7 +2822,8 @@ export const PatchStreamResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
         ]),
         Schema.Null,
     ])),
-}).pipe(Schema.encodeKeys({
+})
+    .pipe(Schema.encodeKeys({
     id: "id",
     createdAt: "created_at",
     http: "http",
@@ -2782,7 +2833,8 @@ export const PatchStreamResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     workerBinding: "worker_binding",
     endpoint: "endpoint",
     format: "format",
-}));
+}))
+    .pipe(T.ResponsePath("result"));
 export const patchStream = API.make(() => ({
     input: PatchStreamRequest,
     output: PatchStreamResponse,
@@ -2824,7 +2876,8 @@ export const GetV1PipelineResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
         type: Schema.Literals(["stream", "sink"]),
         version: Schema.Number,
     })),
-}).pipe(Schema.encodeKeys({
+})
+    .pipe(Schema.encodeKeys({
     id: "id",
     createdAt: "created_at",
     modifiedAt: "modified_at",
@@ -2832,7 +2885,8 @@ export const GetV1PipelineResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     sql: "sql",
     status: "status",
     tables: "tables",
-}));
+}))
+    .pipe(T.ResponsePath("result"));
 export const getV1Pipeline = API.make(() => ({
     input: GetV1PipelineRequest,
     output: GetV1PipelineResponse,
@@ -2844,25 +2898,48 @@ export const ListV1PipelineRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     method: "GET",
     path: "/accounts/{account_id}/pipelines/v1/pipelines",
 }));
-export const ListV1PipelineResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(Schema.Struct({
-    id: Schema.String,
-    createdAt: Schema.String,
-    modifiedAt: Schema.String,
-    name: Schema.String,
-    sql: Schema.String,
-    status: Schema.String,
-}).pipe(Schema.encodeKeys({
-    id: "id",
-    createdAt: "created_at",
-    modifiedAt: "modified_at",
-    name: "name",
-    sql: "sql",
-    status: "status",
-})));
-export const listV1Pipeline = API.make(() => ({
+export const ListV1PipelineResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        createdAt: Schema.String,
+        modifiedAt: Schema.String,
+        name: Schema.String,
+        sql: Schema.String,
+        status: Schema.String,
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        createdAt: "created_at",
+        modifiedAt: "modified_at",
+        name: "name",
+        sql: "sql",
+        status: "status",
+    }))),
+    resultInfo: Schema.optional(Schema.Union([
+        Schema.Struct({
+            count: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            page: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            perPage: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            totalCount: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            count: "count",
+            page: "page",
+            perPage: "per_page",
+            totalCount: "total_count",
+        })),
+        Schema.Null,
+    ])),
+}).pipe(Schema.encodeKeys({ result: "result", resultInfo: "result_info" }));
+export const listV1Pipeline = API.makePaginated(() => ({
     input: ListV1PipelineRequest,
     output: ListV1PipelineResponse,
     errors: [],
+    pagination: {
+        mode: "page",
+        inputToken: "page",
+        outputToken: "resultInfo.page",
+        items: "result",
+        pageSize: "perPage",
+    },
 }));
 export const CreateV1PipelineRequest = 
 /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
@@ -2881,14 +2958,16 @@ export const CreateV1PipelineResponse =
     name: Schema.String,
     sql: Schema.String,
     status: Schema.String,
-}).pipe(Schema.encodeKeys({
+})
+    .pipe(Schema.encodeKeys({
     id: "id",
     createdAt: "created_at",
     modifiedAt: "modified_at",
     name: "name",
     sql: "sql",
     status: "status",
-}));
+}))
+    .pipe(T.ResponsePath("result"));
 export const createV1Pipeline = API.make(() => ({
     input: CreateV1PipelineRequest,
     output: CreateV1PipelineResponse,