durable-execution-storage-drizzle/build/sqlite.d.ts

Drizzle ORM storage implementation for durable-execution

import { type TablesRelationalConfig } from 'drizzle-orm';
import { type BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
import { type DurableExecutionErrorStorageValue, type TaskExecutionCloseStatus, type TaskExecutionOnChildrenFinishedProcessingStatus, type TaskExecutionsStorage, type TaskExecutionStatus, type TaskExecutionSummary, type TaskRetryOptions } from 'durable-execution';
/**
 * Creates a SQLite table schema for storing durable task executions.
 *
 * This function generates a Drizzle ORM table definition with all necessary columns and indexes
 * for the durable-execution storage layer. The table includes:
 * - Task hierarchy tracking (root, parent, child relationships)
 * - Execution state management (status, retries, timeouts)
 * - Input/output data storage with JSON support
 * - Timestamp tracking for scheduling and expiration
 *
 * Note: SQLite storage uses a mutex for write operations to prevent database
 * locking issues with concurrent writes.
 *
 * @example
 * ```ts
 * // In your schema file (e.g., schema.ts)
 * import { createSQLiteTaskExecutionsTable } from 'durable-execution-storage-drizzle'
 *
 * // Use default table name
 * export const taskExecutions = createSQLiteTaskExecutionsTable()
 *
 * // Or specify a custom table name
 * export const myTasksTable = createSQLiteTaskExecutionsTable('my_custom_task_executions')
 * ```
 *
 * @param tableName - The name of the table to create. Defaults to 'task_executions'.
 * @returns A Drizzle SQLite table definition ready for migrations.
 */
export declare function createSQLiteTaskExecutionsTable(tableName?: string): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
    name: string;
    schema: undefined;
    columns: {
        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "id";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: true;
            hasDefault: true;
            isPrimaryKey: true;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        rootTaskId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "root_task_id";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
        }>;
        rootExecutionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "root_execution_id";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
        }>;
        parentTaskId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "parent_task_id";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
        }>;
        parentExecutionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "parent_execution_id";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
        }>;
        indexInParentChildren: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "index_in_parent_children";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        isOnlyChildOfParent: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "is_only_child_of_parent";
            tableName: string;
            dataType: "boolean";
            columnType: "SQLiteBoolean";
            data: boolean;
            driverParam: number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        isFinalizeOfParent: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "is_finalize_of_parent";
            tableName: string;
            dataType: "boolean";
            columnType: "SQLiteBoolean";
            data: boolean;
            driverParam: number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        taskId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "task_id";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: string;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
        }>;
        executionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "execution_id";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: string;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
        }>;
        retryOptions: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "retry_options";
            tableName: string;
            dataType: "json";
            columnType: "SQLiteTextJson";
            data: TaskRetryOptions;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            $type: TaskRetryOptions;
        }>;
        sleepMsBeforeRun: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "sleep_ms_before_run";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        timeoutMs: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "timeout_ms";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        areChildrenSequential: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "are_children_sequential";
            tableName: string;
            dataType: "boolean";
            columnType: "SQLiteBoolean";
            data: boolean;
            driverParam: number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        input: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "input";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: string;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
        }>;
        executorId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "executor_id";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
        }>;
        isSleepingTask: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "is_sleeping_task";
            tableName: string;
            dataType: "boolean";
            columnType: "SQLiteBoolean";
            data: boolean;
            driverParam: number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        sleepingTaskUniqueId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "sleeping_task_unique_id";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
        }>;
        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "status";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: TaskExecutionStatus;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
            $type: TaskExecutionStatus;
        }>;
        isFinished: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "is_finished";
            tableName: string;
            dataType: "boolean";
            columnType: "SQLiteBoolean";
            data: boolean;
            driverParam: number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        runOutput: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "run_output";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
        }>;
        output: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "output";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
        }>;
        error: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "error";
            tableName: string;
            dataType: "json";
            columnType: "SQLiteTextJson";
            data: DurableExecutionErrorStorageValue;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            $type: DurableExecutionErrorStorageValue;
        }>;
        retryAttempts: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "retry_attempts";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        startAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "start_at";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        startedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "started_at";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        expiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "expires_at";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        waitingForChildrenStartedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "waiting_for_children_started_at";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        waitingForFinalizeStartedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "waiting_for_finalize_started_at";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        finishedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "finished_at";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        children: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "children";
            tableName: string;
            dataType: "json";
            columnType: "SQLiteTextJson";
            data: TaskExecutionSummary[];
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            $type: TaskExecutionSummary[];
        }>;
        activeChildrenCount: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "active_children_count";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        onChildrenFinishedProcessingStatus: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "on_children_finished_processing_status";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: TaskExecutionOnChildrenFinishedProcessingStatus;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
            $type: TaskExecutionOnChildrenFinishedProcessingStatus;
        }>;
        onChildrenFinishedProcessingExpiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "on_children_finished_processing_expires_at";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        onChildrenFinishedProcessingFinishedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "on_children_finished_processing_finished_at";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        finalize: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "finalize";
            tableName: string;
            dataType: "json";
            columnType: "SQLiteTextJson";
            data: TaskExecutionSummary;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            $type: TaskExecutionSummary;
        }>;
        closeStatus: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "close_status";
            tableName: string;
            dataType: "string";
            columnType: "SQLiteText";
            data: TaskExecutionCloseStatus;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            length: number | undefined;
            $type: TaskExecutionCloseStatus;
        }>;
        closeExpiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "close_expires_at";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        closedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "closed_at";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        needsPromiseCancellation: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "needs_promise_cancellation";
            tableName: string;
            dataType: "boolean";
            columnType: "SQLiteBoolean";
            data: boolean;
            driverParam: number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "created_at";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
            name: "updated_at";
            tableName: string;
            dataType: "number";
            columnType: "SQLiteInteger";
            data: number;
            driverParam: number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
    };
    dialect: "sqlite";
}>;
/**
 * Type representing the SQLite table schema for task executions. Use this type when you need to
 * reference the table structure in your code.
 */
export type TaskExecutionsSQLiteTable = ReturnType<typeof createSQLiteTaskExecutionsTable>;
/**
 * Creates a SQLite storage adapter for durable-execution.
 *
 * This function creates a storage implementation that uses SQLite as the backend for
 * persisting task execution state. The storage adapter handles:
 * - Mutex-based write synchronization to prevent database locking
 * - Transactional operations for consistency
 * - Efficient querying with proper indexes
 * - Parent-child task relationship management
 *
 * Important: SQLite has limitations with concurrent writes. This implementation uses a mutex to
 * serialize write operations, making it suitable for:
 * - Development and testing environments
 * - Single-instance applications
 * - Low to moderate throughput scenarios
 *
 * For high-concurrency production workloads, consider using PostgreSQL or MySQL.
 *
 * @example
 * ```ts
 * import { drizzle } from 'drizzle-orm/libsql'
 * import { createClient } from '@libsql/client'
 * import { DurableExecutor } from 'durable-execution'
 * import { createSQLiteTaskExecutionsTable, createSQLiteTaskExecutionsStorage } from 'durable-execution-storage-drizzle'
 *
 * // Setup database connection (local file)
 * const client = createClient({
 *   url: 'file:./local.db'
 * })
 * const db = drizzle(client)
 *
 * // Create table schema and storage
 * const taskExecutionsTable = createSQLiteTaskExecutionsTable()
 * const storage = createSQLiteTaskExecutionsStorage(db, taskExecutionsTable)
 *
 * // Use with DurableExecutor
 * const executor = await DurableExecutor.make(storage)
 * ```
 *
 * @example
 * ```ts
 * // Using Turso (LibSQL cloud)
 * import { createClient } from '@libsql/client'
 *
 * const client = createClient({
 *   url: process.env.TURSO_DATABASE_URL!,
 *   authToken: process.env.TURSO_AUTH_TOKEN!
 * })
 * const db = drizzle(client)
 *
 * const storage = createSQLiteTaskExecutionsStorage(db, taskExecutionsTable)
 * ```
 *
 * @param db - A Drizzle SQLite database instance.
 * @param taskExecutionsTable - The table created by `createSQLiteTaskExecutionsTable()`.
 * @param options - The options for the storage.
 * @param options.enableTestMode - Whether to enable test mode. Defaults to false.
 * @returns A TaskExecutionsStorage implementation for use with DurableExecutor.
 */
export declare function createSQLiteTaskExecutionsStorage<TRunResult, TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig>(db: BaseSQLiteDatabase<'async', TRunResult, TFullSchema, TSchema>, taskExecutionsTable: TaskExecutionsSQLiteTable, options?: {
    enableTestMode?: boolean;
}): TaskExecutionsStorage;
//# sourceMappingURL=sqlite.d.ts.map