@keystrokehq/snowflake 0.0.16 → 0.0.18

package/dist/sql/index.mjs

@@ -1,209 +0,0 @@
-import { a as submitStatementInputSchema, n as statementResponseSchema, o as partitionResponseSchema, r as statementStatus } from "../statements-BumhMhN4.mjs";
-import { n as SnowflakeSqlError, t as SnowflakeApiError } from "../errors-60AsF7Su.mjs";
-import { hydrateRows } from "../results/index.mjs";
-
-//#region src/sql/index.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/sql-options-2k5xQ-oS.d.mts

@@ -1,32 +0,0 @@
-//#region src/sql-options.d.ts
-/**
- * Option-list composition helpers for Snowflake DDL/DML.
- *
- * Most CREATE/ALTER statements (stages, file formats, pipes, tasks, COPY
- * options, warehouses) accept option lists like:
- *
- *   FILE_FORMAT = (TYPE = 'CSV' FIELD_DELIMITER = '|' SKIP_HEADER = 1)
- *   CREDENTIALS = (AWS_KEY_ID = 'abc' AWS_SECRET_KEY = 'xyz')
- *   COPY_OPTIONS = (ON_ERROR = 'CONTINUE' PURGE = TRUE)
- *
- * These helpers compose those lists safely:
- *  - String values are quoted with {@link quoteLiteral}.
- *  - Numbers, booleans, and raw-marked values pass through verbatim.
- *  - Nested option maps render as parenthesised sub-lists.
- *  - Ordering is preserved in insertion order.
- */
-/**
- * A scalar that can appear on the RHS of an option. Pre-built raw SQL can
- * be passed via {@link rawOption} when callers need to inject a keyword
- * (e.g. `AUTO_REFRESH = TRUE`, `ENCRYPTION = (TYPE = 'SNOWFLAKE_SSE')`).
- */
-type OptionScalar = string | number | bigint | boolean | null | undefined | RawSql | OptionMap | readonly OptionScalar[];
-interface OptionMap {
-  readonly [key: string]: OptionScalar;
-}
-/** Marker type for a pre-formatted SQL fragment. */
-interface RawSql {
-  readonly __rawSql: string;
-}
-//#endregion
-export { OptionMap as t };

package/dist/sql-options-D6GEa21F.mjs

@@ -1,79 +0,0 @@
-import { a as quoteLiteral } from "./sql-safety-BZpAPsq6.mjs";
-
-//#region src/sql-options.ts
-/**
-* Option-list composition helpers for Snowflake DDL/DML.
-*
-* Most CREATE/ALTER statements (stages, file formats, pipes, tasks, COPY
-* options, warehouses) accept option lists like:
-*
-*   FILE_FORMAT = (TYPE = 'CSV' FIELD_DELIMITER = '|' SKIP_HEADER = 1)
-*   CREDENTIALS = (AWS_KEY_ID = 'abc' AWS_SECRET_KEY = 'xyz')
-*   COPY_OPTIONS = (ON_ERROR = 'CONTINUE' PURGE = TRUE)
-*
-* These helpers compose those lists safely:
-*  - String values are quoted with {@link quoteLiteral}.
-*  - Numbers, booleans, and raw-marked values pass through verbatim.
-*  - Nested option maps render as parenthesised sub-lists.
-*  - Ordering is preserved in insertion order.
-*/
-function isRawSql(value) {
-	return typeof value === "object" && value !== null && typeof value.__rawSql === "string";
-}
-function isOptionMap(value) {
-	if (value === null || typeof value !== "object") return false;
-	if (Array.isArray(value)) return false;
-	if (isRawSql(value)) return false;
-	if (value instanceof Date) return false;
-	return true;
-}
-function formatScalar(value) {
-	if (value === void 0) return void 0;
-	if (value === null) return "NULL";
-	if (isRawSql(value)) return value.__rawSql;
-	if (typeof value === "string") return quoteLiteral(value);
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw new TypeError("Cannot serialise NaN/Infinity as a Snowflake option value");
-		return value.toString();
-	}
-	if (typeof value === "bigint") return value.toString();
-	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
-	if (Array.isArray(value)) return `(${value.map((item) => formatScalar(item)).filter((item) => item !== void 0).join(", ")})`;
-	if (isOptionMap(value)) return formatOptionGroup(value);
-	throw new TypeError(`Unsupported Snowflake option value: ${typeof value}`);
-}
-/** Render a map like `(KEY = value KEY2 = 'literal')`. Empty maps render as `()`. */
-function formatOptionGroup(map) {
-	const parts = [];
-	for (const [key, value] of Object.entries(map)) {
-		const rendered = formatScalar(value);
-		if (rendered === void 0) continue;
-		parts.push(`${key.toUpperCase()} = ${rendered}`);
-	}
-	return `(${parts.join(" ")})`;
-}
-/**
-* Render a map as a space-separated option list (no wrapping parens). This
-* is the form used directly in `CREATE STAGE ... URL='...' CREDENTIALS=(..)`
-* where top-level options sit alongside the object name.
-*/
-function formatOptions(map) {
-	const parts = [];
-	for (const [key, value] of Object.entries(map)) {
-		const rendered = formatScalar(value);
-		if (rendered === void 0) continue;
-		parts.push(`${key.toUpperCase()} = ${rendered}`);
-	}
-	return parts.join(" ");
-}
-/**
-* Render a nested option group as ` KEY = (...)` — returns empty string when
-* the map is undefined so callers can compose optional clauses inline.
-*/
-function renderOptionGroup(key, map) {
-	if (!map) return "";
-	return ` ${key.toUpperCase()} = ${formatOptionGroup(map)}`;
-}
-
-//#endregion
-export { renderOptionGroup as n, formatOptions as t };

package/dist/sql-safety-BZpAPsq6.mjs

@@ -1,56 +0,0 @@
-//#region src/sql-safety.ts
-/**
-* SQL identifier + literal escaping utilities.
-*
-* Snowflake follows ANSI rules:
-*  - Identifiers: wrap in `"..."`; internal `"` is escaped as `""`.
-*  - String literals: wrap in `'...'`; internal `'` is escaped as `''`.
-*  - Numeric, boolean, null literals are written raw.
-*
-* Every domain module that composes SQL goes through these helpers — they
-* are the package's sole defense against SQL injection from operation
-* inputs that name identifiers or match patterns.
-*/
-const UNQUOTED_IDENT = /^[A-Z_][A-Z0-9_$]*$/u;
-/**
-* Return a double-quoted form of the identifier, escaping embedded
-* double-quotes. When `allowUnquoted` is true and the input is already a
-* canonical unquoted identifier, return it verbatim so the resulting SQL
-* is more readable.
-*/
-function quoteIdentifier(name, options = {}) {
-	if (options.allowUnquoted && UNQUOTED_IDENT.test(name)) return name;
-	return `"${name.replaceAll("\"", "\"\"")}"`;
-}
-/**
-* Build a fully-qualified name from up to three segments. Each segment is
-* independently quoted. Missing leading segments are omitted.
-*/
-function buildFqn(...segments) {
-	return segments.filter((segment) => segment !== void 0 && segment.length > 0).map((segment) => quoteIdentifier(segment)).join(".");
-}
-/**
-* Quote a Snowflake string literal, doubling embedded single quotes.
-*/
-function quoteLiteral(value) {
-	return `'${value.replaceAll("'", "''")}'`;
-}
-/**
-* Compose `LIKE '<pattern>'` when `pattern` is provided, empty string
-* otherwise. Pattern is escaped as a SQL literal.
-*/
-function likeClause(pattern) {
-	return pattern ? ` LIKE ${quoteLiteral(pattern)}` : "";
-}
-/**
-* Compose `IN <scopeKeyword> <quoted identifier>` clause (e.g. "IN DATABASE
-* MYDB"). Caller supplies a pre-joined identifier (fqn already built).
-*/
-function inClause(scopeKeyword, target) {
-	if (!target) return "";
-	if (scopeKeyword === "ACCOUNT") return " IN ACCOUNT";
-	return ` IN ${scopeKeyword} ${target}`;
-}
-
-//#endregion
-export { quoteLiteral as a, quoteIdentifier as i, inClause as n, likeClause as r, buildFqn as t };

package/dist/stages/index.d.mts

@@ -1,64 +0,0 @@
-import { SnowflakeClient } from "../client/index.mjs";
-import { d as HydratedRow } from "../statements-DJL0qVNA.mjs";
-import { ExecuteSqlResult } from "../sql/index.mjs";
-import { t as OptionMap } from "../sql-options-2k5xQ-oS.mjs";
-import { CatalogResult, ShowScopedOptions, showStages } from "../catalog/index.mjs";
-
-//#region src/stages/index.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/index.mjs

@@ -1,81 +0,0 @@
-import { executeSql } from "../sql/index.mjs";
-import { a as quoteLiteral, t as buildFqn } from "../sql-safety-BZpAPsq6.mjs";
-import { n as renderOptionGroup, t as formatOptions } from "../sql-options-D6GEa21F.mjs";
-import { showStages } from "../catalog/index.mjs";
-
-//#region src/stages/index.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-BumhMhN4.mjs

@@ -1,81 +0,0 @@
-import { c as sqlBindingsSchema, l as statementContextSchema, r as resultSetMetaDataSchema } from "./common-DfpCwJx5.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 };