@keystrokehq/snowflake 0.0.16 → 0.0.17

package/dist/snowflake-s3-sns-webhook.credential-set-DzR7oWNK.mjs

@@ -1,44 +0,0 @@
-import { CredentialSet } from "@keystrokehq/core";
-import { z } from "zod";
-
-//#region src/credential-sets/snowflake-azure-eventgrid-webhook.credential-set.ts
-const snowflakeAzureEventGridWebhookCredentialSet = new CredentialSet({
-	id: "snowflake-azure-eventgrid-webhook",
-	exposure: "platform-only",
-	name: "Snowflake Auto-Ingest — Azure Event Grid",
-	auth: z.object({
-		sharedSecret: z.string().optional(),
-		sharedSecretHeader: z.string().default("aeg-subscription-secret").optional(),
-		expectedTopicArn: z.string().optional()
-	})
-});
-
-//#endregion
-//#region src/credential-sets/snowflake-gcs-pubsub-webhook.credential-set.ts
-const snowflakeGcsPubSubWebhookCredentialSet = new CredentialSet({
-	id: "snowflake-gcs-pubsub-webhook",
-	exposure: "platform-only",
-	name: "Snowflake Auto-Ingest — GCS Pub/Sub",
-	auth: z.object({
-		expectedAudience: z.string().min(1),
-		expectedServiceAccount: z.string().min(1),
-		jwksUri: z.string().default("https://www.googleapis.com/oauth2/v3/certs").optional(),
-		issuer: z.string().default("https://accounts.google.com").optional()
-	})
-});
-
-//#endregion
-//#region src/credential-sets/snowflake-s3-sns-webhook.credential-set.ts
-const snowflakeS3SnsWebhookCredentialSet = new CredentialSet({
-	id: "snowflake-s3-sns-webhook",
-	exposure: "platform-only",
-	name: "Snowflake Auto-Ingest — AWS SNS",
-	auth: z.object({
-		expectedTopicArn: z.string().optional(),
-		allowedSigningCertHostPattern: z.string().default("^sns\\.[a-z0-9-]+\\.amazonaws\\.com(\\.cn)?$").optional(),
-		autoConfirmSubscriptions: z.enum(["true", "false"]).default("false").optional()
-	})
-});
-
-//#endregion
-export { snowflakeGcsPubSubWebhookCredentialSet as n, snowflakeAzureEventGridWebhookCredentialSet as r, snowflakeS3SnsWebhookCredentialSet as t };

package/dist/snowflake.credential-set-BxT7Gf3A.d.mts

@@ -1,114 +0,0 @@
-import { CredentialSet } from "@keystrokehq/core";
-import { z } from "zod";
-import { InferCredentialSetAuth } from "@keystrokehq/core/credential-set";
-
-//#region src/credential-sets/snowflake.credential-set.d.ts
-/**
- * Public auth schema for Snowflake connections.
- *
- * Modeled as a discriminated union on `mode`. `connection.kind` is `manual`
- * because Keystroke does not run an interactive Snowflake OAuth dance — OAuth
- * mode accepts a bearer token provided by the caller (external IdP /
- * Snowflake-hosted OAuth).
- */
-declare const snowflakeAuthModeSchema: z.ZodEnum<{
-  keypair: "keypair";
-  oauth: "oauth";
-  pat: "pat";
-  basic: "basic";
-}>;
-type SnowflakeAuthMode = z.infer<typeof snowflakeAuthModeSchema>;
-declare const snowflakeAuthSchema: z.ZodObject<{
-  mode: z.ZodEnum<{
-    keypair: "keypair";
-    oauth: "oauth";
-    pat: "pat";
-    basic: "basic";
-  }>;
-  SNOWFLAKE_ACCOUNT: z.ZodString;
-  SNOWFLAKE_USER: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_PRIVATE_KEY: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_PRIVATE_KEY_PASSPHRASE: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_PAT: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_PASSWORD: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_OAUTH_ACCESS_TOKEN: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_OAUTH_REFRESH_TOKEN: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_OAUTH_CLIENT_ID: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_OAUTH_CLIENT_SECRET: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_OAUTH_TOKEN_URL: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_OAUTH_SCOPES: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_ROLE: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_WAREHOUSE: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_DATABASE: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_SCHEMA: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_HOST: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_REGION: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_PUBLIC_KEY_FP: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const snowflakeCredentialSet: CredentialSet<"snowflake", z.ZodObject<{
-  mode: z.ZodEnum<{
-    keypair: "keypair";
-    oauth: "oauth";
-    pat: "pat";
-    basic: "basic";
-  }>;
-  SNOWFLAKE_ACCOUNT: z.ZodString;
-  SNOWFLAKE_USER: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_PRIVATE_KEY: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_PRIVATE_KEY_PASSPHRASE: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_PAT: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_PASSWORD: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_OAUTH_ACCESS_TOKEN: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_OAUTH_REFRESH_TOKEN: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_OAUTH_CLIENT_ID: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_OAUTH_CLIENT_SECRET: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_OAUTH_TOKEN_URL: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_OAUTH_SCOPES: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_ROLE: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_WAREHOUSE: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_DATABASE: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_SCHEMA: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_HOST: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_REGION: z.ZodOptional<z.ZodString>;
-  SNOWFLAKE_PUBLIC_KEY_FP: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, {
-  id: string;
-  kind: "manual";
-  label: string;
-  input: z.ZodObject<{
-    mode: z.ZodEnum<{
-      keypair: "keypair";
-      oauth: "oauth";
-      pat: "pat";
-      basic: "basic";
-    }>;
-    SNOWFLAKE_ACCOUNT: z.ZodString;
-    SNOWFLAKE_USER: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_PRIVATE_KEY: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_PRIVATE_KEY_PASSPHRASE: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_PAT: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_PASSWORD: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_OAUTH_ACCESS_TOKEN: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_OAUTH_REFRESH_TOKEN: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_OAUTH_CLIENT_ID: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_OAUTH_CLIENT_SECRET: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_OAUTH_TOKEN_URL: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_OAUTH_SCOPES: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_ROLE: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_WAREHOUSE: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_DATABASE: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_SCHEMA: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_HOST: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_REGION: z.ZodOptional<z.ZodString>;
-    SNOWFLAKE_PUBLIC_KEY_FP: z.ZodOptional<z.ZodString>;
-  }, z.core.$strip>;
-}[]>;
-type SnowflakeCredentials = InferCredentialSetAuth<typeof snowflakeCredentialSet>;
-/**
- * Parse raw credential values through the full refinement pipeline. Callers
- * (client, operations) should use this instead of the raw object schema so
- * mode-specific invariants are enforced.
- */
-declare function parseSnowflakeCredentials(input: unknown): SnowflakeCredentials;
-//#endregion
-export { snowflakeAuthSchema as a, snowflakeAuthModeSchema as i, SnowflakeCredentials as n, snowflakeCredentialSet as o, parseSnowflakeCredentials as r, SnowflakeAuthMode as t };

package/dist/snowflake.credential-set-DE3gXf-a.mjs

@@ -1,106 +0,0 @@
-import { CredentialSet } from "@keystrokehq/core";
-import { z } from "zod";
-
-//#region src/credential-sets/snowflake.credential-set.ts
-/**
-* Public auth schema for Snowflake connections.
-*
-* Modeled as a discriminated union on `mode`. `connection.kind` is `manual`
-* because Keystroke does not run an interactive Snowflake OAuth dance — OAuth
-* mode accepts a bearer token provided by the caller (external IdP /
-* Snowflake-hosted OAuth).
-*/
-const snowflakeAuthModeSchema = z.enum([
-	"keypair",
-	"oauth",
-	"pat",
-	"basic"
-]);
-const baseSnowflakeAuthShape = {
-	mode: snowflakeAuthModeSchema,
-	SNOWFLAKE_ACCOUNT: z.string().min(1),
-	SNOWFLAKE_USER: z.string().min(1).optional(),
-	SNOWFLAKE_PRIVATE_KEY: z.string().min(1).optional(),
-	SNOWFLAKE_PRIVATE_KEY_PASSPHRASE: z.string().optional(),
-	SNOWFLAKE_PAT: z.string().min(1).optional(),
-	SNOWFLAKE_PASSWORD: z.string().min(1).optional(),
-	SNOWFLAKE_OAUTH_ACCESS_TOKEN: z.string().min(1).optional(),
-	SNOWFLAKE_OAUTH_REFRESH_TOKEN: z.string().optional(),
-	SNOWFLAKE_OAUTH_CLIENT_ID: z.string().optional(),
-	SNOWFLAKE_OAUTH_CLIENT_SECRET: z.string().optional(),
-	SNOWFLAKE_OAUTH_TOKEN_URL: z.string().url().optional(),
-	SNOWFLAKE_OAUTH_SCOPES: z.string().optional(),
-	SNOWFLAKE_ROLE: z.string().optional(),
-	SNOWFLAKE_WAREHOUSE: z.string().optional(),
-	SNOWFLAKE_DATABASE: z.string().optional(),
-	SNOWFLAKE_SCHEMA: z.string().optional(),
-	SNOWFLAKE_HOST: z.string().optional(),
-	SNOWFLAKE_REGION: z.string().optional(),
-	SNOWFLAKE_PUBLIC_KEY_FP: z.string().optional()
-};
-const snowflakeAuthSchema = z.object(baseSnowflakeAuthShape).superRefine((value, ctx) => {
-	if (value.mode === "keypair") {
-		if (!value.SNOWFLAKE_USER) ctx.addIssue({
-			code: z.ZodIssueCode.custom,
-			path: ["SNOWFLAKE_USER"],
-			message: "SNOWFLAKE_USER is required when mode = \"keypair\""
-		});
-		if (!value.SNOWFLAKE_PRIVATE_KEY) ctx.addIssue({
-			code: z.ZodIssueCode.custom,
-			path: ["SNOWFLAKE_PRIVATE_KEY"],
-			message: "SNOWFLAKE_PRIVATE_KEY is required when mode = \"keypair\""
-		});
-	} else if (value.mode === "oauth") {
-		if (!value.SNOWFLAKE_OAUTH_ACCESS_TOKEN) ctx.addIssue({
-			code: z.ZodIssueCode.custom,
-			path: ["SNOWFLAKE_OAUTH_ACCESS_TOKEN"],
-			message: "SNOWFLAKE_OAUTH_ACCESS_TOKEN is required when mode = \"oauth\""
-		});
-	} else if (value.mode === "pat") {
-		if (!value.SNOWFLAKE_USER) ctx.addIssue({
-			code: z.ZodIssueCode.custom,
-			path: ["SNOWFLAKE_USER"],
-			message: "SNOWFLAKE_USER is required when mode = \"pat\""
-		});
-		if (!value.SNOWFLAKE_PAT) ctx.addIssue({
-			code: z.ZodIssueCode.custom,
-			path: ["SNOWFLAKE_PAT"],
-			message: "SNOWFLAKE_PAT is required when mode = \"pat\""
-		});
-	} else if (value.mode === "basic") {
-		if (!value.SNOWFLAKE_USER) ctx.addIssue({
-			code: z.ZodIssueCode.custom,
-			path: ["SNOWFLAKE_USER"],
-			message: "SNOWFLAKE_USER is required when mode = \"basic\""
-		});
-		if (!value.SNOWFLAKE_PASSWORD) ctx.addIssue({
-			code: z.ZodIssueCode.custom,
-			path: ["SNOWFLAKE_PASSWORD"],
-			message: "SNOWFLAKE_PASSWORD is required when mode = \"basic\""
-		});
-	}
-});
-const snowflakeAuthObjectSchema = z.object(baseSnowflakeAuthShape);
-const snowflakeCredentialSet = new CredentialSet({
-	id: "snowflake",
-	name: "Snowflake",
-	description: "Snowflake data cloud: SQL API v2, Snowpipe (file + streaming), warehouses, roles, users, grants, shares, streams, tasks, and administration for Keystroke workflows.",
-	auth: snowflakeAuthObjectSchema,
-	connections: [{
-		id: "manual",
-		kind: "manual",
-		label: "Snowflake credentials",
-		input: snowflakeAuthObjectSchema
-	}]
-});
-/**
-* Parse raw credential values through the full refinement pipeline. Callers
-* (client, operations) should use this instead of the raw object schema so
-* mode-specific invariants are enforced.
-*/
-function parseSnowflakeCredentials(input) {
-	return snowflakeAuthSchema.parse(input);
-}
-
-//#endregion
-export { snowflakeCredentialSet as i, snowflakeAuthModeSchema as n, snowflakeAuthSchema as r, parseSnowflakeCredentials as t };

package/dist/sql/index.d.mts

@@ -1,84 +0,0 @@
-import { SnowflakeClient } from "../client/index.mjs";
-import { a as SubmitStatementInput, d as HydratedRow, f as PartitionResponse, m as ColumnMeta, n as StatementResponse } from "../statements-DJL0qVNA.mjs";
-//#region src/sql/index.d.ts
-interface SubmitOptions {
-  readonly async?: boolean;
-  readonly requestId?: string;
-}
-interface SubmitResult {
-  readonly response: StatementResponse;
-  readonly status: 'done' | 'failed' | 'pending' | 'cancelled';
-  readonly httpStatus: number;
-}
-/**
- * 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.
- */
-declare function submitStatement(client: SnowflakeClient, input: SubmitStatementInput, options?: SubmitOptions): Promise<SubmitResult>;
-/**
- * Fetch the current status of a previously submitted async statement. Returns
- * both the envelope and the derived `status` bucket.
- */
-declare function getStatement(client: SnowflakeClient, handle: string, options?: {
-  readonly partition?: number;
-}): Promise<SubmitResult>;
-/**
- * POST `/cancel`. Snowflake responds with `code: 333335` on success — we
- * normalise anything else into a {@link SnowflakeApiError}.
- */
-declare function cancelStatement(client: SnowflakeClient, handle: string): Promise<void>;
-interface ExecuteSqlOptions extends SubmitOptions {
-  readonly pollIntervalMs?: number;
-  readonly maxWaitMs?: number;
-  readonly hydrate?: boolean;
-  readonly now?: () => number;
-  readonly sleep?: (ms: number) => Promise<void>;
-}
-interface ExecuteSqlResult<TRow = HydratedRow> {
-  readonly handle: string;
-  readonly columns: readonly ColumnMeta[];
-  readonly rows: readonly TRow[];
-  readonly envelope: StatementResponse;
-  readonly partitions: number;
-}
-/**
- * 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.
- */
-declare function executeSql(client: SnowflakeClient, input: SubmitStatementInput, options?: ExecuteSqlOptions): Promise<ExecuteSqlResult<HydratedRow | readonly unknown[]>>;
-/**
- * Composio `SNOWFLAKE_BASIC_RUN_QUERY` parity — requires an explicit
- * database + schema to match the published BASIC shape.
- */
-declare function runQuery(client: SnowflakeClient, input: {
-  readonly statement: string;
-  readonly database: string;
-  readonly schema_name: string;
-  readonly warehouse?: string;
-  readonly role?: string;
-}, options?: ExecuteSqlOptions): Promise<ExecuteSqlResult<HydratedRow | readonly unknown[]>>;
-/**
- * Fetch a single partition for a known handle.
- */
-declare function getStatementResultPartition(client: SnowflakeClient, handle: string, partition: number): Promise<PartitionResponse>;
-/**
- * Async iterator over every partition for a handle. Useful for streaming
- * large result sets into downstream pipelines.
- */
-declare function iterateStatementResult(client: SnowflakeClient, handle: string, options?: {
-  readonly maxPartitions?: number;
-}): AsyncGenerator<PartitionResponse, void, void>;
-/**
- * Blocking helper: polls `getStatement` until the statement reaches a
- * terminal status or the `maxWaitMs` budget elapses. Returns the terminal
- * envelope (throws for `failed` / `cancelled`).
- */
-declare function waitForStatement(client: SnowflakeClient, handle: string, options?: ExecuteSqlOptions): Promise<StatementResponse>;
-//#endregion
-export { ExecuteSqlOptions, ExecuteSqlResult, SubmitOptions, SubmitResult, cancelStatement, executeSql, getStatement, getStatementResultPartition, iterateStatementResult, runQuery, submitStatement, waitForStatement };

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 };