@keystrokehq/snowflake 0.0.16 → 0.0.18

package/dist/shares/index.d.mts

@@ -1,56 +0,0 @@
-import { SnowflakeClient } from "../client/index.mjs";
-import { d as HydratedRow } from "../statements-DJL0qVNA.mjs";
-import { CatalogResult, ShowOptions, showShares } from "../catalog/index.mjs";
-
-//#region src/shares/index.d.ts
-interface ShareContext {
-  readonly warehouse?: string;
-  readonly role?: string;
-}
-interface CreateShareOptions extends ShareContext {
-  readonly name: string;
-  readonly orReplace?: boolean;
-  readonly ifNotExists?: boolean;
-  readonly comment?: string;
-}
-declare function createShare(client: SnowflakeClient, options: CreateShareOptions): Promise<void>;
-interface AlterShareOptions extends ShareContext {
-  readonly name: string;
-  readonly ifExists?: boolean;
-  /** Replace the full account list via `SET ACCOUNTS = (...)`. */
-  readonly setAccounts?: readonly string[];
-  /** `ADD ACCOUNTS = (...)`. */
-  readonly addAccounts?: readonly string[];
-  /** `REMOVE ACCOUNTS = (...)`. */
-  readonly removeAccounts?: readonly string[];
-  /** `SET COMMENT = '...'`. */
-  readonly comment?: string;
-  /** `UNSET COMMENT`. */
-  readonly unsetComment?: boolean;
-}
-declare function alterShare(client: SnowflakeClient, options: AlterShareOptions): Promise<void>;
-interface DropShareOptions extends ShareContext {
-  readonly name: string;
-  readonly ifExists?: boolean;
-}
-declare function dropShare(client: SnowflakeClient, options: DropShareOptions): Promise<void>;
-interface DescribeShareOptions extends ShareContext {
-  readonly name: string;
-}
-declare function describeShare(client: SnowflakeClient, options: DescribeShareOptions): Promise<readonly HydratedRow[]>;
-interface AddAccountsToShareOptions extends ShareContext {
-  readonly name: string;
-  readonly accounts: readonly string[];
-  readonly ifExists?: boolean;
-  /** Optional `SHARE_RESTRICTIONS = TRUE|FALSE` appended to ADD ACCOUNTS. */
-  readonly shareRestrictions?: boolean;
-}
-declare function addAccountsToShare(client: SnowflakeClient, options: AddAccountsToShareOptions): Promise<void>;
-interface RemoveAccountsFromShareOptions extends ShareContext {
-  readonly name: string;
-  readonly accounts: readonly string[];
-  readonly ifExists?: boolean;
-}
-declare function removeAccountsFromShare(client: SnowflakeClient, options: RemoveAccountsFromShareOptions): Promise<void>;
-//#endregion
-export { AddAccountsToShareOptions, AlterShareOptions, type CatalogResult, CreateShareOptions, DescribeShareOptions, DropShareOptions, RemoveAccountsFromShareOptions, ShareContext, type ShowOptions, addAccountsToShare, alterShare, createShare, describeShare, dropShare, removeAccountsFromShare, showShares };

package/dist/shares/index.mjs

@@ -1,77 +0,0 @@
-import { executeSql } from "../sql/index.mjs";
-import { a as quoteLiteral, i as quoteIdentifier } from "../sql-safety-BZpAPsq6.mjs";
-import { showShares } from "../catalog/index.mjs";
-
-//#region src/shares/index.ts
-async function createShare(client, options) {
-	const prefix = `CREATE${options.orReplace ? " OR REPLACE" : ""} SHARE${options.ifNotExists ? " IF NOT EXISTS" : ""}`;
-	const comment = options.comment ? ` COMMENT = ${quoteLiteral(options.comment)}` : "";
-	await executeSql(client, {
-		statement: `${prefix} ${quoteIdentifier(options.name)}${comment}`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-/**
-* Snowflake account identifiers for shares take the form
-* `<orgName>.<accountName>` (unquoted). We validate the shape lightly
-* and pass it through without quoting because Snowflake treats quoted
-* identifiers here as case-sensitive names which would not match the
-* real account.
-*/
-const ACCOUNT_ID_RE = /^[A-Za-z0-9_]+\.[A-Za-z0-9_]+$/u;
-function renderAccountList(accounts) {
-	if (accounts.length === 0) throw new Error("accounts must be a non-empty list");
-	for (const a of accounts) if (!ACCOUNT_ID_RE.test(a)) throw new Error(`Invalid account identifier "${a}" — expected "<orgName>.<accountName>" (letters, digits, underscore)`);
-	return accounts.join(", ");
-}
-async function alterShare(client, options) {
-	let tail;
-	if (options.addAccounts) tail = `ADD ACCOUNTS = (${renderAccountList(options.addAccounts)})`;
-	else if (options.removeAccounts) tail = `REMOVE ACCOUNTS = (${renderAccountList(options.removeAccounts)})`;
-	else if (options.setAccounts) tail = `SET ACCOUNTS = (${renderAccountList(options.setAccounts)})`;
-	else if (options.comment !== void 0) tail = `SET COMMENT = ${quoteLiteral(options.comment)}`;
-	else if (options.unsetComment) tail = "UNSET COMMENT";
-	else throw new Error("alterShare requires one of: setAccounts / addAccounts / removeAccounts / comment / unsetComment");
-	await executeSql(client, {
-		statement: `ALTER SHARE${options.ifExists ? " IF EXISTS" : ""} ${quoteIdentifier(options.name)} ${tail}`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-async function dropShare(client, options) {
-	await executeSql(client, {
-		statement: `DROP SHARE${options.ifExists ? " IF EXISTS" : ""} ${quoteIdentifier(options.name)}`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-async function describeShare(client, options) {
-	return (await executeSql(client, {
-		statement: `DESCRIBE SHARE ${quoteIdentifier(options.name)}`,
-		warehouse: options.warehouse,
-		role: options.role
-	})).rows;
-}
-async function addAccountsToShare(client, options) {
-	const ifExists = options.ifExists ? " IF EXISTS" : "";
-	const accounts = renderAccountList(options.accounts);
-	const restrictions = options.shareRestrictions !== void 0 ? ` SHARE_RESTRICTIONS = ${options.shareRestrictions ? "TRUE" : "FALSE"}` : "";
-	await executeSql(client, {
-		statement: `ALTER SHARE${ifExists} ${quoteIdentifier(options.name)} ADD ACCOUNTS = (${accounts})${restrictions}`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-async function removeAccountsFromShare(client, options) {
-	const ifExists = options.ifExists ? " IF EXISTS" : "";
-	const accounts = renderAccountList(options.accounts);
-	await executeSql(client, {
-		statement: `ALTER SHARE${ifExists} ${quoteIdentifier(options.name)} REMOVE ACCOUNTS = (${accounts})`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-
-//#endregion
-export { addAccountsToShare, alterShare, createShare, describeShare, dropShare, removeAccountsFromShare, showShares };

package/dist/snowflake-s3-sns-webhook.credential-set-D6bLAWy5.d.mts

@@ -1,50 +0,0 @@
-import { CredentialSet } from "@keystrokehq/core";
-import { z } from "zod";
-import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
-import { InferCredentialSetAuth } from "@keystrokehq/core/credential-set";
-
-//#region src/credential-sets/snowflake-azure-eventgrid-webhook.credential-set.d.ts
-declare const snowflakeAzureEventGridWebhookCredentialSet: CredentialSet<"snowflake-azure-eventgrid-webhook", z.ZodObject<{
-  sharedSecret: z.ZodOptional<z.ZodString>;
-  sharedSecretHeader: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-  expectedTopicArn: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
-  sharedSecret: z.ZodOptional<z.ZodString>;
-  sharedSecretHeader: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-  expectedTopicArn: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>[] | undefined>;
-type SnowflakeAzureEventGridWebhookCredentials = InferCredentialSetAuth<typeof snowflakeAzureEventGridWebhookCredentialSet>;
-//#endregion
-//#region src/credential-sets/snowflake-gcs-pubsub-webhook.credential-set.d.ts
-declare const snowflakeGcsPubSubWebhookCredentialSet: CredentialSet<"snowflake-gcs-pubsub-webhook", z.ZodObject<{
-  expectedAudience: z.ZodString;
-  expectedServiceAccount: z.ZodString;
-  jwksUri: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-  issuer: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
-  expectedAudience: z.ZodString;
-  expectedServiceAccount: z.ZodString;
-  jwksUri: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-  issuer: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-}, z.core.$strip>>[] | undefined>;
-type SnowflakeGcsPubSubWebhookCredentials = InferCredentialSetAuth<typeof snowflakeGcsPubSubWebhookCredentialSet>;
-//#endregion
-//#region src/credential-sets/snowflake-s3-sns-webhook.credential-set.d.ts
-declare const snowflakeS3SnsWebhookCredentialSet: CredentialSet<"snowflake-s3-sns-webhook", z.ZodObject<{
-  expectedTopicArn: z.ZodOptional<z.ZodString>;
-  allowedSigningCertHostPattern: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-  autoConfirmSubscriptions: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
-    true: "true";
-    false: "false";
-  }>>>;
-}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
-  expectedTopicArn: z.ZodOptional<z.ZodString>;
-  allowedSigningCertHostPattern: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-  autoConfirmSubscriptions: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
-    true: "true";
-    false: "false";
-  }>>>;
-}, z.core.$strip>>[] | undefined>;
-type SnowflakeS3SnsWebhookCredentials = InferCredentialSetAuth<typeof snowflakeS3SnsWebhookCredentialSet>;
-//#endregion
-export { SnowflakeAzureEventGridWebhookCredentials as a, snowflakeGcsPubSubWebhookCredentialSet as i, snowflakeS3SnsWebhookCredentialSet as n, snowflakeAzureEventGridWebhookCredentialSet as o, SnowflakeGcsPubSubWebhookCredentials as r, SnowflakeS3SnsWebhookCredentials as t };

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