@keystrokehq/snowflake 0.0.1

package/dist/sql.mjs

@@ -0,0 +1,209 @@
+import { n as SnowflakeSqlError, t as SnowflakeApiError } from "./errors-DKnc9o_a.mjs";
+import { a as submitStatementInputSchema, n as statementResponseSchema, o as partitionResponseSchema, r as statementStatus } from "./statements-B2ThF_4b.mjs";
+import { hydrateRows } from "./results.mjs";
+
+//#region src/sql.ts
+const STATEMENTS_PATH = "/api/v2/statements";
+/**
+* Submit a statement. When `async: true` (or the server chooses async) we
+* return the inflated response envelope along with the `pending` status so
+* callers can poll via {@link getStatement} / {@link waitForStatement}.
+*
+* The SQL API itself keys idempotency on the `requestId` query param which
+* {@link SnowflakeClient} auto-populates — callers can override it per
+* request when they need deterministic retries.
+*/
+async function submitStatement(client, input, options = {}) {
+	const parsed = submitStatementInputSchema.parse(input);
+	const query = {};
+	if (options.async) query.async = true;
+	const response = await client.requestRaw(STATEMENTS_PATH, {
+		method: "POST",
+		body: parsed,
+		query,
+		requestId: options.requestId
+	});
+	const body = await response.json();
+	const envelope = statementResponseSchema.parse(body);
+	return {
+		response: envelope,
+		httpStatus: response.status,
+		status: statementStatus({
+			httpStatus: response.status,
+			code: envelope.code
+		})
+	};
+}
+/**
+* Fetch the current status of a previously submitted async statement. Returns
+* both the envelope and the derived `status` bucket.
+*/
+async function getStatement(client, handle, options = {}) {
+	const query = options.partition !== void 0 ? { partition: options.partition } : void 0;
+	const response = await client.requestRaw(`${STATEMENTS_PATH}/${encodeURIComponent(handle)}`, {
+		method: "GET",
+		query
+	});
+	const body = await response.json();
+	const envelope = statementResponseSchema.parse(body);
+	return {
+		response: envelope,
+		httpStatus: response.status,
+		status: statementStatus({
+			httpStatus: response.status,
+			code: envelope.code
+		})
+	};
+}
+/**
+* POST `/cancel`. Snowflake responds with `code: 333335` on success — we
+* normalise anything else into a {@link SnowflakeApiError}.
+*/
+async function cancelStatement(client, handle) {
+	const response = await client.requestRaw(`${STATEMENTS_PATH}/${encodeURIComponent(handle)}/cancel`, {
+		method: "POST",
+		retry: false
+	});
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		throw new SnowflakeApiError({
+			kind: "http",
+			status: response.status,
+			message: `Failed to cancel statement ${handle}: ${text || response.statusText}`
+		});
+	}
+}
+/**
+* Submit + wait + fetch all partitions in one go. The returned rows are
+* hydrated into objects keyed by column name by default; pass
+* `hydrate: false` to get the raw tuple form.
+*/
+async function executeSql(client, input, options = {}) {
+	const submitted = await submitStatement(client, input, options);
+	let envelope = submitted.response;
+	let status = submitted.status;
+	if (status === "pending") {
+		envelope = await waitForStatementEnvelope(client, envelope.statementHandle, options);
+		status = statementStatus({
+			httpStatus: 200,
+			code: envelope.code
+		});
+	}
+	if (status === "cancelled") throw new SnowflakeSqlError({
+		kind: "cancelled",
+		status: 200,
+		message: envelope.message ?? "Statement was cancelled",
+		code: envelope.code,
+		sqlState: envelope.sqlState,
+		statementHandle: envelope.statementHandle
+	});
+	if (status === "failed") throw new SnowflakeSqlError({
+		kind: "sql",
+		status: 422,
+		message: envelope.message ?? "Statement failed",
+		code: envelope.code,
+		sqlState: envelope.sqlState,
+		statementHandle: envelope.statementHandle
+	});
+	const columns = envelope.resultSetMetaData?.rowType ?? [];
+	const partitionCount = envelope.resultSetMetaData?.partitionInfo?.length ?? (envelope.data ? 1 : 0);
+	const firstRows = envelope.data ?? [];
+	const remainder = [];
+	for (let i = 1; i < partitionCount; i += 1) {
+		const partition = await getStatementResultPartition(client, envelope.statementHandle, i);
+		remainder.push(...partition.data ?? []);
+	}
+	const rawRows = [...firstRows, ...remainder];
+	const rows = options.hydrate !== false ? hydrateRows(rawRows, columns) : rawRows;
+	return {
+		handle: envelope.statementHandle,
+		columns,
+		rows,
+		envelope,
+		partitions: Math.max(1, partitionCount)
+	};
+}
+/**
+* Composio `SNOWFLAKE_BASIC_RUN_QUERY` parity — requires an explicit
+* database + schema to match the published BASIC shape.
+*/
+async function runQuery(client, input, options = {}) {
+	return executeSql(client, {
+		statement: input.statement,
+		database: input.database,
+		schema: input.schema_name,
+		warehouse: input.warehouse,
+		role: input.role
+	}, options);
+}
+/**
+* Fetch a single partition for a known handle.
+*/
+async function getStatementResultPartition(client, handle, partition) {
+	const body = await client.request(`${STATEMENTS_PATH}/${encodeURIComponent(handle)}`, {
+		method: "GET",
+		query: { partition }
+	});
+	return partitionResponseSchema.parse(body);
+}
+/**
+* Async iterator over every partition for a handle. Useful for streaming
+* large result sets into downstream pipelines.
+*/
+async function* iterateStatementResult(client, handle, options = {}) {
+	const first = await getStatementResultPartition(client, handle, 0);
+	yield first;
+	const total = first.resultSetMetaData?.partitionInfo?.length ?? 0;
+	const cap = Math.min(total, options.maxPartitions ?? total);
+	for (let i = 1; i < cap; i += 1) yield await getStatementResultPartition(client, handle, i);
+}
+async function waitForStatementEnvelope(client, handle, options) {
+	const pollIntervalMs = options.pollIntervalMs ?? 500;
+	const maxWaitMs = options.maxWaitMs ?? 300 * 1e3;
+	const now = options.now ?? (() => Date.now());
+	const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const deadline = now() + maxWaitMs;
+	for (;;) {
+		const result = await getStatement(client, handle);
+		if (result.status !== "pending") return result.response;
+		if (now() >= deadline) throw new SnowflakeApiError({
+			kind: "timeout",
+			status: 0,
+			message: `Statement ${handle} did not reach a terminal status within ${maxWaitMs}ms`,
+			retryable: false
+		});
+		await sleep(pollIntervalMs);
+	}
+}
+/**
+* Blocking helper: polls `getStatement` until the statement reaches a
+* terminal status or the `maxWaitMs` budget elapses. Returns the terminal
+* envelope (throws for `failed` / `cancelled`).
+*/
+async function waitForStatement(client, handle, options = {}) {
+	const envelope = await waitForStatementEnvelope(client, handle, options);
+	const status = statementStatus({
+		httpStatus: 200,
+		code: envelope.code
+	});
+	if (status === "failed") throw new SnowflakeSqlError({
+		kind: "sql",
+		status: 422,
+		message: envelope.message ?? "Statement failed",
+		code: envelope.code,
+		sqlState: envelope.sqlState,
+		statementHandle: envelope.statementHandle
+	});
+	if (status === "cancelled") throw new SnowflakeSqlError({
+		kind: "cancelled",
+		status: 200,
+		message: envelope.message ?? "Statement was cancelled",
+		code: envelope.code,
+		sqlState: envelope.sqlState,
+		statementHandle: envelope.statementHandle
+	});
+	return envelope;
+}
+
+//#endregion
+export { cancelStatement, executeSql, getStatement, getStatementResultPartition, iterateStatementResult, runQuery, submitStatement, waitForStatement };

package/dist/stages.d.mts

@@ -0,0 +1,64 @@
+import { SnowflakeClient } from "./client.mjs";
+import { d as HydratedRow } from "./statements-DJL0qVNA.mjs";
+import { ExecuteSqlResult } from "./sql.mjs";
+import { t as OptionMap } from "./sql-options-2k5xQ-oS.mjs";
+import { CatalogResult, ShowScopedOptions, showStages } from "./catalog.mjs";
+
+//#region src/stages.d.ts
+interface StageRef {
+  readonly database?: string;
+  readonly schema?: string;
+  readonly name: string;
+}
+interface StageContext {
+  readonly warehouse?: string;
+  readonly role?: string;
+}
+/** `@<fqn>` form used inside LIST / REMOVE / COPY INTO commands. */
+declare function stagePath(ref: StageRef, pathSuffix?: string): string;
+interface CreateStageOptions extends StageRef, StageContext {
+  readonly orReplace?: boolean;
+  readonly ifNotExists?: boolean;
+  readonly temporary?: boolean;
+  /** `URL='...'`, `STORAGE_INTEGRATION='...'`, `CREDENTIALS=(...)`, `ENCRYPTION=(...)`, etc. */
+  readonly options?: OptionMap;
+  readonly fileFormat?: OptionMap;
+  readonly copyOptions?: OptionMap;
+  readonly comment?: string;
+}
+declare function createStage(client: SnowflakeClient, options: CreateStageOptions): Promise<void>;
+interface AlterStageOptions extends StageRef, StageContext {
+  readonly rename?: StageRef;
+  readonly set?: OptionMap;
+  readonly unset?: readonly string[];
+  readonly refreshSubpath?: string;
+  readonly comment?: string;
+}
+declare function alterStage(client: SnowflakeClient, options: AlterStageOptions): Promise<void>;
+interface DropStageOptions extends StageRef, StageContext {
+  readonly ifExists?: boolean;
+}
+declare function dropStage(client: SnowflakeClient, options: DropStageOptions): Promise<void>;
+interface DescribeStageOptions extends StageRef, StageContext {}
+declare function describeStage(client: SnowflakeClient, options: DescribeStageOptions): Promise<readonly HydratedRow[]>;
+interface ListStageFilesOptions extends StageRef, StageContext {
+  readonly pathSuffix?: string;
+  /** Regex pattern matched against file names. */
+  readonly pattern?: string;
+}
+declare function listStageFiles(client: SnowflakeClient, options: ListStageFilesOptions): Promise<readonly HydratedRow[]>;
+interface RemoveStageFilesOptions extends StageRef, StageContext {
+  readonly pathSuffix?: string;
+  readonly pattern?: string;
+}
+declare function removeStageFiles(client: SnowflakeClient, options: RemoveStageFilesOptions): Promise<ExecuteSqlResult<HydratedRow | readonly unknown[]>>;
+/**
+ * PUT is not supported by the Snowflake SQL API v2 — the API cannot accept
+ * raw file bytes. Callers needing a file upload should use a pre-signed S3
+ * URL + external stage, or drive `snowsql`/`snowflake-sdk` from a trusted
+ * context.
+ */
+declare function putFile(): never;
+declare function getFile(): never;
+//#endregion
+export { AlterStageOptions, type CatalogResult, CreateStageOptions, DescribeStageOptions, DropStageOptions, ListStageFilesOptions, RemoveStageFilesOptions, type ShowScopedOptions, StageContext, StageRef, alterStage, createStage, describeStage, dropStage, getFile, listStageFiles, putFile, removeStageFiles, showStages, stagePath };

package/dist/stages.mjs

@@ -0,0 +1,81 @@
+import { executeSql } from "./sql.mjs";
+import { a as quoteLiteral, t as buildFqn } from "./sql-safety-CywdR3EP.mjs";
+import { n as renderOptionGroup, t as formatOptions } from "./sql-options-DI-OmLU6.mjs";
+import { showStages } from "./catalog.mjs";
+
+//#region src/stages.ts
+function stageFqn(ref) {
+	return buildFqn(ref.database, ref.schema, ref.name);
+}
+/** `@<fqn>` form used inside LIST / REMOVE / COPY INTO commands. */
+function stagePath(ref, pathSuffix) {
+	const fqn = stageFqn(ref);
+	if (!pathSuffix) return `@${fqn}`;
+	return `@${fqn}${pathSuffix.startsWith("/") ? pathSuffix : `/${pathSuffix}`}`;
+}
+async function createStage(client, options) {
+	const prefix = `CREATE${options.orReplace ? " OR REPLACE" : ""}${options.temporary ? " TEMPORARY" : ""} STAGE${options.ifNotExists ? " IF NOT EXISTS" : ""}`;
+	const topOptions = options.options ? ` ${formatOptions(options.options)}` : "";
+	await executeSql(client, {
+		statement: `${prefix} ${stageFqn(options)}${topOptions}` + renderOptionGroup("FILE_FORMAT", options.fileFormat) + renderOptionGroup("COPY_OPTIONS", options.copyOptions) + (options.comment ? ` COMMENT = ${quoteLiteral(options.comment)}` : ""),
+		warehouse: options.warehouse,
+		role: options.role
+	});
+}
+async function alterStage(client, options) {
+	let tail;
+	if (options.rename) tail = `RENAME TO ${stageFqn(options.rename)}`;
+	else if (options.refreshSubpath !== void 0) tail = `REFRESH${options.refreshSubpath.length > 0 ? ` SUBPATH = ${quoteLiteral(options.refreshSubpath)}` : ""}`;
+	else if (options.set && Object.keys(options.set).length > 0) tail = `SET ${formatOptions(options.set)}`;
+	else if (options.unset && options.unset.length > 0) tail = `UNSET ${options.unset.map((k) => k.toUpperCase()).join(", ")}`;
+	else if (options.comment !== void 0) tail = `SET COMMENT = ${quoteLiteral(options.comment)}`;
+	else throw new Error("alterStage requires one of: rename / refreshSubpath / set / unset / comment");
+	await executeSql(client, {
+		statement: `ALTER STAGE ${stageFqn(options)} ${tail}`,
+		warehouse: options.warehouse,
+		role: options.role
+	});
+}
+async function dropStage(client, options) {
+	await executeSql(client, {
+		statement: `DROP STAGE${options.ifExists ? " IF EXISTS" : ""} ${stageFqn(options)}`,
+		warehouse: options.warehouse,
+		role: options.role
+	});
+}
+async function describeStage(client, options) {
+	return (await executeSql(client, {
+		statement: `DESCRIBE STAGE ${stageFqn(options)}`,
+		warehouse: options.warehouse,
+		role: options.role
+	})).rows;
+}
+async function listStageFiles(client, options) {
+	return (await executeSql(client, {
+		statement: `LIST ${stagePath(options, options.pathSuffix)}${options.pattern ? ` PATTERN = ${quoteLiteral(options.pattern)}` : ""}`,
+		warehouse: options.warehouse,
+		role: options.role
+	})).rows;
+}
+async function removeStageFiles(client, options) {
+	return executeSql(client, {
+		statement: `REMOVE ${stagePath(options, options.pathSuffix)}${options.pattern ? ` PATTERN = ${quoteLiteral(options.pattern)}` : ""}`,
+		warehouse: options.warehouse,
+		role: options.role
+	});
+}
+/**
+* PUT is not supported by the Snowflake SQL API v2 — the API cannot accept
+* raw file bytes. Callers needing a file upload should use a pre-signed S3
+* URL + external stage, or drive `snowsql`/`snowflake-sdk` from a trusted
+* context.
+*/
+function putFile() {
+	throw new Error("putFile is not supported by the REST integration — use a pre-signed stage URL or the official Snowflake driver to upload raw file bytes.");
+}
+function getFile() {
+	throw new Error("getFile is not supported by the REST integration — use a pre-signed stage URL or the official Snowflake driver to download raw file bytes.");
+}
+
+//#endregion
+export { alterStage, createStage, describeStage, dropStage, getFile, listStageFiles, putFile, removeStageFiles, showStages, stagePath };

package/dist/statements-B2ThF_4b.mjs

@@ -0,0 +1,81 @@
+import { c as sqlBindingsSchema, l as statementContextSchema, r as resultSetMetaDataSchema } from "./common-BnKTPQXc.mjs";
+import { z } from "zod";
+
+//#region src/schemas/results.ts
+/**
+* Result-partition + row hydration schemas.
+*
+* A single partition response arrives under `GET /api/v2/statements/{handle}?partition={n}`
+* and uses the same envelope as the submit response — just with `data`
+* populated with the rows for that partition.
+*/
+const partitionResponseSchema = z.object({
+	statementHandle: z.string().optional(),
+	code: z.string().optional(),
+	message: z.string().optional(),
+	resultSetMetaData: resultSetMetaDataSchema.optional(),
+	data: z.array(z.array(z.unknown())).optional()
+}).catchall(z.unknown());
+
+//#endregion
+//#region src/schemas/statements.ts
+/**
+* Schemas for the Snowflake SQL API v2 statement endpoints.
+*
+* https://docs.snowflake.com/en/developer-guide/sql-api/submitting-requests
+* https://docs.snowflake.com/en/developer-guide/sql-api/responses-errors
+*/
+/** Status code reported under `code` / `message` alongside the HTTP status. */
+const statementStatusCodeSchema = z.string();
+/**
+* Input body for `POST /api/v2/statements`.
+* `statement` is required. All other fields fall back to session / account
+* defaults when omitted.
+*/
+const submitStatementInputSchema = z.object({
+	statement: z.string().min(1),
+	bindings: sqlBindingsSchema.optional()
+}).merge(statementContextSchema).strict();
+/**
+* Response body for a submitted statement — either the inline result (200)
+* or a pending handle (202).
+*/
+const statementResponseSchema = z.object({
+	code: statementStatusCodeSchema.optional(),
+	sqlState: z.string().optional(),
+	message: z.string().optional(),
+	statementHandle: z.string(),
+	statementStatusUrl: z.string().optional(),
+	createdOn: z.number().optional(),
+	requestId: z.string().optional(),
+	statementHandles: z.array(z.string()).optional(),
+	resultSetMetaData: resultSetMetaDataSchema.optional(),
+	data: z.array(z.array(z.unknown())).optional()
+}).catchall(z.unknown());
+/**
+* Snowflake code ranges (SQL API v2):
+*  - 090002 — success (inline result)
+*  - 333333 — statement accepted (async)
+*  - 333334 — statement executing (still polling)
+*  - 333335 — user-triggered cancel succeeded
+*  - 390xxx / 3900xx / 0919xx / ... — SQL-level failures
+*
+* We map explicitly the two non-error status codes; everything else is
+* treated as `failed` when the HTTP status is also an error, otherwise
+* `done`.
+*/
+function statementStatus(input) {
+	if (input.httpStatus === 202) return "pending";
+	if (input.code === "333334" || input.code === "333333") return "pending";
+	if (input.code === "333335") return "cancelled";
+	if (input.httpStatus >= 400) return "failed";
+	return "done";
+}
+const cancelStatementResponseSchema = z.object({
+	code: z.string().optional(),
+	message: z.string().optional(),
+	statementHandle: z.string().optional()
+}).catchall(z.unknown());
+
+//#endregion
+export { submitStatementInputSchema as a, statementStatusCodeSchema as i, statementResponseSchema as n, partitionResponseSchema as o, statementStatus as r, cancelStatementResponseSchema as t };

package/dist/statements-DJL0qVNA.d.mts

@@ -0,0 +1,238 @@
+import { z } from "zod";
+
+//#region src/schemas/common.d.ts
+/**
+ * Snowflake identifiers are 1-255 chars. Unquoted identifiers are normalized
+ * to upper-case; quoted identifiers preserve case. We keep raw validation
+ * permissive and let the server reject bad names — a strict regex would
+ * forbid unicode-quoted identifiers legitimately used in the wild.
+ */
+declare const snowflakeIdentifier: z.ZodString;
+/**
+ * Fully-qualified name: `DATABASE.SCHEMA.NAME` (or subsets). Stored as a
+ * single string; we do *not* split/rejoin so callers can pass quoted
+ * segments through verbatim.
+ */
+declare const snowflakeFqn: z.ZodString;
+/**
+ * Optional context overrides applied per-statement.
+ * Every field is optional — absent values fall back to the connection's
+ * session defaults and then to account-level defaults.
+ */
+declare const statementContextSchema: z.ZodObject<{
+  database: z.ZodOptional<z.ZodString>;
+  schema: z.ZodOptional<z.ZodString>;
+  warehouse: z.ZodOptional<z.ZodString>;
+  role: z.ZodOptional<z.ZodString>;
+  timeout: z.ZodOptional<z.ZodNumber>;
+  parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+type StatementContext = z.infer<typeof statementContextSchema>;
+/**
+ * SQL API v2 supports typed bindings: each binding is an object with a
+ * `type` and a `value`. We allow the simple positional shape and the
+ * keyed-map shape Snowflake accepts.
+ */
+declare const sqlBindingValueSchema: z.ZodObject<{
+  type: z.ZodString;
+  value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strip>;
+declare const sqlBindingsSchema: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodObject<{
+  type: z.ZodString;
+  value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+  type: z.ZodString;
+  value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strip>>]>;
+type SqlBinding = z.infer<typeof sqlBindingValueSchema>;
+type SqlBindings = z.infer<typeof sqlBindingsSchema>;
+/**
+ * Loosely-typed record shape for objects returned by `SHOW ...` commands.
+ * Snowflake returns positional arrays with a `rowType[]` describing each
+ * column — callers either consume the tuple form directly or `hydrateRow`
+ * into a `Record<string, unknown>`.
+ */
+declare const snowflakeObjectRowSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+type SnowflakeObjectRow = z.infer<typeof snowflakeObjectRowSchema>;
+/**
+ * Column metadata entry as returned under `resultSetMetaData.rowType`.
+ */
+declare const columnMetaSchema: z.ZodObject<{
+  name: z.ZodString;
+  type: z.ZodString;
+  nullable: z.ZodOptional<z.ZodBoolean>;
+  length: z.ZodOptional<z.ZodNumber>;
+  precision: z.ZodOptional<z.ZodNumber>;
+  scale: z.ZodOptional<z.ZodNumber>;
+  byteLength: z.ZodOptional<z.ZodNumber>;
+  collation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  database: z.ZodOptional<z.ZodString>;
+  schema: z.ZodOptional<z.ZodString>;
+  table: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodUnknown>>;
+type ColumnMeta = z.infer<typeof columnMetaSchema>;
+/**
+ * Partition entry describing a shard of the total result set.
+ */
+declare const partitionInfoSchema: z.ZodObject<{
+  rowCount: z.ZodNumber;
+  uncompressedSize: z.ZodOptional<z.ZodNumber>;
+  compressedSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$catchall<z.ZodUnknown>>;
+type PartitionInfo = z.infer<typeof partitionInfoSchema>;
+declare const resultSetMetaDataSchema: z.ZodObject<{
+  numRows: z.ZodOptional<z.ZodNumber>;
+  format: z.ZodOptional<z.ZodString>;
+  partitionInfo: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    rowCount: z.ZodNumber;
+    uncompressedSize: z.ZodOptional<z.ZodNumber>;
+    compressedSize: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$catchall<z.ZodUnknown>>>>;
+  rowType: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    nullable: z.ZodOptional<z.ZodBoolean>;
+    length: z.ZodOptional<z.ZodNumber>;
+    precision: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodNumber>;
+    byteLength: z.ZodOptional<z.ZodNumber>;
+    collation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    database: z.ZodOptional<z.ZodString>;
+    schema: z.ZodOptional<z.ZodString>;
+    table: z.ZodOptional<z.ZodString>;
+  }, z.core.$catchall<z.ZodUnknown>>>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+type ResultSetMetaData = z.infer<typeof resultSetMetaDataSchema>;
+//#endregion
+//#region src/schemas/results.d.ts
+declare const partitionResponseSchema: z.ZodObject<{
+  statementHandle: z.ZodOptional<z.ZodString>;
+  code: z.ZodOptional<z.ZodString>;
+  message: z.ZodOptional<z.ZodString>;
+  resultSetMetaData: z.ZodOptional<z.ZodObject<{
+    numRows: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodOptional<z.ZodString>;
+    partitionInfo: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      rowCount: z.ZodNumber;
+      uncompressedSize: z.ZodOptional<z.ZodNumber>;
+      compressedSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodUnknown>>>>;
+    rowType: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      type: z.ZodString;
+      nullable: z.ZodOptional<z.ZodBoolean>;
+      length: z.ZodOptional<z.ZodNumber>;
+      precision: z.ZodOptional<z.ZodNumber>;
+      scale: z.ZodOptional<z.ZodNumber>;
+      byteLength: z.ZodOptional<z.ZodNumber>;
+      collation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      database: z.ZodOptional<z.ZodString>;
+      schema: z.ZodOptional<z.ZodString>;
+      table: z.ZodOptional<z.ZodString>;
+    }, z.core.$catchall<z.ZodUnknown>>>>;
+  }, z.core.$catchall<z.ZodUnknown>>>;
+  data: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodUnknown>>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+type PartitionResponse = z.infer<typeof partitionResponseSchema>;
+/**
+ * A single logical row as hydrated into an object keyed by column name.
+ * Values are permissive (`unknown`) because Snowflake types map to many
+ * TS shapes — callers coerce further with `hydrateValue` when needed.
+ */
+type HydratedRow = Record<string, unknown>;
+//#endregion
+//#region src/schemas/statements.d.ts
+/** Status code reported under `code` / `message` alongside the HTTP status. */
+declare const statementStatusCodeSchema: z.ZodString;
+/**
+ * Input body for `POST /api/v2/statements`.
+ * `statement` is required. All other fields fall back to session / account
+ * defaults when omitted.
+ */
+declare const submitStatementInputSchema: z.ZodObject<{
+  statement: z.ZodString;
+  bindings: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+  }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+    type: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+  }, z.core.$strip>>]>>;
+  database: z.ZodOptional<z.ZodString>;
+  schema: z.ZodOptional<z.ZodString>;
+  warehouse: z.ZodOptional<z.ZodString>;
+  role: z.ZodOptional<z.ZodString>;
+  timeout: z.ZodOptional<z.ZodNumber>;
+  parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+type SubmitStatementInput = z.infer<typeof submitStatementInputSchema>;
+/**
+ * Response body for a submitted statement — either the inline result (200)
+ * or a pending handle (202).
+ */
+declare const statementResponseSchema: z.ZodObject<{
+  code: z.ZodOptional<z.ZodString>;
+  sqlState: z.ZodOptional<z.ZodString>;
+  message: z.ZodOptional<z.ZodString>;
+  statementHandle: z.ZodString;
+  statementStatusUrl: z.ZodOptional<z.ZodString>;
+  createdOn: z.ZodOptional<z.ZodNumber>;
+  requestId: z.ZodOptional<z.ZodString>;
+  statementHandles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  resultSetMetaData: z.ZodOptional<z.ZodObject<{
+    numRows: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodOptional<z.ZodString>;
+    partitionInfo: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      rowCount: z.ZodNumber;
+      uncompressedSize: z.ZodOptional<z.ZodNumber>;
+      compressedSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodUnknown>>>>;
+    rowType: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      type: z.ZodString;
+      nullable: z.ZodOptional<z.ZodBoolean>;
+      length: z.ZodOptional<z.ZodNumber>;
+      precision: z.ZodOptional<z.ZodNumber>;
+      scale: z.ZodOptional<z.ZodNumber>;
+      byteLength: z.ZodOptional<z.ZodNumber>;
+      collation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      database: z.ZodOptional<z.ZodString>;
+      schema: z.ZodOptional<z.ZodString>;
+      table: z.ZodOptional<z.ZodString>;
+    }, z.core.$catchall<z.ZodUnknown>>>>;
+  }, z.core.$catchall<z.ZodUnknown>>>;
+  data: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodUnknown>>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+type StatementResponse = z.infer<typeof statementResponseSchema>;
+/**
+ * Terminal + transient statuses as exposed through the `code` field. Most
+ * callers only care whether the statement is `pending`, `done`, or
+ * `failed` — the `statementStatus` helper below compresses the raw `code`
+ * into those buckets.
+ */
+type StatementTerminalStatus = 'done' | 'failed' | 'cancelled';
+type StatementStatus = StatementTerminalStatus | 'pending';
+/**
+ * Snowflake code ranges (SQL API v2):
+ *  - 090002 — success (inline result)
+ *  - 333333 — statement accepted (async)
+ *  - 333334 — statement executing (still polling)
+ *  - 333335 — user-triggered cancel succeeded
+ *  - 390xxx / 3900xx / 0919xx / ... — SQL-level failures
+ *
+ * We map explicitly the two non-error status codes; everything else is
+ * treated as `failed` when the HTTP status is also an error, otherwise
+ * `done`.
+ */
+declare function statementStatus(input: {
+  httpStatus: number;
+  code?: string | undefined;
+}): StatementStatus;
+declare const cancelStatementResponseSchema: z.ZodObject<{
+  code: z.ZodOptional<z.ZodString>;
+  message: z.ZodOptional<z.ZodString>;
+  statementHandle: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodUnknown>>;
+type CancelStatementResponse = z.infer<typeof cancelStatementResponseSchema>;
+//#endregion
+export { resultSetMetaDataSchema as C, sqlBindingValueSchema as D, snowflakeObjectRowSchema as E, sqlBindingsSchema as O, partitionInfoSchema as S, snowflakeIdentifier as T, SnowflakeObjectRow as _, SubmitStatementInput as a, StatementContext as b, statementStatus as c, HydratedRow as d, PartitionResponse as f, ResultSetMetaData as g, PartitionInfo as h, StatementTerminalStatus as i, statementContextSchema as k, statementStatusCodeSchema as l, ColumnMeta as m, StatementResponse as n, cancelStatementResponseSchema as o, partitionResponseSchema as p, StatementStatus as r, statementResponseSchema as s, CancelStatementResponse as t, submitStatementInputSchema as u, SqlBinding as v, snowflakeFqn as w, columnMetaSchema as x, SqlBindings as y };