drizzle-multitenant 1.1.0 → 1.3.0

package/dist/migrator-B7oPKe73.d.ts

@@ -0,0 +1,1067 @@
+import { C as Config } from './types-CGqsPe2Q.js';
+import { Pool } from 'pg';
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+
+/**
+ * Table format for tracking migrations
+ * - "name": drizzle-multitenant native (filename-based)
+ * - "hash": SHA-256 hash with timestamp
+ * - "drizzle-kit": Exact drizzle-kit format (hash + bigint timestamp)
+ */
+type TableFormat = 'name' | 'hash' | 'drizzle-kit';
+/**
+ * Detected table format information
+ */
+interface DetectedFormat {
+    /** The detected format type */
+    format: TableFormat;
+    /** The table name */
+    tableName: string;
+    /** Column configuration */
+    columns: {
+        /** Column used for identifying migrations */
+        identifier: 'name' | 'hash';
+        /** Column used for timestamp */
+        timestamp: 'applied_at' | 'created_at';
+        /** Data type of timestamp column */
+        timestampType: 'timestamp' | 'bigint';
+    };
+}
+/**
+ * Default format configuration for new tables
+ */
+declare const DEFAULT_FORMAT: DetectedFormat;
+/**
+ * drizzle-kit format configuration
+ */
+declare const DRIZZLE_KIT_FORMAT: DetectedFormat;
+/**
+ * Detect the format of an existing migrations table
+ *
+ * @param pool - Database connection pool
+ * @param schemaName - Schema to check
+ * @param tableName - Migrations table name
+ * @returns Detected format or null if table doesn't exist
+ */
+declare function detectTableFormat(pool: Pool, schemaName: string, tableName: string): Promise<DetectedFormat | null>;
+/**
+ * Get the format configuration for a specific format type
+ */
+declare function getFormatConfig(format: TableFormat, tableName?: string): DetectedFormat;
+
+/**
+ * Types for tenant cloning module
+ * @module clone/types
+ */
+
+/**
+ * Value to use for anonymization (v1: null or fixed value)
+ */
+type AnonymizeValue = null | string | number | boolean;
+/**
+ * Anonymization rules by table and column
+ *
+ * @example
+ * ```typescript
+ * const rules: AnonymizeRules = {
+ *   users: {
+ *     email: null,
+ *     phone: null,
+ *     ssn: '000-00-0000',
+ *   },
+ *   payments: {
+ *     card_number: null,
+ *   },
+ * };
+ * ```
+ */
+interface AnonymizeRules {
+    [tableName: string]: {
+        [columnName: string]: AnonymizeValue;
+    };
+}
+/**
+ * Anonymization options
+ */
+interface AnonymizeOptions {
+    /** Enable anonymization */
+    enabled: boolean;
+    /** Rules per table/column */
+    rules?: AnonymizeRules;
+}
+/**
+ * Options for cloning a tenant
+ */
+interface CloneTenantOptions {
+    /** Include data (default: false, schema only) */
+    includeData?: boolean;
+    /** Anonymize sensitive data */
+    anonymize?: AnonymizeOptions;
+    /** Tables to exclude from cloning */
+    excludeTables?: string[];
+    /** Progress callback */
+    onProgress?: CloneProgressCallback;
+    /** Error handler */
+    onError?: (error: Error) => 'continue' | 'abort';
+}
+/**
+ * Progress status for cloning operation
+ */
+type CloneProgressStatus = 'starting' | 'introspecting' | 'creating_schema' | 'creating_tables' | 'creating_indexes' | 'creating_constraints' | 'copying_data' | 'completed' | 'failed';
+/**
+ * Progress callback for cloning
+ */
+type CloneProgressCallback = (status: CloneProgressStatus, details?: {
+    table?: string;
+    progress?: number;
+    total?: number;
+}) => void;
+/**
+ * Result of cloning a tenant
+ */
+interface CloneTenantResult {
+    /** Source tenant ID */
+    sourceTenant: string;
+    /** Target tenant ID */
+    targetTenant: string;
+    /** Target schema name */
+    targetSchema: string;
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Tables cloned */
+    tables: string[];
+    /** Number of rows copied (if includeData) */
+    rowsCopied?: number;
+    /** Duration in milliseconds */
+    durationMs: number;
+}
+/**
+ * Configuration for Cloner
+ */
+interface ClonerConfig {
+    /** Migrations table name (excluded from data copy) */
+    migrationsTable?: string;
+}
+/**
+ * Dependencies for Cloner
+ */
+interface ClonerDependencies {
+    /** Create pool for specific schema */
+    createPool: (schemaName: string) => Promise<Pool>;
+    /** Create pool without schema (root) */
+    createRootPool: () => Promise<Pool>;
+    /** Schema name template function */
+    schemaNameTemplate: (tenantId: string) => string;
+    /** Check if schema exists */
+    schemaExists: (tenantId: string) => Promise<boolean>;
+    /** Create schema */
+    createSchema: (tenantId: string) => Promise<void>;
+}
+
+/**
+ * Seed function signature
+ * Called with the tenant database instance and tenant ID
+ *
+ * @example
+ * ```typescript
+ * const seed: SeedFunction = async (db, tenantId) => {
+ *   await db.insert(roles).values([
+ *     { name: 'admin', permissions: ['*'] },
+ *     { name: 'user', permissions: ['read'] },
+ *   ]);
+ * };
+ * ```
+ */
+type SeedFunction<TSchema extends Record<string, unknown> = Record<string, unknown>> = (db: PostgresJsDatabase<TSchema>, tenantId: string) => Promise<void>;
+/**
+ * Seed result for a single tenant
+ */
+interface TenantSeedResult {
+    tenantId: string;
+    schemaName: string;
+    success: boolean;
+    error?: string;
+    durationMs: number;
+}
+/**
+ * Aggregate seed results
+ */
+interface SeedResults {
+    total: number;
+    succeeded: number;
+    failed: number;
+    skipped: number;
+    details: TenantSeedResult[];
+}
+/**
+ * Options for seed operations
+ */
+interface SeedOptions {
+    /** Number of concurrent seed operations */
+    concurrency?: number;
+    /** Progress callback */
+    onProgress?: (tenantId: string, status: 'starting' | 'seeding' | 'completed' | 'failed' | 'skipped') => void;
+    /** Error handler */
+    onError?: (tenantId: string, error: Error) => 'continue' | 'abort';
+}
+/**
+ * Migration file metadata
+ */
+interface MigrationFile {
+    /** Migration file name */
+    name: string;
+    /** Full file path */
+    path: string;
+    /** SQL content */
+    sql: string;
+    /** Timestamp extracted from filename */
+    timestamp: number;
+    /** SHA-256 hash of file content (for drizzle-kit compatibility) */
+    hash: string;
+}
+/**
+ * Migration status for a tenant
+ */
+interface TenantMigrationStatus {
+    tenantId: string;
+    schemaName: string;
+    appliedCount: number;
+    pendingCount: number;
+    pendingMigrations: string[];
+    status: 'ok' | 'behind' | 'error';
+    error?: string;
+    /** Detected table format (null for new tenants without migrations table) */
+    format: TableFormat | null;
+}
+/**
+ * Migration result for a single tenant
+ */
+interface TenantMigrationResult {
+    tenantId: string;
+    schemaName: string;
+    success: boolean;
+    appliedMigrations: string[];
+    error?: string;
+    durationMs: number;
+    /** Table format used for this migration */
+    format?: TableFormat;
+}
+/**
+ * Aggregate migration results
+ */
+interface MigrationResults {
+    total: number;
+    succeeded: number;
+    failed: number;
+    skipped: number;
+    details: TenantMigrationResult[];
+}
+/**
+ * Progress callback for migrations
+ */
+type MigrationProgressCallback = (tenantId: string, status: 'starting' | 'migrating' | 'completed' | 'failed' | 'skipped', migrationName?: string) => void;
+/**
+ * Error handler for migrations
+ */
+type MigrationErrorHandler = (tenantId: string, error: Error) => 'continue' | 'abort';
+/**
+ * Migration hooks
+ */
+interface MigrationHooks {
+    /** Called before migrating a tenant */
+    beforeTenant?: (tenantId: string) => void | Promise<void>;
+    /** Called after migrating a tenant */
+    afterTenant?: (tenantId: string, result: TenantMigrationResult) => void | Promise<void>;
+    /** Called before applying a migration */
+    beforeMigration?: (tenantId: string, migrationName: string) => void | Promise<void>;
+    /** Called after applying a migration */
+    afterMigration?: (tenantId: string, migrationName: string, durationMs: number) => void | Promise<void>;
+}
+/**
+ * Migrator configuration
+ */
+interface MigratorConfig {
+    /** Path to tenant migrations folder */
+    migrationsFolder: string;
+    /** Table name for tracking migrations */
+    migrationsTable?: string;
+    /** Function to discover tenant IDs */
+    tenantDiscovery: () => Promise<string[]>;
+    /** Migration hooks */
+    hooks?: MigrationHooks;
+    /**
+     * Table format for tracking migrations
+     * - "auto": Auto-detect existing format, use defaultFormat for new tables
+     * - "name": Use filename (drizzle-multitenant native)
+     * - "hash": Use SHA-256 hash
+     * - "drizzle-kit": Exact drizzle-kit format (hash + bigint timestamp)
+     * @default "auto"
+     */
+    tableFormat?: 'auto' | TableFormat;
+    /**
+     * When using "auto" format and no table exists, which format to create
+     * @default "name"
+     */
+    defaultFormat?: TableFormat;
+    /**
+     * Path to shared schema migrations folder
+     * If provided, enables shared schema migration support
+     */
+    sharedMigrationsFolder?: string;
+    /**
+     * Table name for tracking shared migrations
+     * @default "__drizzle_shared_migrations"
+     */
+    sharedMigrationsTable?: string;
+    /**
+     * Hooks for shared schema migrations
+     */
+    sharedHooks?: SharedMigrationHooks;
+}
+/**
+ * Migrate options
+ */
+interface MigrateOptions {
+    /** Number of concurrent migrations */
+    concurrency?: number;
+    /** Progress callback */
+    onProgress?: MigrationProgressCallback;
+    /** Error handler */
+    onError?: MigrationErrorHandler;
+    /** Dry run mode */
+    dryRun?: boolean;
+}
+/**
+ * Tenant creation options
+ */
+interface CreateTenantOptions {
+    /** Apply all migrations after creating schema */
+    migrate?: boolean;
+}
+/**
+ * Tenant drop options
+ */
+interface DropTenantOptions {
+    /** Skip confirmation (force drop) */
+    force?: boolean;
+    /** Cascade drop */
+    cascade?: boolean;
+}
+/**
+ * Applied migration record
+ */
+interface AppliedMigration {
+    id: number;
+    /** Migration identifier (name or hash depending on format) */
+    identifier: string;
+    /** Migration name (only available in name-based format) */
+    name?: string;
+    /** Migration hash (only available in hash-based format) */
+    hash?: string;
+    appliedAt: Date;
+}
+/**
+ * Sync status for a single tenant
+ */
+interface TenantSyncStatus {
+    tenantId: string;
+    schemaName: string;
+    /** Migrations in disk but not tracked in database */
+    missing: string[];
+    /** Migrations tracked in database but not found in disk */
+    orphans: string[];
+    /** Whether the tenant is in sync */
+    inSync: boolean;
+    /** Table format used */
+    format: TableFormat | null;
+    /** Error if any */
+    error?: string;
+}
+/**
+ * Aggregate sync status
+ */
+interface SyncStatus {
+    total: number;
+    inSync: number;
+    outOfSync: number;
+    error: number;
+    details: TenantSyncStatus[];
+}
+/**
+ * Sync result for a single tenant
+ */
+interface TenantSyncResult {
+    tenantId: string;
+    schemaName: string;
+    success: boolean;
+    /** Migrations that were marked as applied */
+    markedMigrations: string[];
+    /** Orphan records that were removed */
+    removedOrphans: string[];
+    error?: string;
+    durationMs: number;
+}
+/**
+ * Aggregate sync results
+ */
+interface SyncResults {
+    total: number;
+    succeeded: number;
+    failed: number;
+    details: TenantSyncResult[];
+}
+/**
+ * Options for sync operations
+ */
+interface SyncOptions {
+    /** Number of concurrent operations */
+    concurrency?: number;
+    /** Progress callback */
+    onProgress?: (tenantId: string, status: 'starting' | 'syncing' | 'completed' | 'failed') => void;
+    /** Error handler */
+    onError?: MigrationErrorHandler;
+}
+/**
+ * Column information from database introspection
+ */
+interface ColumnInfo {
+    /** Column name */
+    name: string;
+    /** PostgreSQL data type */
+    dataType: string;
+    /** Full data type (e.g., varchar(255)) */
+    udtName: string;
+    /** Whether column is nullable */
+    isNullable: boolean;
+    /** Default value expression */
+    columnDefault: string | null;
+    /** Character maximum length for varchar/char */
+    characterMaximumLength: number | null;
+    /** Numeric precision for numeric types */
+    numericPrecision: number | null;
+    /** Numeric scale for numeric types */
+    numericScale: number | null;
+    /** Ordinal position in table */
+    ordinalPosition: number;
+}
+/**
+ * Index information from database introspection
+ */
+interface IndexInfo {
+    /** Index name */
+    name: string;
+    /** Column names in the index */
+    columns: string[];
+    /** Whether index is unique */
+    isUnique: boolean;
+    /** Whether index is primary key */
+    isPrimary: boolean;
+    /** Index definition SQL */
+    definition: string;
+}
+/**
+ * Constraint information from database introspection
+ */
+interface ConstraintInfo {
+    /** Constraint name */
+    name: string;
+    /** Constraint type (PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK) */
+    type: 'PRIMARY KEY' | 'FOREIGN KEY' | 'UNIQUE' | 'CHECK';
+    /** Columns involved in constraint */
+    columns: string[];
+    /** Foreign table (for foreign keys) */
+    foreignTable?: string;
+    /** Foreign columns (for foreign keys) */
+    foreignColumns?: string[];
+    /** Check expression (for check constraints) */
+    checkExpression?: string;
+}
+/**
+ * Table schema information
+ */
+interface TableSchema {
+    /** Table name */
+    name: string;
+    /** Columns in the table */
+    columns: ColumnInfo[];
+    /** Indexes on the table */
+    indexes: IndexInfo[];
+    /** Constraints on the table */
+    constraints: ConstraintInfo[];
+}
+/**
+ * Full schema for a tenant
+ */
+interface TenantSchema {
+    /** Tenant ID */
+    tenantId: string;
+    /** Schema name */
+    schemaName: string;
+    /** Tables in the schema */
+    tables: TableSchema[];
+    /** Introspection timestamp */
+    introspectedAt: Date;
+}
+/**
+ * Column drift details
+ */
+interface ColumnDrift {
+    /** Column name */
+    column: string;
+    /** Type of drift */
+    type: 'missing' | 'extra' | 'type_mismatch' | 'nullable_mismatch' | 'default_mismatch';
+    /** Expected value (from reference) */
+    expected?: string | boolean | null;
+    /** Actual value (from tenant) */
+    actual?: string | boolean | null;
+    /** Human-readable description */
+    description: string;
+}
+/**
+ * Index drift details
+ */
+interface IndexDrift {
+    /** Index name */
+    index: string;
+    /** Type of drift */
+    type: 'missing' | 'extra' | 'definition_mismatch';
+    /** Expected definition */
+    expected?: string;
+    /** Actual definition */
+    actual?: string;
+    /** Human-readable description */
+    description: string;
+}
+/**
+ * Constraint drift details
+ */
+interface ConstraintDrift {
+    /** Constraint name */
+    constraint: string;
+    /** Type of drift */
+    type: 'missing' | 'extra' | 'definition_mismatch';
+    /** Expected details */
+    expected?: string;
+    /** Actual details */
+    actual?: string;
+    /** Human-readable description */
+    description: string;
+}
+/**
+ * Table drift details
+ */
+interface TableDrift {
+    /** Table name */
+    table: string;
+    /** Whether the entire table is missing or extra */
+    status: 'ok' | 'missing' | 'extra' | 'drifted';
+    /** Column drifts */
+    columns: ColumnDrift[];
+    /** Index drifts */
+    indexes: IndexDrift[];
+    /** Constraints drifts */
+    constraints: ConstraintDrift[];
+}
+/**
+ * Schema drift for a single tenant
+ */
+interface TenantSchemaDrift {
+    /** Tenant ID */
+    tenantId: string;
+    /** Schema name */
+    schemaName: string;
+    /** Whether schema has drift */
+    hasDrift: boolean;
+    /** Table-level drifts */
+    tables: TableDrift[];
+    /** Total number of issues */
+    issueCount: number;
+    /** Error if introspection failed */
+    error?: string;
+}
+/**
+ * Aggregate schema drift status
+ */
+interface SchemaDriftStatus {
+    /** Reference tenant used for comparison */
+    referenceTenant: string;
+    /** Total tenants checked */
+    total: number;
+    /** Tenants without drift */
+    noDrift: number;
+    /** Tenants with drift */
+    withDrift: number;
+    /** Tenants with errors */
+    error: number;
+    /** Detailed results per tenant */
+    details: TenantSchemaDrift[];
+    /** Timestamp of the check */
+    timestamp: string;
+    /** Duration of the check in ms */
+    durationMs: number;
+}
+/**
+ * Options for schema drift detection
+ */
+interface SchemaDriftOptions {
+    /** Tenant ID to use as reference (default: first tenant) */
+    referenceTenant?: string;
+    /** Specific tenant IDs to check (default: all tenants) */
+    tenantIds?: string[];
+    /** Number of concurrent checks */
+    concurrency?: number;
+    /** Whether to include index comparison */
+    includeIndexes?: boolean;
+    /** Whether to include constraint comparison */
+    includeConstraints?: boolean;
+    /** Tables to exclude from comparison */
+    excludeTables?: string[];
+    /** Progress callback */
+    onProgress?: (tenantId: string, status: 'starting' | 'introspecting' | 'comparing' | 'completed' | 'failed') => void;
+}
+
+/**
+ * Migration status for the shared schema (public)
+ */
+interface SharedMigrationStatus {
+    /** Schema name (usually 'public') */
+    schemaName: string;
+    /** Number of applied migrations */
+    appliedCount: number;
+    /** Number of pending migrations */
+    pendingCount: number;
+    /** Names of pending migrations */
+    pendingMigrations: string[];
+    /** Overall status */
+    status: 'ok' | 'behind' | 'error';
+    /** Error message if status is 'error' */
+    error?: string;
+    /** Detected table format */
+    format: TableFormat | null;
+}
+/**
+ * Migration result for the shared schema
+ */
+interface SharedMigrationResult {
+    /** Schema name (usually 'public') */
+    schemaName: string;
+    /** Whether migration was successful */
+    success: boolean;
+    /** List of applied migration names */
+    appliedMigrations: string[];
+    /** Error message if failed */
+    error?: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+    /** Table format used */
+    format?: TableFormat;
+}
+/**
+ * Shared migration configuration (extends MigratorConfig)
+ */
+interface SharedMigratorConfig {
+    /** Path to shared schema migrations folder */
+    sharedMigrationsFolder: string;
+    /** Table name for tracking shared migrations (default: '__drizzle_shared_migrations') */
+    sharedMigrationsTable?: string;
+    /** Migration hooks for shared schema */
+    hooks?: SharedMigrationHooks;
+    /**
+     * Table format for tracking migrations
+     * @default "auto"
+     */
+    tableFormat?: 'auto' | TableFormat;
+    /**
+     * Default format when creating new table
+     * @default "name"
+     */
+    defaultFormat?: TableFormat;
+}
+/**
+ * Hooks for shared schema migrations
+ */
+interface SharedMigrationHooks {
+    /** Called before starting shared migration */
+    beforeMigration?: () => void | Promise<void>;
+    /** Called after shared migration completes */
+    afterMigration?: (result: SharedMigrationResult) => void | Promise<void>;
+    /** Called before applying a specific migration */
+    beforeApply?: (migrationName: string) => void | Promise<void>;
+    /** Called after applying a specific migration */
+    afterApply?: (migrationName: string, durationMs: number) => void | Promise<void>;
+}
+/**
+ * Options for shared migration operations
+ */
+interface SharedMigrateOptions {
+    /** Dry run mode - show what would be applied without executing */
+    dryRun?: boolean;
+    /** Progress callback */
+    onProgress?: (status: 'starting' | 'migrating' | 'completed' | 'failed', migrationName?: string) => void;
+}
+/**
+ * Seed function signature for shared schema
+ * Called with the shared database instance
+ */
+type SharedSeedFunction<TSchema extends Record<string, unknown> = Record<string, unknown>> = (db: PostgresJsDatabase<TSchema>) => Promise<void>;
+/**
+ * Result of shared schema seeding
+ */
+interface SharedSeedResult {
+    /** Schema name (usually 'public') */
+    schemaName: string;
+    /** Whether seeding was successful */
+    success: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+}
+
+/**
+ * Parallel migration engine for multi-tenant applications
+ */
+declare class Migrator<TTenantSchema extends Record<string, unknown>, TSharedSchema extends Record<string, unknown>> {
+    private readonly migratorConfig;
+    private readonly migrationsTable;
+    private readonly schemaManager;
+    private readonly driftDetector;
+    private readonly seeder;
+    private readonly syncManager;
+    private readonly migrationExecutor;
+    private readonly batchExecutor;
+    private readonly cloner;
+    private readonly sharedMigrationExecutor;
+    private readonly sharedSeeder;
+    constructor(tenantConfig: Config<TTenantSchema, TSharedSchema>, migratorConfig: MigratorConfig);
+    /**
+     * Migrate all tenants in parallel
+     *
+     * Delegates to BatchExecutor for parallel migration operations.
+     */
+    migrateAll(options?: MigrateOptions): Promise<MigrationResults>;
+    /**
+     * Migrate a single tenant
+     *
+     * Delegates to MigrationExecutor for single tenant operations.
+     */
+    migrateTenant(tenantId: string, migrations?: MigrationFile[], options?: {
+        dryRun?: boolean;
+        onProgress?: MigrateOptions['onProgress'];
+    }): Promise<TenantMigrationResult>;
+    /**
+     * Migrate specific tenants
+     *
+     * Delegates to BatchExecutor for parallel migration operations.
+     */
+    migrateTenants(tenantIds: string[], options?: MigrateOptions): Promise<MigrationResults>;
+    /**
+     * Get migration status for all tenants
+     *
+     * Delegates to BatchExecutor for status operations.
+     */
+    getStatus(): Promise<TenantMigrationStatus[]>;
+    /**
+     * Get migration status for a specific tenant
+     *
+     * Delegates to MigrationExecutor for single tenant operations.
+     */
+    getTenantStatus(tenantId: string, migrations?: MigrationFile[]): Promise<TenantMigrationStatus>;
+    /**
+     * Create a new tenant schema and optionally apply migrations
+     */
+    createTenant(tenantId: string, options?: CreateTenantOptions): Promise<void>;
+    /**
+     * Drop a tenant schema
+     */
+    dropTenant(tenantId: string, options?: DropTenantOptions): Promise<void>;
+    /**
+     * Check if a tenant schema exists
+     */
+    tenantExists(tenantId: string): Promise<boolean>;
+    /**
+     * Clone a tenant to a new tenant
+     *
+     * By default, clones only schema structure. Use includeData to copy data.
+     *
+     * @example
+     * ```typescript
+     * // Schema-only clone
+     * await migrator.cloneTenant('production', 'dev');
+     *
+     * // Clone with data
+     * await migrator.cloneTenant('production', 'dev', { includeData: true });
+     *
+     * // Clone with anonymization
+     * await migrator.cloneTenant('production', 'dev', {
+     *   includeData: true,
+     *   anonymize: {
+     *     enabled: true,
+     *     rules: {
+     *       users: { email: null, phone: null },
+     *     },
+     *   },
+     * });
+     * ```
+     */
+    cloneTenant(sourceTenantId: string, targetTenantId: string, options?: CloneTenantOptions): Promise<CloneTenantResult>;
+    /**
+     * Mark migrations as applied without executing SQL
+     * Useful for syncing tracking state with already-applied migrations
+     *
+     * Delegates to MigrationExecutor for single tenant operations.
+     */
+    markAsApplied(tenantId: string, options?: {
+        onProgress?: MigrateOptions['onProgress'];
+    }): Promise<TenantMigrationResult>;
+    /**
+     * Mark migrations as applied for all tenants without executing SQL
+     * Useful for syncing tracking state with already-applied migrations
+     *
+     * Delegates to BatchExecutor for parallel operations.
+     */
+    markAllAsApplied(options?: MigrateOptions): Promise<MigrationResults>;
+    /**
+     * Get sync status for all tenants
+     * Detects divergences between migrations on disk and tracking in database
+     */
+    getSyncStatus(): Promise<SyncStatus>;
+    /**
+     * Get sync status for a specific tenant
+     */
+    getTenantSyncStatus(tenantId: string, migrations?: MigrationFile[]): Promise<TenantSyncStatus>;
+    /**
+     * Mark missing migrations as applied for a tenant
+     */
+    markMissing(tenantId: string): Promise<TenantSyncResult>;
+    /**
+     * Mark missing migrations as applied for all tenants
+     */
+    markAllMissing(options?: SyncOptions): Promise<SyncResults>;
+    /**
+     * Remove orphan migration records for a tenant
+     */
+    cleanOrphans(tenantId: string): Promise<TenantSyncResult>;
+    /**
+     * Remove orphan migration records for all tenants
+     */
+    cleanAllOrphans(options?: SyncOptions): Promise<SyncResults>;
+    /**
+     * Seed a single tenant with initial data
+     *
+     * @example
+     * ```typescript
+     * const seed: SeedFunction = async (db, tenantId) => {
+     *   await db.insert(roles).values([
+     *     { name: 'admin', permissions: ['*'] },
+     *     { name: 'user', permissions: ['read'] },
+     *   ]);
+     * };
+     *
+     * await migrator.seedTenant('tenant-123', seed);
+     * ```
+     */
+    seedTenant(tenantId: string, seedFn: SeedFunction<TTenantSchema>): Promise<TenantSeedResult>;
+    /**
+     * Seed all tenants with initial data in parallel
+     *
+     * @example
+     * ```typescript
+     * const seed: SeedFunction = async (db, tenantId) => {
+     *   await db.insert(roles).values([
+     *     { name: 'admin', permissions: ['*'] },
+     *   ]);
+     * };
+     *
+     * await migrator.seedAll(seed, { concurrency: 10 });
+     * ```
+     */
+    seedAll(seedFn: SeedFunction<TTenantSchema>, options?: SeedOptions): Promise<SeedResults>;
+    /**
+     * Seed specific tenants with initial data
+     */
+    seedTenants(tenantIds: string[], seedFn: SeedFunction<TTenantSchema>, options?: SeedOptions): Promise<SeedResults>;
+    /**
+     * Check if shared schema seeding is available
+     *
+     * @returns True if shared schema is configured
+     */
+    hasSharedSeeding(): boolean;
+    /**
+     * Seed the shared schema with initial data
+     *
+     * Seeds the public/shared schema with common data like plans, roles, permissions.
+     * Must have schemas.shared configured in the tenant config.
+     *
+     * @example
+     * ```typescript
+     * if (migrator.hasSharedSeeding()) {
+     *   const result = await migrator.seedShared(async (db) => {
+     *     await db.insert(plans).values([
+     *       { id: 'free', name: 'Free', price: 0 },
+     *       { id: 'pro', name: 'Pro', price: 29 },
+     *       { id: 'enterprise', name: 'Enterprise', price: 99 },
+     *     ]).onConflictDoNothing();
+     *
+     *     await db.insert(roles).values([
+     *       { name: 'admin', permissions: ['*'] },
+     *       { name: 'user', permissions: ['read'] },
+     *     ]).onConflictDoNothing();
+     *   });
+     *
+     *   if (result.success) {
+     *     console.log(`Seeded shared schema in ${result.durationMs}ms`);
+     *   }
+     * }
+     * ```
+     */
+    seedShared(seedFn: SharedSeedFunction<TSharedSchema>): Promise<SharedSeedResult>;
+    /**
+     * Seed shared schema first, then all tenants
+     *
+     * Convenience method for the common pattern of seeding shared tables
+     * before tenant tables.
+     *
+     * @example
+     * ```typescript
+     * const result = await migrator.seedAllWithShared(
+     *   async (db) => {
+     *     await db.insert(plans).values([{ id: 'free', name: 'Free' }]);
+     *   },
+     *   async (db, tenantId) => {
+     *     await db.insert(roles).values([{ name: 'admin' }]);
+     *   },
+     *   { concurrency: 10 }
+     * );
+     *
+     * if (result.shared.success) {
+     *   console.log('Shared seeding completed');
+     * }
+     * console.log(`Tenants: ${result.tenants.succeeded}/${result.tenants.total}`);
+     * ```
+     */
+    seedAllWithShared(sharedSeedFn: SharedSeedFunction<TSharedSchema>, tenantSeedFn: SeedFunction<TTenantSchema>, options?: SeedOptions): Promise<{
+        shared: SharedSeedResult;
+        tenants: SeedResults;
+    }>;
+    /**
+     * Load migration files from the migrations folder
+     */
+    private loadMigrations;
+    /**
+     * Get or detect the format for a schema
+     * Returns the configured format or auto-detects from existing table
+     *
+     * Note: This method is shared with SyncManager and MigrationExecutor via dependency injection.
+     */
+    private getOrDetectFormat;
+    /**
+     * Load shared migration files from the shared migrations folder
+     */
+    private loadSharedMigrations;
+    /**
+     * Get or detect the format for the shared schema
+     */
+    private getOrDetectSharedFormat;
+    /**
+     * Check if shared schema migrations are configured
+     *
+     * @returns True if sharedMigrationsFolder is configured and exists
+     */
+    hasSharedMigrations(): boolean;
+    /**
+     * Migrate the shared schema (public)
+     *
+     * Applies pending migrations to the shared/public schema.
+     * Must have sharedMigrationsFolder configured.
+     *
+     * @example
+     * ```typescript
+     * if (migrator.hasSharedMigrations()) {
+     *   const result = await migrator.migrateShared();
+     *   console.log(`Applied ${result.appliedMigrations.length} shared migrations`);
+     * }
+     * ```
+     */
+    migrateShared(options?: SharedMigrateOptions): Promise<SharedMigrationResult>;
+    /**
+     * Get migration status for the shared schema
+     *
+     * @returns Status with applied/pending counts
+     */
+    getSharedStatus(): Promise<SharedMigrationStatus>;
+    /**
+     * Mark shared schema migrations as applied without executing SQL
+     *
+     * Useful for syncing tracking state with already-applied migrations.
+     */
+    markSharedAsApplied(options?: {
+        onProgress?: SharedMigrateOptions['onProgress'];
+    }): Promise<SharedMigrationResult>;
+    /**
+     * Migrate shared schema first, then all tenants
+     *
+     * Convenience method for the common pattern of migrating shared tables
+     * before tenant tables.
+     *
+     * @example
+     * ```typescript
+     * const result = await migrator.migrateAllWithShared({
+     *   concurrency: 10,
+     *   onProgress: (tenantId, status) => console.log(`${tenantId}: ${status}`),
+     * });
+     *
+     * console.log(`Shared: ${result.shared.appliedMigrations.length} applied`);
+     * console.log(`Tenants: ${result.tenants.succeeded}/${result.tenants.total} succeeded`);
+     * ```
+     */
+    migrateAllWithShared(options?: MigrateOptions & {
+        sharedOptions?: SharedMigrateOptions;
+    }): Promise<{
+        shared: SharedMigrationResult;
+        tenants: MigrationResults;
+    }>;
+    /**
+     * Detect schema drift across all tenants
+     * Compares each tenant's schema against a reference tenant (first tenant by default)
+     *
+     * @example
+     * ```typescript
+     * const drift = await migrator.getSchemaDrift();
+     * if (drift.withDrift > 0) {
+     *   console.log('Schema drift detected!');
+     *   for (const tenant of drift.details) {
+     *     if (tenant.hasDrift) {
+     *       console.log(`Tenant ${tenant.tenantId} has drift:`);
+     *       for (const table of tenant.tables) {
+     *         for (const col of table.columns) {
+     *           console.log(`  - ${table.table}.${col.column}: ${col.description}`);
+     *         }
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    getSchemaDrift(options?: SchemaDriftOptions): Promise<SchemaDriftStatus>;
+    /**
+     * Get schema drift for a specific tenant compared to a reference
+     */
+    getTenantSchemaDrift(tenantId: string, referenceTenantId: string, options?: Pick<SchemaDriftOptions, 'includeIndexes' | 'includeConstraints' | 'excludeTables'>): Promise<TenantSchemaDrift>;
+    /**
+     * Introspect the schema of a tenant
+     */
+    introspectTenantSchema(tenantId: string, options?: {
+        includeIndexes?: boolean;
+        includeConstraints?: boolean;
+        excludeTables?: string[];
+    }): Promise<TenantSchema | null>;
+}
+/**
+ * Create a migrator instance
+ */
+declare function createMigrator<TTenantSchema extends Record<string, unknown>, TSharedSchema extends Record<string, unknown>>(tenantConfig: Config<TTenantSchema, TSharedSchema>, migratorConfig: MigratorConfig): Migrator<TTenantSchema, TSharedSchema>;
+
+export { type AnonymizeRules as $, type AppliedMigration as A, type SharedMigrationStatus as B, type CreateTenantOptions as C, type DropTenantOptions as D, detectTableFormat as E, getFormatConfig as F, DEFAULT_FORMAT as G, DRIZZLE_KIT_FORMAT as H, type TableFormat as I, type ColumnInfo as J, type IndexInfo as K, type ConstraintInfo as L, Migrator as M, type TableSchema as N, type TenantSchema as O, type ColumnDrift as P, type IndexDrift as Q, type ConstraintDrift as R, type SeedFunction as S, type TenantMigrationResult as T, type TableDrift as U, type TenantSchemaDrift as V, type SchemaDriftStatus as W, type SchemaDriftOptions as X, type CloneProgressCallback as Y, type CloneProgressStatus as Z, type AnonymizeOptions as _, type MigratorConfig as a, type AnonymizeValue as a0, type SharedMigratorConfig as a1, type SharedMigrationHooks as a2, type MigrationFile as b, createMigrator as c, type MigrateOptions as d, type MigrationResults as e, type TenantMigrationStatus as f, type MigrationHooks as g, type MigrationProgressCallback as h, type MigrationErrorHandler as i, type SeedOptions as j, type TenantSeedResult as k, type SeedResults as l, type SharedSeedFunction as m, type SharedSeedResult as n, type DetectedFormat as o, type SyncStatus as p, type TenantSyncStatus as q, type TenantSyncResult as r, type SyncOptions as s, type SyncResults as t, type ClonerConfig as u, type ClonerDependencies as v, type CloneTenantOptions as w, type CloneTenantResult as x, type SharedMigrateOptions as y, type SharedMigrationResult as z };