ts-prorm-orm 1.1.0 → 1.2.0

package/dist/dialects/snowflake/index.d.ts

@@ -0,0 +1,727 @@
+/**
+ * Snowflake dialect implementation for the TypeScript ORM
+ *
+ * Notes on Snowflake-specific semantics that differ from most other dialects
+ * implemented in this project:
+ *  - Snowflake has no traditional B-tree indexes. Storage is organized via
+ *    automatic micro-partitioning, and the closest user-facing concept is a
+ *    "clustering key" (ALTER TABLE ... CLUSTER BY (...)). Index-shaped
+ *    interface methods (addIndex/createIndex/removeIndex/dropIndex/etc.) are
+ *    therefore implemented as documented no-ops that emit a console warning,
+ *    mirroring how src/dialects/sqlite/index.ts handles options that are
+ *    accepted for interface-compatibility but have no real effect for that
+ *    dialect (e.g. `engine`/`charset`/table comments).
+ *  - Semi-structured data uses VARIANT/OBJECT/ARRAY types with PARSE_JSON(),
+ *    `:` path access and GET/GET_PATH functions instead of JSON/JSONB.
+ *  - Upserts use MERGE INTO (standard SQL, well supported).
+ *  - Pagination uses standard LIMIT/OFFSET (unlike Oracle/MSSQL's
+ *    OFFSET...FETCH-only style).
+ *  - Auto-increment uses AUTOINCREMENT/IDENTITY column properties.
+ *  - Sequences are supported via CREATE SEQUENCE / NEXTVAL.
+ *  - Connections require an "account" identifier and may specify a
+ *    "warehouse" (the compute resource that must be active for queries to
+ *    run). If provided, `USE WAREHOUSE <name>` is issued right after connect.
+ *  - Auth supports both password auth and key-pair auth (privateKey /
+ *    privateKeyPath), matching the snowflake-sdk driver's ConnectionOptions.
+ */
+import type { Connection as SnowflakeConnection } from 'snowflake-sdk';
+import { Dialect, DialectOptions, ColumnDefinition, TableOptions, DropTableOptions, TableDescription, IndexOptions, IndexDefinition, InsertOptions, UpdateOptions, DeleteOptions, SelectOptions, UpsertQueryOptions, DropSchemaOptions, ViewOptions, DropViewOptions, DropIndexOptions, ConstraintDefinition, DropConstraintOptions, BuildOptions, FdwForeignServerOptions, FdwAlterForeignServerOptions, FdwUserMappingOptions, FdwForeignTableOptions, FdwImportForeignSchemaOptions, ExtensionInfo, CreateExtensionOptions, DropExtensionOptions } from '../dialect';
+import { Transaction, TransactionOptions, QueryResult, QueryOptions, DataType, WhereOptions, Order, RetryOptions, CreatePartitionOptions, AttachPartitionOptions, DetachPartitionOptions, StoredProcedureOptions, DropStoredProcedureOptions, ExecuteStoredProcedureOptions, SequenceOptions, DropSequenceOptions, StreamOptions as QueryStreamOptions } from '../../types';
+import { Readable } from 'stream';
+/**
+ * Snowflake dialect connection/config options.
+ *
+ * Supports both password authentication (`password`) and key-pair
+ * authentication (`privateKey` / `privateKeyPath`, optionally with
+ * `privateKeyPass` for an encrypted key). The `warehouse` option activates
+ * the given virtual warehouse right after connecting via `USE WAREHOUSE`.
+ */
+export interface SnowflakeDialectOptions extends DialectOptions {
+    /** Snowflake account identifier, e.g. "xy12345" or "xy12345.us-east-1" */
+    account?: string;
+    /** Virtual warehouse (compute resource) to activate on connect */
+    warehouse?: string;
+    /** Default schema for the session */
+    schema?: string;
+    /** Default security role for the session */
+    role?: string;
+    /** PEM-encoded private key contents for key-pair authentication */
+    privateKey?: string;
+    /** Path to a PEM-encoded private key file for key-pair authentication */
+    privateKeyPath?: string;
+    /** Passphrase for an encrypted private key */
+    privateKeyPass?: string;
+    /** Authenticator to use (defaults to Snowflake's built-in password auth) */
+    authenticator?: string;
+    /** Client application name reported to Snowflake */
+    application?: string;
+    /** Connection/query retry configuration */
+    retry?: RetryOptions;
+    /** Role-agnostic client session keep alive toggle */
+    clientSessionKeepAlive?: boolean;
+}
+/** Options for `cloneTable`/`cloneSchema`/`cloneDatabase` (zero-copy CLONE). */
+export interface CloneOptions {
+    ifNotExists?: boolean;
+    replace?: boolean;
+    schema?: string;
+    /** Clone the source as of a specific timestamp (Time Travel `AT(TIMESTAMP => ...)`) */
+    atTimestamp?: string | Date;
+    /** Clone the source as of a relative offset in seconds (`AT(OFFSET => ...)`) */
+    atOffset?: number;
+    /** Clone the source as of a specific query ID (`AT(STATEMENT => ...)`) */
+    atStatement?: string;
+    /** Clone the source immediately before a specific query ID (`BEFORE(STATEMENT => ...)`) */
+    beforeStatement?: string;
+}
+/** Options for `createFileFormat` (`CREATE FILE FORMAT`). */
+export interface FileFormatOptions {
+    type: 'CSV' | 'JSON' | 'PARQUET' | 'AVRO' | 'ORC' | 'XML' | string;
+    ifNotExists?: boolean;
+    replace?: boolean;
+    schema?: string;
+    fieldDelimiter?: string;
+    recordDelimiter?: string;
+    skipHeader?: number;
+    fieldOptionallyEnclosedBy?: string;
+    nullIf?: string | string[];
+    emptyFieldAsNull?: boolean;
+    stripOuterArray?: boolean;
+    binaryAsText?: boolean;
+    compression?: string;
+    dateFormat?: string;
+    timestampFormat?: string;
+    /** Escape hatch for any additional `KEY = value` clause, appended verbatim */
+    raw?: string;
+}
+/** Options for `createStage` (`CREATE STAGE`). */
+export interface StageOptions {
+    ifNotExists?: boolean;
+    replace?: boolean;
+    schema?: string;
+    /** External location URL, e.g. 's3://my-bucket/path/' */
+    url?: string;
+    /** Credential key/value pairs, e.g. { awsKeyId: '...', awsSecretKey: '...' } */
+    credentials?: Record<string, string>;
+    /** Name of a previously created FILE FORMAT to associate with this stage */
+    fileFormatName?: string;
+}
+/** Options for `copyInto` (bulk load via `COPY INTO <table> FROM @stage`). */
+export interface CopyIntoOptions {
+    schema?: string;
+    files?: string[];
+    pattern?: string;
+    fileFormatName?: string;
+    fileFormat?: Record<string, string | number | boolean>;
+    onError?: 'CONTINUE' | 'SKIP_FILE' | 'ABORT_STATEMENT' | string;
+    force?: boolean;
+    purge?: boolean;
+    matchByColumnName?: 'CASE_SENSITIVE' | 'CASE_INSENSITIVE' | 'NONE' | string;
+}
+/** Options for `unloadTo` (bulk unload via `COPY INTO @stage FROM <table>`). */
+export interface UnloadOptions {
+    schema?: string;
+    fileFormatName?: string;
+    fileFormat?: Record<string, string | number | boolean>;
+    overwrite?: boolean;
+    single?: boolean;
+    header?: boolean;
+    maxFileSize?: number;
+}
+/** Options for `createStream` (`CREATE STREAM ... ON TABLE ...`). */
+export interface StreamOptions {
+    ifNotExists?: boolean;
+    replace?: boolean;
+    schema?: string;
+    appendOnly?: boolean;
+    showInitialRows?: boolean;
+    comment?: string;
+}
+/** Options for `createTask` (`CREATE TASK ...`). */
+export interface TaskOptions {
+    ifNotExists?: boolean;
+    replace?: boolean;
+    schema?: string;
+    warehouse?: string;
+    /** Cron expression or interval, e.g. "USING CRON 0 0 * * * UTC" or "60 MINUTE" */
+    schedule?: string;
+    /**
+     * Name(s) of predecessor task(s), forming a DAG (`AFTER <task>`). Snowflake
+     * tasks may depend on more than one predecessor (a task runs only after
+     * *all* of its predecessors complete); pass an array to emit
+     * `AFTER <task1>, <task2>, ...`.
+     */
+    after?: string | string[];
+    /** Condition expression gating execution (`WHEN <expr>`) */
+    when?: string;
+    comment?: string;
+}
+/**
+ * Options shared by `createWarehouse`/`alterWarehouse` (`CREATE WAREHOUSE
+ * ... WITH ...` / `ALTER WAREHOUSE ... SET ...`). Field names mirror the
+ * Snowflake object properties they map to (WAREHOUSE_SIZE, AUTO_SUSPEND,
+ * etc.), snake_case-to-camelCase.
+ */
+export interface WarehouseOptions {
+    /** `IF NOT EXISTS` — only meaningful on create, ignored on alter */
+    ifNotExists?: boolean;
+    /** `CREATE OR REPLACE WAREHOUSE` — only meaningful on create */
+    replace?: boolean;
+    /** `WAREHOUSE_SIZE`, e.g. 'X-SMALL', 'SMALL', 'MEDIUM', 'LARGE', 'X-LARGE', '2X-LARGE', ... */
+    size?: string;
+    /** `AUTO_SUSPEND` — seconds of inactivity before the warehouse suspends (0 disables auto-suspend) */
+    autoSuspend?: number;
+    /** `AUTO_RESUME` — whether the warehouse automatically resumes when a query is submitted */
+    autoResume?: boolean;
+    /** `MIN_CLUSTER_COUNT` — minimum clusters for a multi-cluster warehouse */
+    minClusterCount?: number;
+    /** `MAX_CLUSTER_COUNT` — maximum clusters for a multi-cluster warehouse */
+    maxClusterCount?: number;
+    /** `SCALING_POLICY`, e.g. 'STANDARD' or 'ECONOMY' */
+    scalingPolicy?: 'STANDARD' | 'ECONOMY' | string;
+    /** `INITIALLY_SUSPENDED` — only meaningful on create */
+    initiallySuspended?: boolean;
+    /** `RESOURCE_MONITOR` — name of a resource monitor to assign to this warehouse */
+    resourceMonitor?: string;
+    /** `COMMENT` */
+    comment?: string;
+}
+/** A single `TRIGGERS ON <threshold> PERCENT DO <action>` clause of a resource monitor. */
+export interface ResourceMonitorTrigger {
+    /** Percentage of the credit quota that activates this trigger */
+    threshold: number;
+    /** Action to take once the threshold is reached */
+    action: 'NOTIFY' | 'SUSPEND' | 'SUSPEND_IMMEDIATE';
+}
+/**
+ * Options for `createResourceMonitor`/`alterResourceMonitor`
+ * (`CREATE RESOURCE MONITOR ... WITH ...` / `ALTER RESOURCE MONITOR ... SET ...`).
+ * Resource monitors track Snowflake credit usage and can automatically
+ * notify, suspend, or immediately suspend the warehouse(s)/account they are
+ * assigned to once usage crosses configured thresholds.
+ */
+export interface ResourceMonitorOptions {
+    /** `IF NOT EXISTS` — only meaningful on create; mutually exclusive with `replace` */
+    ifNotExists?: boolean;
+    /** `CREATE OR REPLACE RESOURCE MONITOR` — only meaningful on create; mutually exclusive with `ifNotExists` */
+    replace?: boolean;
+    /** `CREDIT_QUOTA` */
+    creditQuota?: number;
+    /** `FREQUENCY`, e.g. 'MONTHLY', 'DAILY', 'WEEKLY', 'YEARLY', 'NEVER' */
+    frequency?: 'MONTHLY' | 'DAILY' | 'WEEKLY' | 'YEARLY' | 'NEVER' | string;
+    /** `START_TIMESTAMP` — a timestamp literal, or 'IMMEDIATELY' */
+    startTimestamp?: string;
+    /** `END_TIMESTAMP` */
+    endTimestamp?: string;
+    /** `NOTIFY_USERS = (...)` — Snowflake usernames to notify */
+    notifyUsers?: string[];
+    /** `TRIGGERS ON <n> PERCENT DO <action> ...` */
+    triggers?: ResourceMonitorTrigger[];
+}
+export declare class SnowflakeDialect implements Dialect {
+    readonly name = "snowflake";
+    readonly library = "snowflake-sdk";
+    private connection;
+    private _isConnected;
+    private config;
+    private retryOptions;
+    constructor(config: SnowflakeDialectOptions);
+    /**
+     * Connect to Snowflake. Wraps the callback-based snowflake-sdk API
+     * (`createConnection(...).connect(callback)`) in a Promise. If a
+     * `warehouse` was configured, activates it with `USE WAREHOUSE` right
+     * after the connection is established.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from Snowflake, terminating the connection immediately.
+     *
+     * A failed `destroy()` callback is surfaced by rejecting this promise
+     * (rather than silently resolving as if the disconnect succeeded), so
+     * callers relying on disconnect() aren't misled into thinking the
+     * underlying socket was cleanly torn down. The local connection state is
+     * still cleared in a `finally` regardless of outcome, since from this
+     * dialect's perspective the connection should no longer be used either way.
+     */
+    disconnect(): Promise<void>;
+    getConnection(): SnowflakeConnection | null;
+    isConnected(): boolean;
+    /**
+     * Builds the shared `complete` callback used by both `query()` and
+     * `queryWithCancel()` to translate a snowflake-sdk statement completion
+     * into a resolved/rejected `QueryResult` promise.
+     */
+    private makeCompleteHandler;
+    private resolveExecuteArgs;
+    /**
+     * Stream query results by paging through `sql` via repeated
+     * dialect-appropriate LIMIT/OFFSET queries (see
+     * `createPaginatedQueryStream()` in `src/dialects/query-stream-helper.ts`)
+     * instead of loading the whole result set into memory at once.
+     * @param sql - The SELECT statement to stream
+     * @param options - Streaming options (batch size, backpressure watermark, model mapping)
+     */
+    queryStream(sql: string, options?: QueryStreamOptions): Readable;
+    /**
+     * Execute a raw SQL query, wrapping the callback-based
+     * `connection.execute({ sqlText, binds, complete })` API in a Promise.
+     */
+    query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    /**
+     * Execute a query and return a handle that allows cancelling it before it
+     * completes, via snowflake-sdk's `Statement.cancel()` API. This is the
+     * long-running-query abort path that plain `query()` does not offer: once
+     * a query has been submitted, `query()` gives the caller no way to stop it
+     * short of waiting (or retrying, which only compounds wait time under
+     * warehouse auto-suspend/resume scenarios).
+     *
+     * Unlike `query()`, this method does not go through the retry wrapper —
+     * callers that need cancellation are expected to manage their own
+     * retry/backoff around the returned `result` promise if desired.
+     */
+    queryWithCancel(sql: string, options?: QueryOptions): {
+        result: Promise<QueryResult>;
+        cancel: () => Promise<void>;
+        getQueryId: () => string | undefined;
+    };
+    private executeWithRetry;
+    escape(value: unknown): string;
+    private escapeString;
+    private formatDate;
+    escapeId(identifier: unknown): string;
+    quoteIdentifier(identifier: string): string;
+    quoteTable(tableName: string, schema?: string): string;
+    createSchema(schema: string): Promise<void>;
+    dropSchema(schema: string, options?: DropSchemaOptions): Promise<void>;
+    showAllSchemas(): Promise<string[]>;
+    listSchemas(): Promise<string[]>;
+    createDatabaseSQL(options: {
+        name: string;
+        encoding?: string;
+        lcCollate?: string;
+        lcCtype?: string;
+        template?: string;
+        tablespace?: string;
+        collate?: string;
+        isTemplate?: boolean;
+    }): string;
+    dropDatabaseSQL(name: string): string;
+    createSavepointSQL(name?: string): string;
+    releaseSavepointSQL(name: string): string;
+    rollbackToSavepointSQL(name: string): string;
+    createExtension(_extensionName: string, _options?: CreateExtensionOptions): Promise<void>;
+    dropExtension(_extensionName: string, _options?: DropExtensionOptions): Promise<void>;
+    getExtensions(): Promise<ExtensionInfo[]>;
+    hasExtension(_extensionName: string): Promise<boolean>;
+    getDatabaseVersion(): Promise<string>;
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions): Promise<void>;
+    private buildConstraintSql;
+    private getColumnDefinitionSql;
+    private getDefaultValue;
+    dropTable(tableName: string, options?: DropTableOptions): Promise<void>;
+    createPartitionedTable(): Promise<void>;
+    createPartition(_options: CreatePartitionOptions): Promise<void>;
+    attachPartition(_options: AttachPartitionOptions): Promise<void>;
+    detachPartition(_options: DetachPartitionOptions): Promise<void>;
+    dropPartition(): Promise<void>;
+    /**
+     * Set (or clear) a clustering key for a table — Snowflake's replacement
+     * for manual indexing/partitioning to influence micro-partition pruning.
+     */
+    setClusteringKey(tableName: string, fields: string[]): Promise<void>;
+    dropClusteringKey(tableName: string): Promise<void>;
+    createView(viewName: string, query: string, options?: ViewOptions): Promise<void>;
+    dropView(viewName: string, options?: DropViewOptions): Promise<void>;
+    showViews(): Promise<string[]>;
+    showMaterializedViews(): Promise<string[]>;
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    removeColumn(tableName: string, columnName: string): Promise<void>;
+    changeColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    renameColumn(tableName: string, oldColumnName: string, newColumnName: string): Promise<void>;
+    addForeignKey(tableName: string, columnName: string, referencedTableName: string, referencedColumnName: string, options?: any): Promise<void>;
+    bulkInsert(tableName: string, records: Record<string, any>[], _options?: any): Promise<QueryResult>;
+    showTables(): Promise<string[]>;
+    showConstraints(tableName: string): Promise<any[]>;
+    addConstraint(tableName: string, options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): Promise<void>;
+    removeConstraint(tableName: string, constraintName: string): Promise<void>;
+    /**
+     * Snowflake has no traditional indexes; it returns an empty list rather
+     * than throwing so generic ORM code paths that inspect "current indexes"
+     * degrade gracefully.
+     */
+    showIndexes(_tableName: string): Promise<any[]>;
+    describeTable(tableName: string): Promise<TableDescription>;
+    renameTable(oldName: string, newName: string): Promise<void>;
+    addIndex(tableName: string, indexName: string, _fields: string[], _options?: IndexOptions): Promise<void>;
+    removeIndex(tableName: string, indexName: string): Promise<void>;
+    createIndex(tableName: string, indexDef: IndexDefinition): Promise<void>;
+    dropIndex(tableName: string, indexName: string, _options?: DropIndexOptions): Promise<void>;
+    createFulltextIndex(tableName: string, indexName: string, _fields: string[], _options?: {
+        parser?: string;
+        comment?: string;
+    }): Promise<void>;
+    createSpatialIndex(tableName: string, indexName: string, _fields: string[], _options?: {
+        storage?: string;
+        srid?: number;
+    }): Promise<void>;
+    createConstraint(tableName: string, constraintDef: ConstraintDefinition): Promise<void>;
+    dropConstraint(tableName: string, constraintName: string, options?: DropConstraintOptions): Promise<void>;
+    changeOwner(newOwner: string, tableName: string): Promise<void>;
+    createForeignDataWrapper(): Promise<void>;
+    dropForeignDataWrapper(): Promise<void>;
+    createForeignServer(): Promise<void>;
+    dropForeignServer(): Promise<void>;
+    createForeignTable(): Promise<void>;
+    createSecurityPolicy(_policyName: string, _tableName: string, _options?: {
+        predicate?: string;
+    }): Promise<void>;
+    dropSecurityPolicy(_policyName: string, _tableName: string): Promise<void>;
+    startTransaction(_options?: TransactionOptions): Promise<Transaction>;
+    commitTransaction(_transaction: Transaction): Promise<void>;
+    rollbackTransaction(_transaction: Transaction): Promise<void>;
+    getDataTypeSql(dataType: DataType): string;
+    /**
+     * Build a Snowflake VARIANT/OBJECT path query using `:` path access
+     * (e.g. `data:key::STRING`) rather than JSON_EXTRACT.
+     */
+    buildJsonQuery(column: string, path: string, value?: unknown, operator?: string): {
+        sql: string;
+        values: unknown[];
+    };
+    buildWhereClause(where: WhereOptions, _options?: BuildOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildOrderClause(order: Order, _options?: BuildOptions): string;
+    /**
+     * Snowflake supports standard LIMIT/OFFSET pagination (unlike Oracle/MSSQL's
+     * FETCH FIRST-only style), so this is a direct passthrough.
+     */
+    buildLimitOffset(limit?: number | string, offset?: number | string): string;
+    buildInsertQuery(tableName: string, values: Record<string, any>, options?: InsertOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildUpdateQuery(tableName: string, values: Record<string, any>, where: WhereOptions, options?: UpdateOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildDeleteQuery(tableName: string, where: WhereOptions, options?: DeleteOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Formats a single SELECT attribute. Plain column names are identifier-
+     * quoted as before; entries that look like SQL expressions rather than
+     * bare identifiers (e.g. window functions like
+     * `ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC) AS rn`, or
+     * any other expression containing parentheses/whitespace/an `AS` alias)
+     * are passed through unescaped so callers can use analytical SQL that a
+     * plain identifier-quoting pass would otherwise mangle.
+     */
+    private formatSelectAttribute;
+    /**
+     * Builds a `WITH [RECURSIVE] ...` prefix from `options.cte`, Snowflake's
+     * (standard-SQL) Common Table Expression syntax. Each entry may set its
+     * own `recursive` flag; if any entry is recursive the whole `WITH` clause
+     * is emitted as `WITH RECURSIVE` (Snowflake, like most engines, applies
+     * RECURSIVE to the entire WITH clause rather than per-CTE).
+     */
+    private buildCteClause;
+    /**
+     * Builds Snowflake's Time Travel clause (`AT(...)`/`BEFORE(...)`) to
+     * append right after a table reference in the FROM clause, e.g.
+     * `FROM "T" AT(TIMESTAMP => '2024-01-01 00:00:00')`.
+     */
+    private buildTimeTravelClause;
+    buildSelectQuery(options: SelectOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build an upsert using Snowflake's MERGE INTO, which is well-supported
+     * and close to standard SQL MERGE.
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, any>, options?: UpsertQueryOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildIncrementQuery(tableName: string, fields: string | string[] | Record<string, number>, where: WhereOptions, options?: {
+        by?: number;
+    }): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Replace placeholders in SQL with actual escaped values. Supports both
+     * named (:param) and positional (?) placeholders.
+     */
+    replaceReplacements(sql: string, replacements?: Record<string, unknown> | unknown[]): string;
+    buildCreateServerQuery(_name: string, _opts: FdwForeignServerOptions): string;
+    buildAlterServerQuery(_name: string, _opts: FdwAlterForeignServerOptions): string;
+    buildDropServerQuery(_name: string, _opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    buildCreateUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    buildAlterUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    buildDropUserMappingQuery(_serverName: string, _user: string, _opts?: {
+        ifExists?: boolean;
+    }): string;
+    createUserMapping(): Promise<void>;
+    dropUserMapping(): Promise<void>;
+    buildCreateForeignTableQuery(_tableName: string, _opts: FdwForeignTableOptions): string;
+    buildDropForeignTableQuery(_tableName: string, _opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    buildImportForeignSchemaQuery(_remoteSchema: string, _serverName: string, _opts?: FdwImportForeignSchemaOptions): string;
+    getServersQuery(): string;
+    buildCreateUserQuery(_username: string, _options?: any): string;
+    buildAlterUserQuery(_username: string, _options: any): string;
+    buildDropUserQuery(_username: string, _options?: any): string;
+    getUsersQuery(): string;
+    buildGrantQuery(_options: any): string;
+    buildRevokeQuery(_options: any): string;
+    buildShowGrantsQuery(_username: string, _host?: string): string;
+    buildFlushPrivilegesQuery(): string;
+    buildCreateRoleQuery(_roleName: string, _options?: any): string;
+    buildDropRoleQuery(_roleName: string, _options?: any): string;
+    buildGrantRoleQuery(_role: string, _to: any, _options?: any): string;
+    buildRevokeRoleQuery(_role: string, _from: any, _options?: any): string;
+    getRolesQuery(): string;
+    createSequence(options: SequenceOptions): Promise<void>;
+    dropSequence(sequenceName: string, options?: DropSequenceOptions): Promise<void>;
+    nextSequenceValue(sequenceName: string): Promise<number>;
+    hasSequence(sequenceName: string): Promise<boolean>;
+    listSequences(): Promise<string[]>;
+    createStoredProcedure(options: StoredProcedureOptions): Promise<void>;
+    createProcedure(options: StoredProcedureOptions): Promise<void>;
+    dropStoredProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    dropProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    executeStoredProcedure(options: ExecuteStoredProcedureOptions): Promise<QueryResult>;
+    hasStoredProcedure(procedureName: string, schema?: string): Promise<boolean>;
+    /**
+     * Builds the optional `AT(...)`/`BEFORE(...)` suffix used by CLONE
+     * statements, reusing the same Time Travel clause builder as SELECT.
+     */
+    private buildCloneTimeTravelClause;
+    /**
+     * Zero-copy clone of a table: `CREATE TABLE <target> CLONE <source>`.
+     * Supports an optional Time Travel clause (`atTimestamp`/`atOffset`/
+     * `atStatement`/`beforeStatement`) to clone a historical version of the
+     * source table, and `ifNotExists`/`replace` like `createTable`.
+     */
+    cloneTable(source: string, target: string, options?: CloneOptions): Promise<void>;
+    /**
+     * Zero-copy clone of a schema: `CREATE SCHEMA <target> CLONE <source>`.
+     */
+    cloneSchema(source: string, target: string, options?: CloneOptions): Promise<void>;
+    /**
+     * Zero-copy clone of a database: `CREATE DATABASE <target> CLONE <source>`.
+     */
+    cloneDatabase(source: string, target: string, options?: CloneOptions): Promise<void>;
+    /**
+     * `CREATE FILE FORMAT <name> TYPE = <CSV|JSON|PARQUET|...> [options...]`.
+     * Supports the most commonly used per-type options; any additional/rare
+     * option can be passed through `raw` and is appended verbatim.
+     */
+    createFileFormat(name: string, options: FileFormatOptions): Promise<void>;
+    dropFileFormat(name: string, options?: {
+        ifExists?: boolean;
+        schema?: string;
+    }): Promise<void>;
+    /**
+     * `CREATE STAGE <name> [URL = '...'] [CREDENTIALS = (...)] [FILE_FORMAT = ...]`.
+     * A stage is Snowflake's named reference to a bulk-load/unload location
+     * (internal, or external S3/Azure/GCS); required before `COPY INTO` can
+     * reference `@<stage>`.
+     */
+    createStage(name: string, options?: StageOptions): Promise<void>;
+    dropStage(name: string, options?: {
+        ifExists?: boolean;
+        schema?: string;
+    }): Promise<void>;
+    /**
+     * Bulk load: `COPY INTO <table> FROM @<stage>[/path] [FILES = (...)]
+     * [PATTERN = '...'] [FILE_FORMAT = (...)] [ON_ERROR = ...] [FORCE = ...]`.
+     * `stagePath` may be a bare stage name (`my_stage`) or already include the
+     * `@` prefix / sub-path (`@my_stage/2024/`); both are normalized.
+     */
+    copyInto(tableName: string, stagePath: string, options?: CopyIntoOptions): Promise<QueryResult>;
+    /**
+     * Bulk unload: `COPY INTO @<stage>[/path] FROM <table> [FILE_FORMAT = (...)]
+     * [OVERWRITE = ...] [SINGLE = ...] [HEADER = ...]`.
+     */
+    unloadTo(tableName: string, stagePath: string, options?: UnloadOptions): Promise<QueryResult>;
+    /**
+     * Builds the `WAREHOUSE_SIZE = '...' AUTO_SUSPEND = ... ...` object
+     * properties shared by `CREATE WAREHOUSE ... WITH ...` and
+     * `ALTER WAREHOUSE ... SET ...`. `includeCreateOnly` controls whether
+     * create-only properties (`INITIALLY_SUSPENDED`) are included, since
+     * `ALTER WAREHOUSE ... SET` does not accept them.
+     */
+    private buildWarehousePropertiesSql;
+    /**
+     * `CREATE [OR REPLACE] WAREHOUSE [IF NOT EXISTS] <name> WITH <properties>`.
+     */
+    createWarehouse(name: string, options?: WarehouseOptions): Promise<void>;
+    /**
+     * `ALTER WAREHOUSE <name> SET <properties>`. Also used to (re)assign a
+     * resource monitor to a warehouse via `options.resourceMonitor`
+     * (`ALTER WAREHOUSE <name> SET RESOURCE_MONITOR = <monitor_name>`).
+     */
+    alterWarehouse(name: string, options: WarehouseOptions): Promise<void>;
+    dropWarehouse(name: string, options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    suspendWarehouse(name: string): Promise<void>;
+    resumeWarehouse(name: string): Promise<void>;
+    /**
+     * Builds the `CREDIT_QUOTA = ... FREQUENCY = ... TRIGGERS ON ... PERCENT DO ...`
+     * body shared by `CREATE RESOURCE MONITOR ... WITH ...` and
+     * `ALTER RESOURCE MONITOR ... SET ...`.
+     */
+    private buildResourceMonitorPropertiesSql;
+    /** `CREATE [OR REPLACE] RESOURCE MONITOR [IF NOT EXISTS] <name> WITH <properties>`. */
+    createResourceMonitor(name: string, options: ResourceMonitorOptions): Promise<void>;
+    /** `ALTER RESOURCE MONITOR <name> SET <properties>` (updates quota/frequency/triggers/etc). */
+    alterResourceMonitor(name: string, options: ResourceMonitorOptions): Promise<void>;
+    dropResourceMonitor(name: string, options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /**
+     * `CREATE STREAM <name> ON TABLE <table> [APPEND_ONLY = ...] [SHOW_INITIAL_ROWS = ...]`.
+     * A stream tracks row-level INSERT/UPDATE/DELETE changes on a table (or
+     * view) since it was created or last consumed, Snowflake's native CDC
+     * mechanism.
+     */
+    createStream(name: string, tableName: string, options?: StreamOptions): Promise<void>;
+    dropStream(name: string, options?: {
+        ifExists?: boolean;
+        schema?: string;
+    }): Promise<void>;
+    showStreams(): Promise<string[]>;
+    /**
+     * `CREATE TASK <name> [WAREHOUSE = ...] [SCHEDULE = '...'] [AFTER <task>]
+     * AS <sql>`. A task runs a single SQL statement (often `CALL` on a stored
+     * procedure) on a schedule (cron/interval) or as part of a DAG (`AFTER`).
+     */
+    createTask(name: string, sql: string, options?: TaskOptions): Promise<void>;
+    dropTask(name: string, options?: {
+        ifExists?: boolean;
+        schema?: string;
+    }): Promise<void>;
+    resumeTask(name: string, schema?: string): Promise<void>;
+    suspendTask(name: string, schema?: string): Promise<void>;
+    /** Runs a task immediately, outside of its schedule: `EXECUTE TASK <name>`. */
+    executeTask(name: string, schema?: string): Promise<QueryResult>;
+    showTasks(): Promise<string[]>;
+    /**
+     * `CREATE [OR REPLACE] [SECURE] MATERIALIZED VIEW <name> AS <query>`.
+     * Snowflake materialized views are single-table, automatically maintained by
+     * the service. Pass `secure: true` for a SECURE materialized view (hides the
+     * definition/optimizer internals for data sharing).
+     */
+    createMaterializedView(viewName: string, query: string, options?: {
+        replace?: boolean;
+        secure?: boolean;
+        comment?: string;
+        schema?: string;
+        clusterBy?: string[];
+    }): Promise<void>;
+    dropMaterializedView(viewName: string, options?: {
+        ifExists?: boolean;
+        schema?: string;
+    }): Promise<void>;
+    /**
+     * `CREATE [OR REPLACE] DYNAMIC TABLE <name> TARGET_LAG = '...' WAREHOUSE = ...
+     * AS <query>`. Dynamic tables are Snowflake's declarative, automatically
+     * refreshed alternative to materialized views for multi-table
+     * transforms/rollups; `targetLag` (e.g. `'1 minute'` or `'DOWNSTREAM'`) sets
+     * the freshness target and `warehouse` runs the refresh.
+     */
+    createDynamicTable(name: string, query: string, options: {
+        targetLag: string;
+        warehouse: string;
+        replace?: boolean;
+        ifNotExists?: boolean;
+        schema?: string;
+        clusterBy?: string[];
+        comment?: string;
+    }): Promise<void>;
+    dropDynamicTable(name: string, options?: {
+        ifExists?: boolean;
+        schema?: string;
+    }): Promise<void>;
+    /** Manually refresh a dynamic table: `ALTER DYNAMIC TABLE <name> REFRESH`. */
+    refreshDynamicTable(name: string, schema?: string): Promise<void>;
+    /**
+     * `UNDROP TABLE <name>` — restore a table dropped within the Time Travel
+     * retention window. Snowflake's counterpart to an accidental-DROP undo; also
+     * available for schemas/databases via {@link undropSchema}/{@link undropDatabase}.
+     */
+    undropTable(tableName: string, schema?: string): Promise<void>;
+    undropSchema(schema: string): Promise<void>;
+    undropDatabase(name: string): Promise<void>;
+    /**
+     * Fetch the full `CREATE` DDL for an object via `SELECT GET_DDL(<type>, <name>)`.
+     * Higher fidelity than parsing `DESCRIBE TABLE` rows — returns the exact,
+     * reproducible statement Snowflake would use to recreate the object.
+     *
+     * @param objectType - e.g. `'TABLE'`, `'VIEW'`, `'FUNCTION'`, `'PROCEDURE'`, `'SCHEMA'`.
+     */
+    getDdl(objectType: string, name: string, schema?: string): Promise<string>;
+    /**
+     * `CREATE [OR REPLACE] [SECURE] FUNCTION <name>(args) RETURNS <type>
+     * [LANGUAGE ...] AS $$ <body> $$`. UDFs return a value (scalar or table) and
+     * are callable inline in SQL, unlike stored procedures. `language` defaults to
+     * SQL; JavaScript/Python/Java UDFs pass the matching `language` + `body`.
+     */
+    createFunction(name: string, options: {
+        args?: Array<{
+            name: string;
+            type: string;
+        }>;
+        returns: string;
+        body: string;
+        language?: 'SQL' | 'JAVASCRIPT' | 'PYTHON' | 'JAVA' | 'SCALA';
+        replace?: boolean;
+        secure?: boolean;
+        schema?: string;
+        immutable?: boolean;
+        runtimeVersion?: string;
+        handler?: string;
+        comment?: string;
+    }): Promise<void>;
+    dropFunction(name: string, argTypes?: string[], options?: {
+        ifExists?: boolean;
+        schema?: string;
+    }): Promise<void>;
+    /**
+     * Build an expression to shred a JSON document/array into relational rows.
+     * Snowflake has no `JSON_TABLE`; its real equivalent is the `FLATTEN` table function
+     * (`TABLE(FLATTEN(input => ..., path => ...))`), which explodes a VARIANT array/object
+     * into rows exposing `value` (and `index` for array position). This wraps FLATTEN in a
+     * derived table that projects `value:<key>::<type>` per requested column, matching the
+     * named/typed column shape of JSON_TABLE/OPENJSON in the other dialects.
+     * Snowflake: (SELECT f.value:name::type AS name, ... FROM
+     *   TABLE(FLATTEN(input => expr, path => 'rowPath')) AS f) AS alias
+     */
+    buildJsonTable(jsonExpression: string, rowPath: string, columns: Array<{
+        name: string;
+        type?: string;
+        path?: string;
+        forOrdinality?: boolean;
+    }>, alias: string): string;
+}
+export default SnowflakeDialect;