@distilled.cloud/cloudflare 0.0.0-john

package/lib/services/pipelines.js

@@ -0,0 +1,2991 @@
+/**
+ * Cloudflare PIPELINES API
+ *
+ * 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
+// =============================================================================
+export class InvalidSinkId extends Schema.TaggedErrorClass()("InvalidSinkId", { code: Schema.Number, message: Schema.String }) {
+}
+T.applyErrorMatchers(InvalidSinkId, [{ code: 2 }]);
+export class InvalidStreamId extends Schema.TaggedErrorClass()("InvalidStreamId", { code: Schema.Number, message: Schema.String }) {
+}
+T.applyErrorMatchers(InvalidStreamId, [{ code: 2 }]);
+export class InvalidStreamName extends Schema.TaggedErrorClass()("InvalidStreamName", { code: Schema.Number, message: Schema.String }) {
+}
+T.applyErrorMatchers(InvalidStreamName, [{ code: 2 }]);
+export class PipelineNotExists extends Schema.TaggedErrorClass()("PipelineNotExists", { code: Schema.Number, message: Schema.String }) {
+}
+T.applyErrorMatchers(PipelineNotExists, [{ code: 1000 }]);
+export class SinkNotFound extends Schema.TaggedErrorClass()("SinkNotFound", { code: Schema.Number, message: Schema.String }) {
+}
+T.applyErrorMatchers(SinkNotFound, [{ code: 1015 }]);
+export class StreamAlreadyExists extends Schema.TaggedErrorClass()("StreamAlreadyExists", { code: Schema.Number, message: Schema.String }) {
+}
+T.applyErrorMatchers(StreamAlreadyExists, [{ code: 1003 }]);
+export class StreamNotFound extends Schema.TaggedErrorClass()("StreamNotFound", { code: Schema.Number, message: Schema.String }) {
+}
+T.applyErrorMatchers(StreamNotFound, [{ code: 1016 }]);
+export class TableNotFound extends Schema.TaggedErrorClass()("TableNotFound", { code: Schema.Number, message: Schema.String }) {
+}
+T.applyErrorMatchers(TableNotFound, [{ code: 1014 }]);
+export const GetPipelineRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    pipelineName: Schema.String.pipe(T.HttpPath("pipelineName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/pipelines/{pipelineName}",
+}));
+export const GetPipelineResponse = /*@__PURE__*/ /*#__PURE__*/ 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"),
+            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,
+}).pipe(T.ResponsePath("result"));
+export const getPipeline = API.make(() => ({
+    input: GetPipelineRequest,
+    output: GetPipelineResponse,
+    errors: [PipelineNotExists],
+}));
+export const ListPipelinesRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    page: Schema.optional(Schema.String).pipe(T.HttpQuery("page")),
+    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.Struct({
+    resultInfo: Schema.optional(Schema.Union([
+        Schema.Struct({
+            count: Schema.Number,
+            page: Schema.Number,
+            perPage: Schema.Number,
+            totalCount: Schema.Number,
+        }).pipe(Schema.encodeKeys({
+            count: "count",
+            page: "page",
+            perPage: "per_page",
+            totalCount: "total_count",
+        })),
+        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"),
+                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,
+    })),
+    success: Schema.Boolean,
+}).pipe(Schema.encodeKeys({
+    resultInfo: "result_info",
+    results: "result",
+    success: "success",
+}));
+export const listPipelines = API.make(() => ({
+    input: ListPipelinesRequest,
+    output: ListPipelinesResponse,
+    errors: [],
+}));
+export const CreatePipelineRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    destination: Schema.Struct({
+        batch: Schema.Struct({
+            maxBytes: Schema.optional(Schema.Number),
+            maxDurationS: Schema.optional(Schema.Number),
+            maxRows: Schema.optional(Schema.Number),
+        }).pipe(Schema.encodeKeys({
+            maxBytes: "max_bytes",
+            maxDurationS: "max_duration_s",
+            maxRows: "max_rows",
+        })),
+        compression: Schema.Struct({
+            type: Schema.optional(Schema.Literals(["none", "gzip", "deflate"])),
+        }),
+        credentials: Schema.Struct({
+            accessKeyId: SensitiveString,
+            endpoint: Schema.String,
+            secretAccessKey: SensitiveString,
+        }).pipe(Schema.encodeKeys({
+            accessKeyId: "access_key_id",
+            endpoint: "endpoint",
+            secretAccessKey: "secret_access_key",
+        })),
+        format: Schema.Literal("json"),
+        path: Schema.Struct({
+            bucket: Schema.String,
+            filename: Schema.optional(Schema.String),
+            filepath: Schema.optional(Schema.String),
+            prefix: Schema.optional(Schema.String),
+        }),
+        type: Schema.Literal("r2"),
+    }),
+    name: Schema.String,
+    source: Schema.Array(Schema.Union([
+        Schema.Struct({
+            format: Schema.Literal("json"),
+            type: Schema.String,
+            authentication: Schema.optional(Schema.Boolean),
+            cors: Schema.optional(Schema.Struct({
+                origins: Schema.optional(Schema.Array(Schema.String)),
+            })),
+        }),
+        Schema.Struct({
+            format: Schema.Literal("json"),
+            type: Schema.String,
+        }),
+    ])),
+}).pipe(T.Http({ method: "POST", path: "/accounts/{account_id}/pipelines" }));
+export const CreatePipelineResponse = /*@__PURE__*/ /*#__PURE__*/ 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"),
+            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,
+}).pipe(T.ResponsePath("result"));
+export const createPipeline = API.make(() => ({
+    input: CreatePipelineRequest,
+    output: CreatePipelineResponse,
+    errors: [],
+}));
+export const UpdatePipelineRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    pipelineName: Schema.String.pipe(T.HttpPath("pipelineName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    destination: Schema.Struct({
+        batch: Schema.Struct({
+            maxBytes: Schema.optional(Schema.Number),
+            maxDurationS: Schema.optional(Schema.Number),
+            maxRows: Schema.optional(Schema.Number),
+        }).pipe(Schema.encodeKeys({
+            maxBytes: "max_bytes",
+            maxDurationS: "max_duration_s",
+            maxRows: "max_rows",
+        })),
+        compression: Schema.Struct({
+            type: Schema.optional(Schema.Literals(["none", "gzip", "deflate"])),
+        }),
+        format: Schema.Literal("json"),
+        path: Schema.Struct({
+            bucket: Schema.String,
+            filename: Schema.optional(Schema.String),
+            filepath: Schema.optional(Schema.String),
+            prefix: Schema.optional(Schema.String),
+        }),
+        type: Schema.Literal("r2"),
+        credentials: Schema.optional(Schema.Struct({
+            accessKeyId: SensitiveString,
+            endpoint: Schema.String,
+            secretAccessKey: SensitiveString,
+        }).pipe(Schema.encodeKeys({
+            accessKeyId: "access_key_id",
+            endpoint: "endpoint",
+            secretAccessKey: "secret_access_key",
+        }))),
+    }),
+    name: Schema.String,
+    source: Schema.Array(Schema.Union([
+        Schema.Struct({
+            format: Schema.Literal("json"),
+            type: Schema.String,
+            authentication: Schema.optional(Schema.Boolean),
+            cors: Schema.optional(Schema.Struct({
+                origins: Schema.optional(Schema.Array(Schema.String)),
+            })),
+        }),
+        Schema.Struct({
+            format: Schema.Literal("json"),
+            type: Schema.String,
+        }),
+    ])),
+}).pipe(T.Http({
+    method: "PUT",
+    path: "/accounts/{account_id}/pipelines/{pipelineName}",
+}));
+export const UpdatePipelineResponse = /*@__PURE__*/ /*#__PURE__*/ 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"),
+            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,
+}).pipe(T.ResponsePath("result"));
+export const updatePipeline = API.make(() => ({
+    input: UpdatePipelineRequest,
+    output: UpdatePipelineResponse,
+    errors: [PipelineNotExists],
+}));
+export const DeletePipelineRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    pipelineName: Schema.String.pipe(T.HttpPath("pipelineName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/pipelines/{pipelineName}",
+}));
+export const DeletePipelineResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
+export const deletePipeline = API.make(() => ({
+    input: DeletePipelineRequest,
+    output: DeletePipelineResponse,
+    errors: [PipelineNotExists],
+}));
+export const GetSinkRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    sinkId: Schema.String.pipe(T.HttpPath("sinkId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/pipelines/v1/sinks/{sinkId}",
+}));
+export const GetSinkResponse = /*@__PURE__*/ /*#__PURE__*/ 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({
+                    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])),
+                    }).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",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getSink = API.make(() => ({
+    input: GetSinkRequest,
+    output: GetSinkResponse,
+    errors: [SinkNotFound, InvalidSinkId],
+}));
+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.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({
+                        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])),
+                        }).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",
+    }))),
+    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 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: SensitiveString,
+                secretAccessKey: SensitiveString,
+            }).pipe(Schema.encodeKeys({
+                accessKeyId: "access_key_id",
+                secretAccessKey: "secret_access_key",
+            })),
+            fileNaming: Schema.optional(Schema.Struct({
+                prefix: Schema.optional(Schema.String),
+                strategy: Schema.optional(Schema.Literals(["serial", "uuid", "uuid_v7", "ulid"])),
+                suffix: Schema.optional(Schema.String),
+            })),
+            jurisdiction: Schema.optional(Schema.String),
+            partitioning: Schema.optional(Schema.Struct({
+                timePattern: Schema.optional(Schema.String),
+            }).pipe(Schema.encodeKeys({ timePattern: "time_pattern" }))),
+            path: Schema.optional(Schema.String),
+            rollingPolicy: Schema.optional(Schema.Struct({
+                fileSizeBytes: Schema.optional(Schema.Number),
+                inactivitySeconds: Schema.optional(Schema.Number),
+                intervalSeconds: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                fileSizeBytes: "file_size_bytes",
+                inactivitySeconds: "inactivity_seconds",
+                intervalSeconds: "interval_seconds",
+            }))),
+        }).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.String),
+            rollingPolicy: Schema.optional(Schema.Struct({
+                fileSizeBytes: Schema.optional(Schema.Number),
+                inactivitySeconds: Schema.optional(Schema.Number),
+                intervalSeconds: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                fileSizeBytes: "file_size_bytes",
+                inactivitySeconds: "inactivity_seconds",
+                intervalSeconds: "interval_seconds",
+            }))),
+        }).pipe(Schema.encodeKeys({
+            token: "token",
+            accountId: "account_id",
+            bucket: "bucket",
+            tableName: "table_name",
+            namespace: "namespace",
+            rollingPolicy: "rolling_policy",
+        })),
+    ])),
+    format: Schema.optional(Schema.Union([
+        Schema.Struct({
+            type: Schema.Literal("json"),
+            decimalEncoding: Schema.optional(Schema.Literals(["number", "string", "bytes"])),
+            timestampFormat: Schema.optional(Schema.Literals(["rfc3339", "unix_millis"])),
+            unstructured: Schema.optional(Schema.Boolean),
+        }).pipe(Schema.encodeKeys({
+            type: "type",
+            decimalEncoding: "decimal_encoding",
+            timestampFormat: "timestamp_format",
+            unstructured: "unstructured",
+        })),
+        Schema.Struct({
+            type: Schema.Literal("parquet"),
+            compression: Schema.optional(Schema.Literals(["uncompressed", "snappy", "gzip", "zstd", "lz4"])),
+            rowGroupBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            type: "type",
+            compression: "compression",
+            rowGroupBytes: "row_group_bytes",
+        })),
+    ])),
+    schema: Schema.optional(Schema.Struct({
+        fields: Schema.optional(Schema.Array(Schema.Union([
+            Schema.Struct({
+                type: Schema.Literal("int32"),
+                metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                name: Schema.optional(Schema.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+                unit: Schema.optional(Schema.Literals([
+                    "second",
+                    "millisecond",
+                    "microsecond",
+                    "nanosecond",
+                ])),
+            }).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.Literals(["number", "string", "bytes"])),
+                timestampFormat: Schema.optional(Schema.Literals(["rfc3339", "unix_millis"])),
+                unstructured: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                type: "type",
+                decimalEncoding: "decimal_encoding",
+                timestampFormat: "timestamp_format",
+                unstructured: "unstructured",
+            })),
+            Schema.Unknown,
+        ]))),
+        format: Schema.optional(Schema.Union([
+            Schema.Struct({
+                type: Schema.Literal("json"),
+                decimalEncoding: Schema.optional(Schema.Literals(["number", "string", "bytes"])),
+                timestampFormat: Schema.optional(Schema.Literals(["rfc3339", "unix_millis"])),
+                unstructured: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                type: "type",
+                decimalEncoding: "decimal_encoding",
+                timestampFormat: "timestamp_format",
+                unstructured: "unstructured",
+            })),
+            Schema.Struct({
+                type: Schema.Literal("parquet"),
+                compression: Schema.optional(Schema.Literals([
+                    "uncompressed",
+                    "snappy",
+                    "gzip",
+                    "zstd",
+                    "lz4",
+                ])),
+                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])),
+    })),
+}).pipe(T.Http({ method: "POST", path: "/accounts/{account_id}/pipelines/v1/sinks" }));
+export const CreateSinkResponse = /*@__PURE__*/ /*#__PURE__*/ 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({
+                    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])),
+                    }).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",
+}))
+    .pipe(T.ResponsePath("result"));
+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,
+            }).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")),
+}).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({
+                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",
+}))
+    .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")),
+    name: Schema.String,
+    format: Schema.optional(Schema.Union([
+        Schema.Struct({
+            type: Schema.Literal("json"),
+            decimalEncoding: Schema.optional(Schema.Literals(["number", "string", "bytes"])),
+            timestampFormat: Schema.optional(Schema.Literals(["rfc3339", "unix_millis"])),
+            unstructured: Schema.optional(Schema.Boolean),
+        }).pipe(Schema.encodeKeys({
+            type: "type",
+            decimalEncoding: "decimal_encoding",
+            timestampFormat: "timestamp_format",
+            unstructured: "unstructured",
+        })),
+        Schema.Struct({
+            type: Schema.Literal("parquet"),
+            compression: Schema.optional(Schema.Literals(["uncompressed", "snappy", "gzip", "zstd", "lz4"])),
+            rowGroupBytes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            type: "type",
+            compression: "compression",
+            rowGroupBytes: "row_group_bytes",
+        })),
+    ])),
+    http: Schema.optional(Schema.Struct({
+        authentication: Schema.Boolean,
+        enabled: Schema.Boolean,
+        cors: Schema.optional(Schema.Struct({
+            origins: Schema.optional(Schema.Array(Schema.String)),
+        })),
+    })),
+    schema: Schema.optional(Schema.Struct({
+        fields: Schema.optional(Schema.Array(Schema.Union([
+            Schema.Struct({
+                type: Schema.Literal("int32"),
+                metadataKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                name: Schema.optional(Schema.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+            }).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.String),
+                required: Schema.optional(Schema.Boolean),
+                sqlName: Schema.optional(Schema.String),
+                unit: Schema.optional(Schema.Literals([
+                    "second",
+                    "millisecond",
+                    "microsecond",
+                    "nanosecond",
+                ])),
+            }).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.Literals(["number", "string", "bytes"])),
+                timestampFormat: Schema.optional(Schema.Literals(["rfc3339", "unix_millis"])),
+                unstructured: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                type: "type",
+                decimalEncoding: "decimal_encoding",
+                timestampFormat: "timestamp_format",
+                unstructured: "unstructured",
+            })),
+            Schema.Unknown,
+        ]))),
+        format: Schema.optional(Schema.Union([
+            Schema.Struct({
+                type: Schema.Literal("json"),
+                decimalEncoding: Schema.optional(Schema.Literals(["number", "string", "bytes"])),
+                timestampFormat: Schema.optional(Schema.Literals(["rfc3339", "unix_millis"])),
+                unstructured: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                type: "type",
+                decimalEncoding: "decimal_encoding",
+                timestampFormat: "timestamp_format",
+                unstructured: "unstructured",
+            })),
+            Schema.Struct({
+                type: Schema.Literal("parquet"),
+                compression: Schema.optional(Schema.Literals([
+                    "uncompressed",
+                    "snappy",
+                    "gzip",
+                    "zstd",
+                    "lz4",
+                ])),
+                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])),
+    })),
+    workerBinding: Schema.optional(Schema.Struct({
+        enabled: Schema.Boolean,
+    })),
+}).pipe(Schema.encodeKeys({
+    name: "name",
+    format: "format",
+    http: "http",
+    schema: "schema",
+    workerBinding: "worker_binding",
+}), T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/pipelines/v1/streams",
+}));
+export const CreateStreamResponse = /*@__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({
+                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",
+}))
+    .pipe(T.ResponsePath("result"));
+export const createStream = API.make(() => ({
+    input: CreateStreamRequest,
+    output: CreateStreamResponse,
+    errors: [InvalidStreamName, StreamAlreadyExists],
+}));
+export const PatchStreamRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    streamId: Schema.String.pipe(T.HttpPath("streamId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    http: Schema.optional(Schema.Struct({
+        authentication: Schema.Boolean,
+        enabled: Schema.Boolean,
+        cors: Schema.optional(Schema.Struct({
+            origins: Schema.optional(Schema.Array(Schema.String)),
+        })),
+    })),
+    workerBinding: Schema.optional(Schema.Struct({
+        enabled: Schema.Boolean,
+    })),
+}).pipe(Schema.encodeKeys({ http: "http", workerBinding: "worker_binding" }), T.Http({
+    method: "PATCH",
+    path: "/accounts/{account_id}/pipelines/v1/streams/{streamId}",
+}));
+export const PatchStreamResponse = /*@__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({
+                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,
+    ])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    createdAt: "created_at",
+    http: "http",
+    modifiedAt: "modified_at",
+    name: "name",
+    version: "version",
+    workerBinding: "worker_binding",
+    endpoint: "endpoint",
+    format: "format",
+}))
+    .pipe(T.ResponsePath("result"));
+export const patchStream = API.make(() => ({
+    input: PatchStreamRequest,
+    output: PatchStreamResponse,
+    errors: [StreamNotFound],
+}));
+export const DeleteStreamRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    streamId: Schema.String.pipe(T.HttpPath("streamId")),
+    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/streams/{streamId}",
+}));
+export const DeleteStreamResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
+export const deleteStream = API.make(() => ({
+    input: DeleteStreamRequest,
+    output: DeleteStreamResponse,
+    errors: [PipelineNotExists],
+}));
+export const GetV1PipelineRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    pipelineId: Schema.String.pipe(T.HttpPath("pipelineId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/pipelines/v1/pipelines/{pipelineId}",
+}));
+export const GetV1PipelineResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    createdAt: Schema.String,
+    modifiedAt: Schema.String,
+    name: Schema.String,
+    sql: Schema.String,
+    status: Schema.String,
+    tables: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        latest: Schema.Number,
+        name: Schema.String,
+        type: Schema.Literals(["stream", "sink"]),
+        version: Schema.Number,
+    })),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    createdAt: "created_at",
+    modifiedAt: "modified_at",
+    name: "name",
+    sql: "sql",
+    status: "status",
+    tables: "tables",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getV1Pipeline = API.make(() => ({
+    input: GetV1PipelineRequest,
+    output: GetV1PipelineResponse,
+    errors: [],
+}));
+export const ListV1PipelineRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/pipelines/v1/pipelines",
+}));
+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({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    name: Schema.String,
+    sql: Schema.String,
+}).pipe(T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/pipelines/v1/pipelines",
+}));
+export const CreateV1PipelineResponse = 
+/*@__PURE__*/ /*#__PURE__*/ 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",
+}))
+    .pipe(T.ResponsePath("result"));
+export const createV1Pipeline = API.make(() => ({
+    input: CreateV1PipelineRequest,
+    output: CreateV1PipelineResponse,
+    errors: [],
+}));
+export const DeleteV1PipelineRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    pipelineId: Schema.String.pipe(T.HttpPath("pipelineId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/pipelines/v1/pipelines/{pipelineId}",
+}));
+export const DeleteV1PipelineResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
+export const deleteV1Pipeline = API.make(() => ({
+    input: DeleteV1PipelineRequest,
+    output: DeleteV1PipelineResponse,
+    errors: [],
+}));
+//# sourceMappingURL=pipelines.js.map