import { b as SQLiteSchemaInternal, D as DrizzleObjects, S as Snapshot } from '../index.web-Bjl8wnx8.cjs';
export { d as drizzleObjectsToSnapshot, s as schemaToDrizzleObjects, a as schemaToSnapshot } from '../index.web-Bjl8wnx8.cjs';
import { P as PartialConfig } from '../loader.node-Bo9Dqnt1.cjs';
import { D as DrizzleSchema, C as Casing } from '../global-v_LCR4XD.cjs';
import 'drizzle-orm';
import 'drizzle-orm/sqlite-core';
import '../symbols-CdI5QtS4.cjs';
import 'drizzle-orm/relations';
import 'zod';

type SQLiteDB = {
    query: <T = any>(sql: string, params?: any[]) => Promise<T[]>;
};
/**
 * Import the Drizzle schema from a PostgreSQL database.
 * @param db - The database to import from.
 */
declare const importFromDatabase: (db: SQLiteDB) => Promise<SQLiteSchemaInternal>;

/**
 * Convert the schema SQL dump to a Drizzle snapshot
 *
 * **It requires `@libsql/client-wasm` to be installed**
 *
 * @param sqlDump - SQL dump
 * @returns Drizzle snapshot
 */
declare function sqlToSnapshot(sqlDump: string): Promise<{
    dialect: "sqlite";
    projectId: string;
    version: "6";
    tables: Record<string, {
        name: string;
        columns: Record<string, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            autoincrement?: boolean | undefined;
            default?: any;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
        }>;
        indexes: Record<string, {
            name: string;
            columns: string[];
            isUnique: boolean;
            where?: string | undefined;
        }>;
        foreignKeys: Record<string, {
            name: string;
            tableFrom: string;
            columnsFrom: string[];
            tableTo: string;
            columnsTo: string[];
            onUpdate?: string | undefined;
            onDelete?: string | undefined;
        }>;
        compositePrimaryKeys: Record<string, {
            columns: string[];
            name?: string | undefined;
        }>;
        uniqueConstraints: Record<string, {
            name: string;
            columns: string[];
        }>;
        checkConstraints: Record<string, {
            value: string;
            name: string;
        }>;
        relations: {
            type: "many" | "one";
            fieldName: string;
            relationName: string;
            referencedTableName: string;
        }[];
        description?: string | undefined;
    }>;
    enums: {};
    views: Record<string, {
        name: string;
        columns: Record<string, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            autoincrement?: boolean | undefined;
            default?: any;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
        }>;
        isExisting: boolean;
        description?: string | undefined;
        definition?: string | undefined;
    }>;
    _meta: {
        columns: Record<string, string>;
        tables: Record<string, string>;
    };
    internal?: {
        indexes?: Record<string, {
            columns: Record<string, {
                isExpression?: boolean | undefined;
            } | undefined>;
        } | undefined> | undefined;
    } | undefined;
}>;

/**
 * Convert Drizzle objects to SQL
 * @param drizzleObjects - Drizzle objects
 * @param config - Drizzle config
 * @returns SQL
 */
declare function drizzleObjectsToSql(drizzleObjects: DrizzleObjects, config?: PartialConfig): string;
/**
 * Convert snapshot to SQL statements
 * @param snapshot - Snapshot
 * @returns SQL statements
 */
declare function snapshotToSqlStatements(snapshot: Snapshot): string[];
/**
 * Convert snapshot to SQL
 * @param snapshot - Snapshot
 * @returns SQL
 */
declare function snapshotToSql(snapshot: Snapshot): string;
/**
 * Convert schema to SQL statements
 * @param schema - Drizzle schema
 * @param config - Drizzle config
 * @returns SQL statements
 */
declare function schemaToSqlStatements(schema: DrizzleSchema, config?: PartialConfig): string[];
/**
 * Convert schema to SQL
 * @param schema - Drizzle schema
 * @param config - Drizzle config
 * @returns SQL
 */
declare function schemaToSql(schema: DrizzleSchema, config?: PartialConfig): string;

/**
 * Convert snapshot to TypeScript
 * @param snapshot - Snapshot
 * @param casing - Casing
 * @returns TypeScript
 */
declare function snapshotToTypeScript(snapshot: Snapshot, casing: Casing): {
    file: string;
    imports: string;
    decalrations: string;
    schemaEntry: string;
};
/**
 * Convert the schema SQL dump to a Drizzle TypeScript file
 *
 * **It requires `@libsql/client-wasm` to be installed**
 *
 * @param sqlDump - The SQL dump
 * @returns The TypeScript file
 */
declare function sqlToTypescript(sqlDump: string): Promise<string>;

export { DrizzleObjects, Snapshot, drizzleObjectsToSql, importFromDatabase, schemaToSql, schemaToSqlStatements, snapshotToSql, snapshotToSqlStatements, snapshotToTypeScript, sqlToSnapshot, sqlToTypescript };