@magnet-cms/adapter-db-drizzle 1.0.2

package/dist/index.d.ts

@@ -0,0 +1,1059 @@
+import { SchemaOptions, PropOptions, DatabaseAdapter, AdapterName, DBConfig, AdapterFeature, AdapterCapabilities, EnvVarRequirement, DatabaseMagnetProvider, QueryBuilder, FilterQuery, SortQuery, ProjectionQuery, BaseSchema, PaginatedResult } from '@magnet-cms/common';
+import { Type, DynamicModule } from '@nestjs/common';
+import { pgTable, PgDatabase, PgQueryResultHKT, PgTable } from 'drizzle-orm/pg-core';
+import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+
+/**
+ * Drizzle-specific Schema decorator.
+ * Stores metadata that will be used to generate Drizzle table schemas.
+ *
+ * This is called by the common @Schema() decorator after detecting
+ * that Drizzle is the active database adapter.
+ */
+declare function Schema(options?: SchemaOptions): ClassDecorator;
+/**
+ * Get Drizzle schema metadata from a class
+ */
+declare function getDrizzleSchemaMetadata(target: Function): {
+    name: string;
+    tableName: string;
+    i18n: boolean;
+    versioning: boolean;
+} | null;
+
+/**
+ * Drizzle-specific Prop decorator.
+ * Stores property metadata that will be used to generate Drizzle column definitions.
+ *
+ * This is called by the common @Prop() decorator after detecting
+ * that Drizzle is the active database adapter.
+ */
+declare function Prop(options?: PropOptions): PropertyDecorator;
+/**
+ * Get Drizzle property metadata from a class
+ */
+declare function getDrizzlePropsMetadata(target: Function): Map<string | symbol, PropOptions>;
+
+declare function InjectModel(schema: Type): ParameterDecorator;
+
+/**
+ * Get or generate a Drizzle table schema from a class
+ */
+declare function getOrGenerateSchema(schemaClass: Type): {
+    table: ReturnType<typeof pgTable>;
+    tableName: string;
+};
+/**
+ * Generate a Drizzle table schema from a decorated class
+ */
+declare function generateSchema(schemaClass: Type): {
+    table: ReturnType<typeof pgTable>;
+    tableName: string;
+};
+/**
+ * Get all registered schemas (read-only view of the registry)
+ */
+declare function getRegisteredSchemas(): ReadonlyMap<string, {
+    table: ReturnType<typeof pgTable>;
+    tableName: string;
+}>;
+/**
+ * Clear the schema registry (useful for testing)
+ */
+declare function clearSchemaRegistry(): void;
+
+/**
+ * Options for document columns
+ */
+interface DocumentColumnOptions {
+    /** Whether i18n is enabled */
+    hasI18n: boolean;
+    /** Whether versioning is enabled */
+    hasVersioning: boolean;
+}
+/**
+ * Document status enum values
+ */
+declare const DOCUMENT_STATUS: {
+    readonly DRAFT: "draft";
+    readonly PUBLISHED: "published";
+    readonly ARCHIVED: "archived";
+};
+type DocumentStatus = (typeof DOCUMENT_STATUS)[keyof typeof DOCUMENT_STATUS];
+/**
+ * Default locale
+ */
+declare const DEFAULT_LOCALE = "en";
+/**
+ * Apply document columns for i18n and versioning support.
+ * This mirrors the Mongoose document plugin behavior.
+ *
+ * Adds the following columns:
+ * - documentId: Groups all locale variants and versions of the same logical document
+ * - locale: The locale of this document variant (e.g., 'en', 'pt-BR')
+ * - status: The status of this document ('draft', 'published', 'archived')
+ * - publishedAt: When this document was published (if applicable)
+ */
+declare function applyDocumentColumns(options: DocumentColumnOptions): Record<string, any>;
+/**
+ * Check if a record is a draft
+ */
+declare function isDraft(record: {
+    status?: string;
+}): boolean;
+/**
+ * Check if a record is published
+ */
+declare function isPublished(record: {
+    status?: string;
+}): boolean;
+
+/**
+ * Supported SQL dialects for migrations
+ */
+type MigrationDialect = 'postgresql' | 'mysql' | 'sqlite';
+/**
+ * Migration mode:
+ * - 'auto': Auto-generate and apply migrations on startup (development)
+ * - 'manual': Only apply migrations via CLI (production)
+ */
+type MigrationMode = 'auto' | 'manual';
+/**
+ * Configuration for the migration system
+ */
+interface MigrationConfig {
+    /**
+     * Migration mode — 'auto' for development, 'manual' for production
+     * @default 'auto'
+     */
+    mode: MigrationMode;
+    /**
+     * Directory where migration files are stored
+     * @default './migrations'
+     */
+    directory: string;
+    /**
+     * Table name for tracking applied migrations
+     * @default '_magnet_migrations'
+     */
+    tableName: string;
+    /**
+     * Table name for migration lock
+     * @default '_magnet_migrations_lock'
+     */
+    lockTableName: string;
+    /**
+     * Timeout for acquiring migration lock (ms)
+     * @default 30000
+     */
+    lockTimeout: number;
+    /**
+     * Whether to run each migration in a transaction
+     * @default true
+     */
+    transactional: boolean;
+}
+/**
+ * Default migration configuration
+ */
+declare const DEFAULT_MIGRATION_CONFIG: MigrationConfig;
+/**
+ * A database connection used to execute migration SQL.
+ * Accept any object with an execute method for maximum compatibility.
+ */
+interface MigrationDb {
+    execute(sql: string, params?: unknown[]): Promise<unknown>;
+}
+/**
+ * A single migration with up and down functions
+ */
+interface Migration {
+    /** Unique identifier (usually filename without extension) */
+    id: string;
+    /** Unix timestamp when migration was created */
+    timestamp: number;
+    /** Human-readable description */
+    description?: string;
+    /** Flag for dangerous operations (drops, type changes) */
+    dangerous?: boolean;
+    /** Warning messages for dangerous operations */
+    warnings?: string[];
+    /** Apply the migration */
+    up(db: MigrationDb): Promise<void>;
+    /** Revert the migration */
+    down(db: MigrationDb): Promise<void>;
+}
+/**
+ * Record of an applied migration stored in the history table
+ */
+interface MigrationHistoryRecord {
+    /** Migration ID */
+    id: string;
+    /** Migration name (same as id) */
+    name: string;
+    /** Unix timestamp when migration was created */
+    timestamp: number;
+    /** When this migration was applied */
+    appliedAt: Date;
+    /** Checksum of the migration functions at time of application */
+    checksum: string;
+}
+/**
+ * Column change descriptor for diffing
+ */
+interface ColumnChange {
+    /** Table name */
+    table: string;
+    /** Column name */
+    column: string;
+    /** SQL type */
+    type?: string;
+    /** Whether column is nullable */
+    nullable?: boolean;
+    /** Default value */
+    default?: string;
+    /** Old column name (for renames) */
+    oldColumn?: string;
+    /** Old type (for type changes) */
+    oldType?: string;
+}
+/**
+ * Index descriptor for diffing
+ */
+interface IndexChange {
+    /** Index name */
+    name: string;
+    /** Table name */
+    table: string;
+    /** Column names */
+    columns: string[];
+    /** Whether unique */
+    unique?: boolean;
+}
+/**
+ * Result of comparing decorator schemas against database state
+ */
+interface DiffResult {
+    /** Tables to create */
+    tablesToCreate: TableDefinition[];
+    /** Table names to drop */
+    tablesToDrop: string[];
+    /** Columns to add */
+    columnsToAdd: ColumnChange[];
+    /** Columns to remove */
+    columnsToRemove: ColumnChange[];
+    /** Columns to alter (type/nullable/default changes) */
+    columnsToAlter: ColumnChange[];
+    /** Indexes to add */
+    indexesToAdd: IndexChange[];
+    /** Index names to remove */
+    indexesToRemove: string[];
+    /** Whether there are no changes */
+    isEmpty: boolean;
+}
+/**
+ * Full table definition for CREATE TABLE
+ */
+interface TableDefinition {
+    /** Table name */
+    name: string;
+    /** Column definitions */
+    columns: ColumnChange[];
+    /** Index definitions */
+    indexes: IndexChange[];
+}
+/**
+ * Result of running migrations
+ */
+interface MigrationResult {
+    /** Number of migrations applied */
+    applied: number;
+    /** Names of applied migrations */
+    names: string[];
+    /** Time taken per migration in ms */
+    timings: Record<string, number>;
+}
+/**
+ * Base migration error
+ */
+declare class MigrationError extends Error {
+    readonly migrationId: string;
+    readonly cause?: Error | undefined;
+    constructor(message: string, migrationId: string, cause?: Error | undefined);
+}
+/**
+ * Thrown when the migration lock cannot be acquired
+ */
+declare class MigrationLockError extends MigrationError {
+    constructor(migrationId?: string);
+}
+/**
+ * Thrown when a migration file's checksum differs from what was recorded
+ */
+declare class MigrationChecksumError extends MigrationError {
+    constructor(migrationId: string, expected: string, actual: string);
+}
+
+/**
+ * Drizzle configuration for MagnetModuleOptions
+ */
+interface DrizzleConfig {
+    /** Database connection string */
+    connectionString: string;
+    /** SQL dialect to use */
+    dialect: 'postgresql' | 'mysql' | 'sqlite';
+    /** Database driver to use (auto-detected if not specified) */
+    driver?: 'pg' | 'neon' | 'mysql2' | 'better-sqlite3';
+    /** Enable debug logging */
+    debug?: boolean;
+    /**
+     * Migration configuration. If omitted, falls back to legacy CREATE TABLE IF NOT EXISTS behavior.
+     */
+    migrations?: Partial<MigrationConfig>;
+}
+/**
+ * Supported Drizzle database types.
+ * MySQL and SQLite connections are cast to this type at runtime for API compatibility.
+ */
+type DrizzleDB = NodePgDatabase | PgDatabase<PgQueryResultHKT, Record<string, never>>;
+/**
+ * Schema metadata stored via decorators
+ */
+interface SchemaMetadata {
+    /** Schema class name */
+    name: string;
+    /** Whether i18n is enabled (default: true) */
+    i18n?: boolean;
+    /** Whether versioning is enabled (default: false) */
+    versioning?: boolean;
+    /** Table name (defaults to lowercase pluralized class name) */
+    tableName?: string;
+}
+/**
+ * Property metadata stored via decorators
+ */
+interface PropMetadata {
+    /** Property name */
+    name: string;
+    /** Property type */
+    type?: any;
+    /** Whether the property is required */
+    required?: boolean;
+    /** Whether the property is unique */
+    unique?: boolean;
+    /** Default value */
+    default?: any;
+    /** Whether the property is nullable */
+    nullable?: boolean;
+    /** Whether the property supports i18n */
+    intl?: boolean;
+    /** Whether the property is hidden from API responses */
+    hidden?: boolean;
+    /** Whether the property is readonly */
+    readonly?: boolean;
+    /** Reference to another schema (for relationships) */
+    ref?: string;
+    /** Description for documentation */
+    description?: string;
+}
+/**
+ * Generated Drizzle table schema
+ */
+interface GeneratedSchema {
+    /** The Drizzle table definition */
+    table: any;
+    /** The schema class reference */
+    schemaClass: any;
+    /** Schema metadata */
+    metadata: SchemaMetadata;
+    /** Property metadata map */
+    properties: Map<string, PropMetadata>;
+}
+/**
+ * Drizzle module options for NestJS dynamic module
+ */
+interface DrizzleModuleOptions {
+    /** Drizzle database instance */
+    db: DrizzleDB;
+    /** Configuration */
+    config: DrizzleConfig;
+}
+
+/**
+ * Create a Neon serverless database connection.
+ * Uses @neondatabase/serverless for edge/serverless deployments.
+ *
+ * @example
+ * ```typescript
+ * const db = await createNeonConnection({
+ *   connectionString: process.env.DATABASE_URL,
+ *   dialect: 'postgresql',
+ *   driver: 'neon',
+ * })
+ * ```
+ */
+declare function createNeonConnection(config: DrizzleConfig): Promise<{
+    db: any;
+    pool: null;
+}>;
+/**
+ * Create a Neon WebSocket connection for pooled/session mode.
+ * Better for long-running processes with connection pooling.
+ */
+declare function createNeonWebSocketConnection(config: DrizzleConfig): Promise<{
+    db: any;
+    pool: any;
+}>;
+
+/**
+ * Injection tokens
+ */
+declare const DRIZZLE_DB = "DRIZZLE_DB";
+declare const DRIZZLE_CONFIG = "DRIZZLE_CONFIG";
+/**
+ * Get model token for a schema
+ * @deprecated Use getModelToken from @magnet-cms/common instead
+ */
+declare function getDrizzleModelToken(schema: string): string;
+/**
+ * Drizzle ORM adapter for Magnet CMS.
+ * Supports PostgreSQL, MySQL, and SQLite through Drizzle ORM.
+ *
+ * @example
+ * ```typescript
+ * MagnetModule.forRoot([
+ *   DrizzleDatabaseAdapter.forRoot({ dialect: 'postgresql' }),
+ * ])
+ * ```
+ */
+declare class DrizzleDatabaseAdapter extends DatabaseAdapter {
+    readonly name: AdapterName;
+    private db;
+    private pool;
+    private options;
+    private schemaRegistry;
+    private tablesInitialized;
+    /**
+     * Automatically create tables for all registered schemas.
+     * Called lazily when first model is accessed, or can be called explicitly.
+     */
+    ensureTablesCreated(): Promise<void>;
+    /**
+     * Run the auto-migration system when `config.migrations` is configured.
+     */
+    private runAutoMigration;
+    /**
+     * Create tables for all registered schemas in the database.
+     * Uses Drizzle's getTableConfig to generate CREATE TABLE IF NOT EXISTS statements.
+     */
+    private createTables;
+    /**
+     * Quote identifier for the given dialect.
+     */
+    private quoteIdent;
+    /**
+     * Generate and execute CREATE TABLE IF NOT EXISTS statement from table config.
+     */
+    private createTableFromConfig;
+    /**
+     * Map PostgreSQL SQL types to dialect-specific types.
+     */
+    private mapSQLTypeForDialect;
+    /**
+     * Infer SQL type from column definition when getSQLType() is not available.
+     */
+    private inferSQLType;
+    /**
+     * Format default value for SQL DEFAULT clause.
+     */
+    private formatDefaultValue;
+    /**
+     * Connect to the database and return a NestJS dynamic module.
+     * Supports both synchronous (pg) and asynchronous (neon) drivers.
+     */
+    connect(config: DBConfig): DynamicModule;
+    /**
+     * Register schemas and return a NestJS dynamic module with model providers.
+     * Note: Providers return raw { db, table, schemaClass } for the model() method to wrap.
+     */
+    forFeature(schemas: Type | Type[]): DynamicModule;
+    /**
+     * Create a Model class from raw model data or a factory (for lazy init).
+     * Core's DatabaseModule passes an async factory; we support both.
+     */
+    model<T>(modelDataOrFactory: {
+        db: DrizzleDB;
+        table: PgTable;
+        schemaClass: Type;
+    } | (() => Promise<{
+        db: DrizzleDB;
+        table: PgTable;
+        schemaClass: Type;
+    }>)): any;
+    /**
+     * Create a model class that lazily resolves the factory (used by core's DatabaseModule).
+     */
+    private createLazyModel;
+    /**
+     * Get the injection token for a schema.
+     */
+    token(schema: string): string;
+    /**
+     * Get the database instance (for advanced usage).
+     */
+    getDb(): DrizzleDB | null;
+    /**
+     * Check if adapter supports a feature
+     */
+    supports(feature: AdapterFeature): boolean;
+    /**
+     * Get adapter capabilities
+     */
+    getCapabilities(): AdapterCapabilities;
+    /**
+     * Create database connection based on config (synchronous, for pg/mysql/sqlite drivers).
+     */
+    private createConnection;
+    /**
+     * Create database connection asynchronously (required for Neon driver).
+     */
+    private createConnectionAsync;
+    /**
+     * Graceful shutdown - close database connections.
+     */
+    onModuleDestroy(): Promise<void>;
+    /** Environment variables required by this adapter */
+    static readonly envVars: EnvVarRequirement[];
+    /**
+     * Create a configured database provider for MagnetModule.forRoot().
+     * Auto-resolves the connection string from DATABASE_URL env var if not provided.
+     *
+     * @param config - Optional Drizzle configuration. If omitted, reads from DATABASE_URL env var.
+     * @returns A DatabaseMagnetProvider to pass to MagnetModule.forRoot()
+     */
+    static forRoot(config?: Partial<DrizzleConfig>): DatabaseMagnetProvider;
+    /**
+     * Get the singleton adapter instance.
+     * @internal Used by DatabaseModule for forFeature() calls.
+     */
+    static getInstance(): DrizzleDatabaseAdapter;
+}
+/**
+ * @deprecated Use DrizzleDatabaseAdapter instead.
+ * Kept temporarily for internal compatibility during migration.
+ */
+declare const Adapter: DrizzleDatabaseAdapter;
+
+/**
+ * Drizzle implementation of QueryBuilder for fluent database queries.
+ * Provides chainable methods for filtering, sorting, pagination, and projection.
+ *
+ * @example
+ * ```typescript
+ * const users = await userModel.query()
+ *   .where({ status: 'active', age: { $gte: 18 } })
+ *   .sort({ createdAt: -1 })
+ *   .limit(10)
+ *   .skip(20)
+ *   .exec()
+ * ```
+ */
+/**
+ * Lazy query builder that buffers chainable operations synchronously
+ * and replays them on the real DrizzleQueryBuilder when a terminal
+ * method (exec, execOne, count, exists, paginate) is called.
+ *
+ * This solves the problem where LazyDrizzleModelAdapter.query() needs
+ * to return a synchronous, chainable object even though the underlying
+ * model requires async initialization.
+ */
+declare class LazyQueryBuilder<T> extends QueryBuilder<T> {
+    private readonly factory;
+    private operations;
+    constructor(factory: () => Promise<DrizzleQueryBuilder<T>>);
+    where(filter: FilterQuery<T>): this;
+    and(filter: FilterQuery<T>): this;
+    or(filters: FilterQuery<T>[]): this;
+    sort(sort: SortQuery<T>): this;
+    limit(count: number): this;
+    skip(count: number): this;
+    select(projection: ProjectionQuery<T>): this;
+    locale(loc: string): this;
+    version(versionId: string): this;
+    exec(): Promise<BaseSchema<T>[]>;
+    execOne(): Promise<BaseSchema<T> | null>;
+    count(): Promise<number>;
+    exists(): Promise<boolean>;
+    paginate(): Promise<PaginatedResult<BaseSchema<T>>>;
+    private buildChain;
+}
+declare class DrizzleQueryBuilder<T> extends QueryBuilder<T> {
+    private readonly db;
+    private readonly table;
+    private filterConditions;
+    private sortSpecs;
+    private selectedColumns;
+    private limitValue?;
+    private skipValue?;
+    private currentLocale?;
+    private currentVersion?;
+    constructor(db: DrizzleDB, table: PgTable, locale?: string, version?: string);
+    /**
+     * Add filter conditions to the query.
+     * Supports MongoDB-style operators like $gt, $lt, $in, $regex, etc.
+     */
+    where(filter: FilterQuery<T>): this;
+    /**
+     * Add additional AND conditions
+     */
+    and(filter: FilterQuery<T>): this;
+    /**
+     * Add OR conditions
+     */
+    or(filters: FilterQuery<T>[]): this;
+    /**
+     * Sort results by specified fields.
+     * Values can be 1 (asc), -1 (desc), 'asc', or 'desc'.
+     */
+    sort(sort: SortQuery<T>): this;
+    /**
+     * Limit the number of results
+     */
+    limit(count: number): this;
+    /**
+     * Skip a number of results (for pagination)
+     */
+    skip(count: number): this;
+    /**
+     * Select specific fields to return
+     */
+    select(projection: ProjectionQuery<T>): this;
+    /**
+     * Set the locale for query results
+     */
+    locale(locale: string): this;
+    /**
+     * Set the version filter for query
+     */
+    version(versionId: string): this;
+    /**
+     * Execute the query and return all matching documents
+     */
+    exec(): Promise<BaseSchema<T>[]>;
+    /**
+     * Execute the query and return a single document
+     */
+    execOne(): Promise<BaseSchema<T> | null>;
+    /**
+     * Count matching documents without fetching them
+     */
+    count(): Promise<number>;
+    /**
+     * Check if any matching documents exist
+     */
+    exists(): Promise<boolean>;
+    /**
+     * Execute with pagination info
+     */
+    paginate(): Promise<PaginatedResult<BaseSchema<T>>>;
+    /**
+     * Map MongoDB-style filter operators to Drizzle conditions.
+     * Note: Uses DynamicTableColumn for column references due to dynamic column access.
+     */
+    private mapFilter;
+    /**
+     * Map a single operator to a Drizzle condition.
+     * Note: Uses DynamicTableColumn for column parameter due to dynamic column access.
+     */
+    private mapOperator;
+    /**
+     * Map a database row to a result with camelCase keys
+     */
+    private mapResult;
+}
+
+/**
+ * Manages the migration history table (_magnet_migrations).
+ * Tracks which migrations have been applied, records checksums for validation.
+ */
+declare class MigrationHistory {
+    private readonly db;
+    private readonly tableName;
+    constructor(db: MigrationDb, tableName: string);
+    /**
+     * Ensure the migrations history table exists.
+     */
+    ensureTable(): Promise<void>;
+    /**
+     * Get all applied migrations ordered by timestamp.
+     */
+    getApplied(): Promise<MigrationHistoryRecord[]>;
+    /**
+     * Record a newly applied migration.
+     */
+    recordMigration(record: MigrationHistoryRecord): Promise<void>;
+    /**
+     * Remove a migration record (for rollback).
+     */
+    removeMigration(id: string): Promise<void>;
+    /**
+     * Calculate a 16-char checksum (SHA-256 truncated) for a migration's up+down functions.
+     */
+    static calculateChecksum(up: (db: MigrationDb) => Promise<void>, down: (db: MigrationDb) => Promise<void>): string;
+}
+
+/**
+ * Manages the migration lock table to prevent concurrent migrations.
+ * Uses a simple INSERT-based locking with timeout for stale lock cleanup.
+ */
+declare class MigrationLock {
+    private readonly db;
+    private readonly tableName;
+    private readonly lockTimeout;
+    constructor(db: MigrationDb, tableName: string, lockTimeout: number);
+    /**
+     * Ensure the lock table exists.
+     */
+    ensureTable(): Promise<void>;
+    /**
+     * Check if a valid (non-expired) lock exists.
+     */
+    isLocked(): Promise<boolean>;
+    /**
+     * Acquire the migration lock.
+     * Cleans up stale locks (older than lockTimeout) before attempting to lock.
+     * Throws MigrationLockError if another valid lock exists.
+     */
+    acquire(): Promise<void>;
+    /**
+     * Release the migration lock.
+     */
+    release(): Promise<void>;
+}
+
+/**
+ * Orchestrates migration execution: acquires lock, validates checksums,
+ * runs pending migrations in order, and releases lock on completion or error.
+ */
+declare class MigrationRunner {
+    private readonly db;
+    private readonly config;
+    private readonly history;
+    private readonly lock;
+    constructor(db: MigrationDb, config: MigrationConfig);
+    /**
+     * Apply all pending migrations (or up to a specific migration ID).
+     */
+    up(migrations: Migration[], options?: {
+        to?: string;
+    }): Promise<MigrationResult>;
+    /**
+     * Roll back applied migrations. Without options, rolls back the last one.
+     * With options.to, rolls back all migrations after the target (exclusive).
+     */
+    down(migrations: Migration[], options?: {
+        to?: string;
+    }): Promise<void>;
+    /**
+     * Return the current migration status.
+     */
+    status(migrations: Migration[]): Promise<{
+        applied: MigrationHistoryRecord[];
+        pending: Migration[];
+    }>;
+}
+
+/**
+ * Default filename for persisted schema snapshot (used by auto-migration).
+ */
+declare const SNAPSHOT_FILENAME = ".schema_snapshot.json";
+/**
+ * A drizzle snapshot JSON (opaque to us — owned by drizzle-kit)
+ */
+type SnapshotJSON = Record<string, unknown> & {
+    id: string;
+    prevId: string;
+    dialect: string;
+};
+/**
+ * Function signature for drizzle-kit's programmatic generateDrizzleJson / generateSQLiteDrizzleJson / generateMySQLDrizzleJson
+ */
+type GenerateJsonFn = (imports: Record<string, unknown>, prevId?: string) => Promise<SnapshotJSON>;
+/**
+ * Function signature for drizzle-kit's programmatic generateMigration / generateSQLiteMigration / generateMySQLMigration
+ */
+type GenerateSQLFn = (prev: SnapshotJSON, cur: SnapshotJSON) => Promise<string[]>;
+/**
+ * Bridges Magnet's decorator-generated Drizzle schemas to drizzle-kit's
+ * programmatic API for schema snapshotting and SQL diff generation.
+ */
+declare class SchemaBridge {
+    /**
+     * Collect all registered schemas from the schema registry into a plain record
+     * suitable for passing to drizzle-kit's `generateDrizzleJson`.
+     */
+    collectSchemas(): Record<string, unknown>;
+    /**
+     * Generate a drizzle-kit snapshot for the current schemas.
+     *
+     * @param dialect - SQL dialect to use
+     * @param generateJsonFn - drizzle-kit's programmatic generateDrizzleJson function
+     *   (injected for testability; defaults to importing from drizzle-kit/api at runtime)
+     */
+    generateSnapshot(dialect: MigrationDialect, generateJsonFn?: GenerateJsonFn): Promise<SnapshotJSON>;
+    /**
+     * Generate SQL statements to migrate from `prev` snapshot to `cur` snapshot.
+     *
+     * @param prev - Previous snapshot (empty for first migration)
+     * @param cur - Current snapshot
+     * @param generateSQLFn - drizzle-kit's programmatic generateMigration function
+     *   (injected for testability; defaults to importing from drizzle-kit/api at runtime)
+     */
+    generateSQL(prev: SnapshotJSON, cur: SnapshotJSON, generateSQLFn?: GenerateSQLFn, dialect?: MigrationDialect): Promise<string[]>;
+    /**
+     * Load a previously saved snapshot from disk.
+     * Returns null if the file does not exist or is invalid.
+     */
+    loadSnapshot(directory: string): Promise<SnapshotJSON | null>;
+    /**
+     * Save a snapshot to disk for use as prevSnapshot on the next run.
+     */
+    saveSnapshot(directory: string, snapshot: SnapshotJSON): Promise<void>;
+    /**
+     * Generate an empty snapshot to use as the "previous" state for the first migration.
+     */
+    emptySnapshot(dialect: MigrationDialect): SnapshotJSON;
+    private resolveGenerateJsonFn;
+    private resolveGenerateSQLFn;
+}
+
+/**
+ * Result of a schema diff operation
+ */
+interface SchemaDiffResult {
+    /** SQL statements for the up migration */
+    upSQL: string[];
+    /** Whether this diff contains dangerous operations */
+    dangerous: boolean;
+    /** Warning messages for dangerous operations */
+    warnings: string[];
+    /** Whether there are no changes */
+    isEmpty: boolean;
+    /** The current schema snapshot */
+    currentSnapshot: SnapshotJSON;
+}
+/**
+ * Diffs the current decorator schemas against a previous snapshot
+ * using drizzle-kit's programmatic API.
+ */
+declare class SchemaDiff {
+    private readonly bridge;
+    constructor(bridge: SchemaBridge);
+    /**
+     * Generate a diff between the previous snapshot and the current schema state.
+     *
+     * @param dialect - SQL dialect to use
+     * @param prevSnapshot - Previous snapshot (uses empty snapshot if not provided)
+     */
+    diff(dialect: MigrationDialect, prevSnapshot?: SnapshotJSON): Promise<SchemaDiffResult>;
+    /**
+     * Scan SQL statements for dangerous operations (drops, type changes).
+     */
+    detectDangerousOperations(sqlStatements: string[]): {
+        dangerous: boolean;
+        warnings: string[];
+    };
+}
+
+interface MigrationGenerateOptions {
+    dangerous?: boolean;
+    warnings?: string[];
+}
+/**
+ * Generates TypeScript migration files from SQL statements.
+ */
+declare class MigrationGenerator {
+    /**
+     * Generate the TypeScript content of a migration file.
+     */
+    generate(name: string, upSQL: string[], downSQL: string[], options?: MigrationGenerateOptions): string;
+    /**
+     * Determine the next sequential migration number for a directory.
+     * Returns 1 if the directory is empty, otherwise the highest number + 1.
+     */
+    nextMigrationNumber(directory: string): Promise<number>;
+    /**
+     * Write a migration file to the directory with sequential numbering.
+     */
+    writeMigrationFile(directory: string, name: string, content: string): Promise<{
+        filename: string;
+        path: string;
+    }>;
+}
+
+/**
+ * PostgreSQL-specific SQL generation helpers.
+ * Primary SQL generation is handled by drizzle-kit's generateMigration/generateDrizzleJson.
+ * These helpers are for manual SQL generation when needed.
+ */
+interface ColumnDef {
+    name: string;
+    type: string;
+    nullable?: boolean;
+    default?: string;
+    primaryKey?: boolean;
+}
+interface IndexDef {
+    name: string;
+    table: string;
+    columns: string[];
+    unique?: boolean;
+}
+/**
+ * Generate CREATE TABLE SQL for PostgreSQL
+ */
+declare function createTable$2(tableName: string, columns: ColumnDef[]): string;
+/**
+ * Generate DROP TABLE SQL for PostgreSQL
+ */
+declare function dropTable$2(tableName: string): string;
+/**
+ * Generate ADD COLUMN SQL for PostgreSQL
+ */
+declare function addColumn$2(tableName: string, column: ColumnDef): string;
+/**
+ * Generate DROP COLUMN SQL for PostgreSQL
+ */
+declare function dropColumn$1(tableName: string, columnName: string): string;
+/**
+ * Generate ALTER COLUMN TYPE SQL for PostgreSQL
+ */
+declare function alterColumnType(tableName: string, columnName: string, newType: string): string;
+/**
+ * Generate CREATE INDEX SQL for PostgreSQL
+ */
+declare function createIndex$2(idx: IndexDef): string;
+/**
+ * Generate DROP INDEX SQL for PostgreSQL
+ */
+declare function dropIndex$2(indexName: string): string;
+
+type postgresql_ColumnDef = ColumnDef;
+type postgresql_IndexDef = IndexDef;
+declare const postgresql_alterColumnType: typeof alterColumnType;
+declare namespace postgresql {
+  export { type postgresql_ColumnDef as ColumnDef, type postgresql_IndexDef as IndexDef, addColumn$2 as addColumn, postgresql_alterColumnType as alterColumnType, createIndex$2 as createIndex, createTable$2 as createTable, dropColumn$1 as dropColumn, dropIndex$2 as dropIndex, dropTable$2 as dropTable };
+}
+
+/**
+ * MySQL-specific SQL generation helpers.
+ * Primary SQL generation is handled by drizzle-kit's generateMySQLMigration/generateMySQLDrizzleJson.
+ */
+
+/**
+ * Generate CREATE TABLE SQL for MySQL
+ */
+declare function createTable$1(tableName: string, columns: ColumnDef[]): string;
+/**
+ * Generate DROP TABLE SQL for MySQL
+ */
+declare function dropTable$1(tableName: string): string;
+/**
+ * Generate ADD COLUMN SQL for MySQL
+ */
+declare function addColumn$1(tableName: string, column: ColumnDef): string;
+/**
+ * Generate DROP COLUMN SQL for MySQL
+ */
+declare function dropColumn(tableName: string, columnName: string): string;
+/**
+ * Generate MODIFY COLUMN SQL for MySQL (used for type changes)
+ */
+declare function modifyColumn(tableName: string, column: ColumnDef): string;
+/**
+ * Generate CREATE INDEX SQL for MySQL
+ */
+declare function createIndex$1(idx: IndexDef): string;
+/**
+ * Generate DROP INDEX SQL for MySQL
+ */
+declare function dropIndex$1(indexName: string, tableName: string): string;
+
+type mysql_ColumnDef = ColumnDef;
+type mysql_IndexDef = IndexDef;
+declare const mysql_dropColumn: typeof dropColumn;
+declare const mysql_modifyColumn: typeof modifyColumn;
+declare namespace mysql {
+  export { type mysql_ColumnDef as ColumnDef, type mysql_IndexDef as IndexDef, addColumn$1 as addColumn, createIndex$1 as createIndex, createTable$1 as createTable, mysql_dropColumn as dropColumn, dropIndex$1 as dropIndex, dropTable$1 as dropTable, mysql_modifyColumn as modifyColumn };
+}
+
+/**
+ * SQLite-specific SQL generation helpers.
+ * Primary SQL generation is handled by drizzle-kit's generateSQLiteMigration/generateSQLiteDrizzleJson.
+ *
+ * Note: SQLite has limited ALTER TABLE support — no DROP COLUMN or MODIFY COLUMN.
+ * Complex schema changes require table recreation (rename old, create new, copy data, drop old).
+ */
+
+/**
+ * Generate CREATE TABLE SQL for SQLite
+ */
+declare function createTable(tableName: string, columns: ColumnDef[]): string;
+/**
+ * Generate DROP TABLE SQL for SQLite
+ */
+declare function dropTable(tableName: string): string;
+/**
+ * Generate ADD COLUMN SQL for SQLite
+ * Note: SQLite ADD COLUMN is limited — no NOT NULL without DEFAULT, no UNIQUE, no PRIMARY KEY
+ */
+declare function addColumn(tableName: string, column: ColumnDef): string;
+/**
+ * Generate CREATE INDEX SQL for SQLite
+ */
+declare function createIndex(idx: IndexDef): string;
+/**
+ * Generate DROP INDEX SQL for SQLite
+ */
+declare function dropIndex(indexName: string): string;
+
+type sqlite_ColumnDef = ColumnDef;
+type sqlite_IndexDef = IndexDef;
+declare const sqlite_addColumn: typeof addColumn;
+declare const sqlite_createIndex: typeof createIndex;
+declare const sqlite_createTable: typeof createTable;
+declare const sqlite_dropIndex: typeof dropIndex;
+declare const sqlite_dropTable: typeof dropTable;
+declare namespace sqlite {
+  export { type sqlite_ColumnDef as ColumnDef, type sqlite_IndexDef as IndexDef, sqlite_addColumn as addColumn, sqlite_createIndex as createIndex, sqlite_createTable as createTable, sqlite_dropIndex as dropIndex, sqlite_dropTable as dropTable };
+}
+
+type index_ColumnDef = ColumnDef;
+type index_IndexDef = IndexDef;
+declare const index_mysql: typeof mysql;
+declare const index_postgresql: typeof postgresql;
+declare const index_sqlite: typeof sqlite;
+declare namespace index {
+  export { type index_ColumnDef as ColumnDef, type index_IndexDef as IndexDef, index_mysql as mysql, index_postgresql as postgresql, index_sqlite as sqlite };
+}
+
+/**
+ * Handles automatic migration detection and application on adapter startup.
+ *
+ * In `auto` mode:  detects diff → generates migration file → applies it.
+ * In `manual` mode: detects diff → logs warning only (does not apply).
+ * No `migrations` config: caller falls back to legacy CREATE TABLE IF NOT EXISTS.
+ */
+declare class AutoMigration {
+    private readonly bridge;
+    private readonly diff;
+    private readonly gen;
+    private readonly runner;
+    constructor(bridge: SchemaBridge, diff: SchemaDiff, gen: MigrationGenerator, runner: MigrationRunner);
+    /**
+     * Check for schema changes and handle them based on the migration mode.
+     */
+    run(dialect: MigrationDialect, config: MigrationConfig, directory: string): Promise<void>;
+}
+
+export { Adapter, AutoMigration, type ColumnChange, DEFAULT_LOCALE, DEFAULT_MIGRATION_CONFIG, DOCUMENT_STATUS, DRIZZLE_CONFIG, DRIZZLE_DB, type DiffResult, type DocumentColumnOptions, type DocumentStatus, type DrizzleConfig, type DrizzleDB, DrizzleDatabaseAdapter, type DrizzleModuleOptions, DrizzleQueryBuilder, type GenerateJsonFn, type GenerateSQLFn, type GeneratedSchema, type IndexChange, InjectModel, LazyQueryBuilder, type Migration, MigrationChecksumError, type MigrationConfig, type MigrationDb, type MigrationDialect, MigrationError, type MigrationGenerateOptions, MigrationGenerator, MigrationHistory, type MigrationHistoryRecord, MigrationLock, MigrationLockError, type MigrationMode, type MigrationResult, MigrationRunner, Prop, type PropMetadata, SNAPSHOT_FILENAME, Schema, SchemaBridge, SchemaDiff, type SchemaDiffResult, type SchemaMetadata, type SnapshotJSON, type TableDefinition, applyDocumentColumns, clearSchemaRegistry, createNeonConnection, createNeonWebSocketConnection, generateSchema, getDrizzleModelToken, getDrizzlePropsMetadata, getDrizzleSchemaMetadata, getOrGenerateSchema, getRegisteredSchemas, isDraft, isPublished, index as sqlGenerators };