/**
 * Default logging configuration
 */
export declare const DEFAULT_LOGGING_CONFIG: Required<LoggingConfig>;

/**
 * Default PRAGMA configuration
 */
export declare const DEFAULT_PRAGMA_CONFIG: PragmaConfig;

/**
 * Default VFS configuration
 */
export declare const DEFAULT_VFS_CONFIG: Required<VFSConfig>;

/**
 * PRAGMA journal_mode options
 */
export declare type JournalMode = 'DELETE' | 'TRUNCATE' | 'PERSIST' | 'MEMORY' | 'WAL' | 'OFF';

/**
 * Logging configuration
 */
export declare interface LoggingConfig {
    filterSqlTrace?: boolean;
    print?: (message: string) => void;
    printErr?: (message: string) => void;
}

/**
 * Configuration for OPFS SAH Pool VFS
 */
export declare interface PoolConfig {
    initialCapacity?: number;
    clearOnInit?: boolean;
    name?: string;
}

/**
 * PRAGMA configuration
 */
export declare interface PragmaConfig {
    journal_mode?: JournalMode;
    synchronous?: SynchronousMode;
    temp_store?: TempStoreMode;
    cache_size?: number;
    page_size?: number;
    foreign_keys?: 'ON' | 'OFF';
    [key: string]: any;
}

/**
 * Result of a run() operation
 */
export declare interface RunResult {
    lastInsertRowId?: number;
    changes?: number;
}

/**
 * Main SQLiteWASM class - provides a simple interface to SQLite WASM
 */
export declare class SQLiteWASM<Schema = any> {
    private config;
    private worker;
    private messageId;
    private pendingRequests;
    private isReady;
    private readyPromise;
    constructor(config: SQLiteWASMConfig);
    /**
     * Initialize the database and wait for it to be ready
     */
    ready(): Promise<void>;
    private initialize;
    private handleWorkerMessage;
    private sendMessage;
    /**
     * Execute SQL without returning results (INSERT, UPDATE, DELETE, CREATE, etc.)
     */
    exec(sql: string, params?: any[]): Promise<void>;
    /**
     * Execute SQL and return results (SELECT)
     */
    query<T = any>(sql: string, params?: any[]): Promise<T[]>;
    /**
     * Execute SQL and return run results (lastInsertRowId, changes)
     */
    run(sql: string, params?: any[]): Promise<RunResult>;
    /**
     * Execute multiple operations in a transaction
     */
    transaction(callback: (_tx: Transaction) => Promise<void>): Promise<void>;
    /**
     * Get a typed table accessor (for type hints only)
     * Replaces '$' in the SQL with the table name
     */
    table<K extends keyof Schema>(tableName: K): TypedTable<Schema[K]>;
    /**
     * Export the database as a Uint8Array
     */
    export(): Promise<Uint8Array>;
    /**
     * Import a database from a Uint8Array
     */
    import(filename: string, data: Uint8Array): Promise<void>;
    /**
     * Close the database connection
     */
    close(): Promise<void>;
    /**
     * Delete the database
     */
    delete(): Promise<void>;
}

/**
 * Main configuration for SQLiteWASM
 */
export declare interface SQLiteWASMConfig {
    filename: string;
    vfs?: VFSConfig;
    pragma?: PragmaConfig;
    worker?: WorkerConfig;
    logging?: LoggingConfig;
}

/**
 * PRAGMA synchronous options
 */
export declare type SynchronousMode = 'OFF' | 'NORMAL' | 'FULL' | 'EXTRA';

/**
 * PRAGMA temp_store options
 */
export declare type TempStoreMode = 'DEFAULT' | 'FILE' | 'MEMORY';

/**
 * Transaction interface
 */
export declare interface Transaction {
    exec(sql: string, params?: any[]): Promise<void>;
    query<T = any>(sql: string, params?: any[]): Promise<T[]>;
    run(sql: string, params?: any[]): Promise<RunResult>;
}

/**
 * Typed table interface (for type hints only)
 */
export declare interface TypedTable<T> {
    query<R = T>(sql: string, params?: any[]): Promise<R[]>;
    exec(sql: string, params?: any[]): Promise<void>;
    run(sql: string, params?: any[]): Promise<RunResult>;
}

/**
 * VFS configuration
 */
export declare interface VFSConfig {
    type?: VFSType;
    poolConfig?: PoolConfig;
}

/**
 * VFS (Virtual File System) type options
 */
export declare type VFSType = 'opfs-sahpool' | 'opfs' | 'memdb';

/**
 * Worker configuration
 */
export declare interface WorkerConfig {
    path?: string;
}

export { }
