drizzle-multitenant 1.1.0 → 1.3.0

package/dist/migrator/index.d.ts

@@ -1,356 +1,1203 @@
-import { C as Config } from '../types-BhK96FPC.js';
+import { o as DetectedFormat, S as SeedFunction, k as TenantSeedResult, j as SeedOptions, l as SeedResults, p as SyncStatus, b as MigrationFile, q as TenantSyncStatus, r as TenantSyncResult, s as SyncOptions, t as SyncResults, d as MigrateOptions, e as MigrationResults, g as MigrationHooks, h as MigrationProgressCallback, i as MigrationErrorHandler, T as TenantMigrationResult, f as TenantMigrationStatus, u as ClonerConfig, v as ClonerDependencies, w as CloneTenantOptions, x as CloneTenantResult, y as SharedMigrateOptions, z as SharedMigrationResult, B as SharedMigrationStatus } from '../migrator-B7oPKe73.js';
+export { _ as AnonymizeOptions, $ as AnonymizeRules, a0 as AnonymizeValue, A as AppliedMigration, Y as CloneProgressCallback, Z as CloneProgressStatus, P as ColumnDrift, J as ColumnInfo, R as ConstraintDrift, L as ConstraintInfo, C as CreateTenantOptions, G as DEFAULT_FORMAT, H as DRIZZLE_KIT_FORMAT, D as DropTenantOptions, Q as IndexDrift, K as IndexInfo, M as Migrator, a as MigratorConfig, X as SchemaDriftOptions, W as SchemaDriftStatus, a2 as SharedMigrationHooks, a1 as SharedMigratorConfig, m as SharedSeedFunction, n as SharedSeedResult, U as TableDrift, I as TableFormat, N as TableSchema, O as TenantSchema, V as TenantSchemaDrift, c as createMigrator, E as detectTableFormat, F as getFormatConfig } from '../migrator-B7oPKe73.js';
+import * as pg from 'pg';
 import { Pool } from 'pg';
+import { C as Config } from '../types-CGqsPe2Q.js';
+import 'drizzle-orm/postgres-js';
 import 'drizzle-orm/node-postgres';
 
 /**
- * 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';
-    };
+ * Options for creating a tenant schema
+ */
+interface CreateSchemaOptions {
+    /** Whether to also run migrations after creating (handled by Migrator) */
+    migrate?: boolean;
 }
 /**
- * Default format configuration for new tables
+ * Options for dropping a tenant schema
  */
-declare const DEFAULT_FORMAT: DetectedFormat;
+interface DropSchemaOptions {
+    /** Use CASCADE to drop all objects in schema */
+    cascade?: boolean;
+    /** Force drop without confirmation (used by CLI) */
+    force?: boolean;
+}
 /**
- * drizzle-kit format configuration
+ * Manages PostgreSQL schema lifecycle for multi-tenant applications.
+ *
+ * Extracted from Migrator to follow Single Responsibility Principle.
+ * Handles schema creation, deletion, existence checks, and migrations table management.
+ *
+ * @example
+ * ```typescript
+ * const schemaManager = new SchemaManager(config);
+ *
+ * // Create a new tenant schema
+ * await schemaManager.createSchema('tenant-123');
+ *
+ * // Check if schema exists
+ * const exists = await schemaManager.schemaExists('tenant-123');
+ *
+ * // Drop a tenant schema
+ * await schemaManager.dropSchema('tenant-123', { cascade: true });
+ * ```
  */
-declare const DRIZZLE_KIT_FORMAT: DetectedFormat;
+declare class SchemaManager<TTenantSchema extends Record<string, unknown>, TSharedSchema extends Record<string, unknown>> {
+    private readonly config;
+    private readonly migrationsTable;
+    constructor(config: Config<TTenantSchema, TSharedSchema>, migrationsTable?: string);
+    /**
+     * Get the schema name for a tenant ID using the configured template
+     *
+     * @param tenantId - The tenant identifier
+     * @returns The PostgreSQL schema name
+     *
+     * @example
+     * ```typescript
+     * const schemaName = schemaManager.getSchemaName('tenant-123');
+     * // Returns: 'tenant_tenant-123' (depends on schemaNameTemplate)
+     * ```
+     */
+    getSchemaName(tenantId: string): string;
+    /**
+     * Create a PostgreSQL pool for a specific schema
+     *
+     * The pool is configured with `search_path` set to the schema,
+     * allowing queries to run in tenant isolation.
+     *
+     * @param schemaName - The PostgreSQL schema name
+     * @returns A configured Pool instance
+     *
+     * @example
+     * ```typescript
+     * const pool = await schemaManager.createPool('tenant_123');
+     * try {
+     *   await pool.query('SELECT * FROM users'); // Queries tenant_123.users
+     * } finally {
+     *   await pool.end();
+     * }
+     * ```
+     */
+    createPool(schemaName: string): Promise<Pool>;
+    /**
+     * Create a PostgreSQL pool without schema-specific search_path
+     *
+     * Used for operations that need to work across schemas or
+     * before a schema exists (like creating the schema itself).
+     *
+     * @returns A Pool instance connected to the database
+     */
+    createRootPool(): Promise<Pool>;
+    /**
+     * Create a new tenant schema in the database
+     *
+     * @param tenantId - The tenant identifier
+     * @returns Promise that resolves when schema is created
+     *
+     * @example
+     * ```typescript
+     * await schemaManager.createSchema('new-tenant');
+     * ```
+     */
+    createSchema(tenantId: string): Promise<void>;
+    /**
+     * Drop a tenant schema from the database
+     *
+     * @param tenantId - The tenant identifier
+     * @param options - Drop options (cascade, force)
+     * @returns Promise that resolves when schema is dropped
+     *
+     * @example
+     * ```typescript
+     * // Drop with CASCADE (removes all objects)
+     * await schemaManager.dropSchema('old-tenant', { cascade: true });
+     *
+     * // Drop with RESTRICT (fails if objects exist)
+     * await schemaManager.dropSchema('old-tenant', { cascade: false });
+     * ```
+     */
+    dropSchema(tenantId: string, options?: DropSchemaOptions): Promise<void>;
+    /**
+     * Check if a tenant schema exists in the database
+     *
+     * @param tenantId - The tenant identifier
+     * @returns True if schema exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (await schemaManager.schemaExists('tenant-123')) {
+     *   console.log('Tenant schema exists');
+     * }
+     * ```
+     */
+    schemaExists(tenantId: string): Promise<boolean>;
+    /**
+     * List all schemas matching a pattern
+     *
+     * @param pattern - SQL LIKE pattern to filter schemas (optional)
+     * @returns Array of schema names
+     *
+     * @example
+     * ```typescript
+     * // List all tenant schemas
+     * const schemas = await schemaManager.listSchemas('tenant_%');
+     * ```
+     */
+    listSchemas(pattern?: string): Promise<string[]>;
+    /**
+     * Ensure the migrations table exists with the correct format
+     *
+     * Creates the migrations tracking table if it doesn't exist,
+     * using the appropriate column types based on the format.
+     *
+     * @param pool - Database pool to use
+     * @param schemaName - The schema to create the table in
+     * @param format - The detected/configured table format
+     *
+     * @example
+     * ```typescript
+     * const pool = await schemaManager.createPool('tenant_123');
+     * await schemaManager.ensureMigrationsTable(pool, 'tenant_123', format);
+     * ```
+     */
+    ensureMigrationsTable(pool: Pool, schemaName: string, format: DetectedFormat): Promise<void>;
+    /**
+     * Check if the migrations table exists in a schema
+     *
+     * @param pool - Database pool to use
+     * @param schemaName - The schema to check
+     * @returns True if migrations table exists
+     *
+     * @example
+     * ```typescript
+     * const pool = await schemaManager.createPool('tenant_123');
+     * if (await schemaManager.migrationsTableExists(pool, 'tenant_123')) {
+     *   console.log('Migrations table exists');
+     * }
+     * ```
+     */
+    migrationsTableExists(pool: Pool, schemaName: string): Promise<boolean>;
+    /**
+     * Get the configured migrations table name
+     *
+     * @returns The migrations table name
+     */
+    getMigrationsTableName(): string;
+}
 /**
- * Detect the format of an existing migrations table
+ * Factory function to create a SchemaManager instance
+ *
+ * @param config - The tenant configuration
+ * @param migrationsTable - Optional custom migrations table name
+ * @returns A new SchemaManager instance
  *
- * @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
+ * @example
+ * ```typescript
+ * const schemaManager = createSchemaManager(config);
+ * await schemaManager.createSchema('tenant-123');
+ * ```
  */
-declare function detectTableFormat(pool: Pool, schemaName: string, tableName: string): Promise<DetectedFormat | null>;
+declare function createSchemaManager<TTenantSchema extends Record<string, unknown>, TSharedSchema extends Record<string, unknown>>(config: Config<TTenantSchema, TSharedSchema>, migrationsTable?: string): SchemaManager<TTenantSchema, TSharedSchema>;
+
 /**
- * Get the format configuration for a specific format type
+ * Interfaces for Migrator module refactoring
+ *
+ * These interfaces define the contracts for the extracted modules.
+ * They should be implemented when refactoring the god component.
+ *
+ * @see REFACTOR_PROPOSAL.md for full refactoring plan
  */
-declare function getFormatConfig(format: TableFormat, tableName?: string): DetectedFormat;
 
 /**
- * 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;
+ * Options for executing a single migration
+ */
+interface ExecuteMigrationOptions {
+    /** Whether to skip actual SQL execution (mark as applied only) */
+    markOnly?: boolean;
+    /** Progress callback */
+    onProgress?: (status: 'applying' | 'recording') => void;
 }
 /**
- * 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;
+ * Responsible for executing migrations on a single tenant
+ */
+interface IMigrationExecutor {
+    /**
+     * Execute a single migration on a tenant
+     */
+    executeMigration(pool: Pool, schemaName: string, migration: MigrationFile, format: DetectedFormat, options?: ExecuteMigrationOptions): Promise<void>;
+    /**
+     * Execute multiple migrations on a tenant
+     */
+    executeMigrations(pool: Pool, schemaName: string, migrations: MigrationFile[], format: DetectedFormat, options?: ExecuteMigrationOptions): Promise<string[]>;
+    /**
+     * Record a migration as applied without executing SQL
+     */
+    recordMigration(pool: Pool, schemaName: string, migration: MigrationFile, format: DetectedFormat): Promise<void>;
+    /**
+     * Get list of applied migrations for a tenant
+     */
+    getAppliedMigrations(pool: Pool, schemaName: string, format: DetectedFormat): Promise<Array<{
+        identifier: string;
+        name?: string;
+        hash?: string;
+        appliedAt: Date;
+    }>>;
+    /**
+     * Get pending migrations (not yet applied)
+     */
+    getPendingMigrations(pool: Pool, schemaName: string, allMigrations: MigrationFile[], format: DetectedFormat): Promise<MigrationFile[]>;
 }
 /**
- * Aggregate migration results
+ * Batch execution options
  */
-interface MigrationResults {
-    total: number;
-    succeeded: number;
-    failed: number;
-    skipped: number;
-    details: TenantMigrationResult[];
+interface BatchExecuteOptions extends MigrateOptions {
+    /** Migrations to apply (if not provided, loads from disk) */
+    migrations?: MigrationFile[];
 }
 /**
- * Progress callback for migrations
+ * Responsible for batch migration operations across multiple tenants
  */
-type MigrationProgressCallback = (tenantId: string, status: 'starting' | 'migrating' | 'completed' | 'failed' | 'skipped', migrationName?: string) => void;
+interface IBatchExecutor {
+    /**
+     * Migrate all tenants in parallel
+     */
+    migrateAll(options?: BatchExecuteOptions): Promise<MigrationResults>;
+    /**
+     * Migrate specific tenants in parallel
+     */
+    migrateTenants(tenantIds: string[], options?: BatchExecuteOptions): Promise<MigrationResults>;
+    /**
+     * Mark all tenants as applied without executing SQL
+     */
+    markAllAsApplied(options?: MigrateOptions): Promise<MigrationResults>;
+}
 /**
- * Error handler for migrations
+ * Responsible for synchronizing migration state between disk and database
  */
-type MigrationErrorHandler = (tenantId: string, error: Error) => 'continue' | 'abort';
+interface ISyncManager {
+    /**
+     * Get sync status for all tenants
+     */
+    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 records from a tenant
+     */
+    cleanOrphans(tenantId: string): Promise<TenantSyncResult>;
+    /**
+     * Remove orphan records from all tenants
+     */
+    cleanAllOrphans(options?: SyncOptions): Promise<SyncResults>;
+}
 /**
- * Migration hooks
+ * Responsible for seeding tenant databases
  */
-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>;
+interface ISeeder<TSchema extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Seed a single tenant
+     */
+    seedTenant(tenantId: string, seedFn: SeedFunction<TSchema>): Promise<TenantSeedResult>;
+    /**
+     * Seed all tenants
+     */
+    seedAll(seedFn: SeedFunction<TSchema>, options?: SeedOptions): Promise<SeedResults>;
+    /**
+     * Seed specific tenants
+     */
+    seedTenants(tenantIds: string[], seedFn: SeedFunction<TSchema>, options?: SeedOptions): Promise<SeedResults>;
 }
+
 /**
- * Migrator configuration
+ * Configuration for the Seeder
  */
-interface MigratorConfig {
-    /** Path to tenant migrations folder */
-    migrationsFolder: string;
-    /** Table name for tracking migrations */
-    migrationsTable?: string;
+interface SeederConfig {
     /** Function to discover tenant IDs */
     tenantDiscovery: () => Promise<string[]>;
-    /** Migration hooks */
-    hooks?: MigrationHooks;
+}
+/**
+ * Seeder dependencies
+ */
+interface SeederDependencies<TTenantSchema extends Record<string, unknown> = Record<string, unknown>> {
+    /** Pool creation for specific schemas */
+    createPool: (schemaName: string) => Promise<pg.Pool>;
+    /** Schema name template function */
+    schemaNameTemplate: (tenantId: string) => string;
+    /** Tenant schema definition */
+    tenantSchema: TTenantSchema;
+}
+
+/**
+ * Responsible for seeding tenant databases with initial data.
+ *
+ * Extracted from Migrator to follow Single Responsibility Principle.
+ * Handles seeding individual tenants and batch seeding operations.
+ *
+ * @example
+ * ```typescript
+ * const seeder = new Seeder(config, dependencies);
+ *
+ * // Seed a single tenant
+ * const result = await seeder.seedTenant('tenant-123', async (db, tenantId) => {
+ *   await db.insert(roles).values([
+ *     { name: 'admin', permissions: ['*'] },
+ *     { name: 'user', permissions: ['read'] },
+ *   ]);
+ * });
+ *
+ * // Seed all tenants
+ * const results = await seeder.seedAll(seedFn, { concurrency: 10 });
+ * ```
+ */
+declare class Seeder<TTenantSchema extends Record<string, unknown> = Record<string, unknown>> implements ISeeder<TTenantSchema> {
+    private readonly config;
+    private readonly deps;
+    constructor(config: SeederConfig, deps: SeederDependencies<TTenantSchema>);
+    /**
+     * Seed a single tenant with initial data
+     *
+     * Creates a database connection for the tenant, executes the seed function,
+     * and properly cleans up the connection afterward.
+     *
+     * @param tenantId - The tenant identifier
+     * @param seedFn - Function that seeds the database
+     * @returns Result of the seeding operation
+     *
+     * @example
+     * ```typescript
+     * const result = await seeder.seedTenant('tenant-123', async (db, tenantId) => {
+     *   await db.insert(users).values([
+     *     { name: 'Admin', email: `admin@${tenantId}.com` },
+     *   ]);
+     * });
+     *
+     * if (result.success) {
+     *   console.log(`Seeded ${result.tenantId} in ${result.durationMs}ms`);
+     * }
+     * ```
+     */
+    seedTenant(tenantId: string, seedFn: SeedFunction<TTenantSchema>): Promise<TenantSeedResult>;
+    /**
+     * Seed all tenants with initial data in parallel
+     *
+     * Discovers all tenants and seeds them in batches with configurable concurrency.
+     * Supports progress callbacks and abort-on-error behavior.
+     *
+     * @param seedFn - Function that seeds each database
+     * @param options - Seeding options
+     * @returns Aggregate results of all seeding operations
+     *
+     * @example
+     * ```typescript
+     * const results = await seeder.seedAll(
+     *   async (db, tenantId) => {
+     *     await db.insert(settings).values({ key: 'initialized', value: 'true' });
+     *   },
+     *   {
+     *     concurrency: 5,
+     *     onProgress: (id, status) => console.log(`${id}: ${status}`),
+     *   }
+     * );
+     *
+     * console.log(`Succeeded: ${results.succeeded}/${results.total}`);
+     * ```
+     */
+    seedAll(seedFn: SeedFunction<TTenantSchema>, options?: SeedOptions): Promise<SeedResults>;
+    /**
+     * Seed specific tenants with initial data
+     *
+     * Seeds only the specified tenants in batches with configurable concurrency.
+     *
+     * @param tenantIds - List of tenant IDs to seed
+     * @param seedFn - Function that seeds each database
+     * @param options - Seeding options
+     * @returns Aggregate results of seeding operations
+     *
+     * @example
+     * ```typescript
+     * const results = await seeder.seedTenants(
+     *   ['tenant-1', 'tenant-2', 'tenant-3'],
+     *   async (db) => {
+     *     await db.insert(config).values({ setup: true });
+     *   },
+     *   { concurrency: 2 }
+     * );
+     * ```
+     */
+    seedTenants(tenantIds: string[], seedFn: SeedFunction<TTenantSchema>, options?: SeedOptions): Promise<SeedResults>;
+    /**
+     * Create a skipped result for aborted seeding
+     */
+    private createSkippedResult;
     /**
-     * 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"
+     * Create an error result for failed seeding
      */
-    tableFormat?: 'auto' | TableFormat;
+    private createErrorResult;
     /**
-     * When using "auto" format and no table exists, which format to create
-     * @default "name"
+     * Aggregate individual results into a summary
      */
-    defaultFormat?: TableFormat;
+    private aggregateResults;
 }
 /**
- * Migrate options
+ * Factory function to create a Seeder instance
+ *
+ * @param config - Seeder configuration
+ * @param dependencies - Required dependencies
+ * @returns A configured Seeder instance
+ *
+ * @example
+ * ```typescript
+ * const seeder = createSeeder(
+ *   { tenantDiscovery: async () => ['t1', 't2'] },
+ *   {
+ *     createPool: schemaManager.createPool.bind(schemaManager),
+ *     schemaNameTemplate: (id) => `tenant_${id}`,
+ *     tenantSchema: schema,
+ *   }
+ * );
+ * ```
  */
-interface MigrateOptions {
-    /** Number of concurrent migrations */
-    concurrency?: number;
-    /** Progress callback */
-    onProgress?: MigrationProgressCallback;
-    /** Error handler */
-    onError?: MigrationErrorHandler;
-    /** Dry run mode */
-    dryRun?: boolean;
+declare function createSeeder<TTenantSchema extends Record<string, unknown> = Record<string, unknown>>(config: SeederConfig, dependencies: SeederDependencies<TTenantSchema>): Seeder<TTenantSchema>;
+
+/**
+ * Internal types for the SyncManager module
+ *
+ * Public types are re-exported from the main types.ts file
+ * @module sync/types
+ */
+
+/**
+ * Configuration for the SyncManager
+ */
+interface SyncManagerConfig {
+    /** Function to discover tenant IDs */
+    tenantDiscovery: () => Promise<string[]>;
+    /** Path to migrations folder */
+    migrationsFolder: string;
+    /** Migrations table name */
+    migrationsTable: string;
 }
 /**
- * Tenant creation options
+ * SyncManager dependencies
  */
-interface CreateTenantOptions {
-    /** Apply all migrations after creating schema */
-    migrate?: boolean;
+interface SyncManagerDependencies {
+    /** Create a pool for a specific schema */
+    createPool: (schemaName: string) => Promise<Pool>;
+    /** Schema name template function */
+    schemaNameTemplate: (tenantId: string) => string;
+    /** Check if migrations table exists */
+    migrationsTableExists: (pool: Pool, schemaName: string) => Promise<boolean>;
+    /** Ensure migrations table exists */
+    ensureMigrationsTable: (pool: Pool, schemaName: string, format: DetectedFormat) => Promise<void>;
+    /** Get or detect the format for a schema */
+    getOrDetectFormat: (pool: Pool, schemaName: string) => Promise<DetectedFormat>;
+    /** Load migrations from disk */
+    loadMigrations: () => Promise<MigrationFile[]>;
 }
+
 /**
- * Tenant drop options
+ * Responsible for synchronizing migration state between disk and database.
+ *
+ * Extracted from Migrator to follow Single Responsibility Principle.
+ * Handles detection of divergences and reconciliation operations.
+ *
+ * @example
+ * ```typescript
+ * const syncManager = new SyncManager(config, dependencies);
+ *
+ * // Check sync status
+ * const status = await syncManager.getSyncStatus();
+ * if (status.outOfSync > 0) {
+ *   console.log(`${status.outOfSync} tenants out of sync`);
+ * }
+ *
+ * // Mark missing migrations as applied
+ * await syncManager.markAllMissing({ concurrency: 10 });
+ *
+ * // Clean orphan records
+ * await syncManager.cleanAllOrphans({ concurrency: 10 });
+ * ```
  */
-interface DropTenantOptions {
-    /** Skip confirmation (force drop) */
-    force?: boolean;
-    /** Cascade drop */
-    cascade?: boolean;
+declare class SyncManager implements ISyncManager {
+    private readonly config;
+    private readonly deps;
+    constructor(config: SyncManagerConfig, deps: SyncManagerDependencies);
+    /**
+     * Get sync status for all tenants
+     *
+     * Detects divergences between migrations on disk and tracking in database.
+     * A tenant is "in sync" when all disk migrations are tracked and no orphan records exist.
+     *
+     * @returns Aggregate sync status for all tenants
+     *
+     * @example
+     * ```typescript
+     * const status = await syncManager.getSyncStatus();
+     * console.log(`Total: ${status.total}, In sync: ${status.inSync}, Out of sync: ${status.outOfSync}`);
+     *
+     * for (const tenant of status.details.filter(d => !d.inSync)) {
+     *   console.log(`${tenant.tenantId}: missing=${tenant.missing.length}, orphans=${tenant.orphans.length}`);
+     * }
+     * ```
+     */
+    getSyncStatus(): Promise<SyncStatus>;
+    /**
+     * Get sync status for a specific tenant
+     *
+     * Compares migrations on disk with records in the database.
+     * Identifies missing migrations (on disk but not tracked) and
+     * orphan records (tracked but not on disk).
+     *
+     * @param tenantId - The tenant identifier
+     * @param migrations - Optional pre-loaded migrations (avoids reloading from disk)
+     * @returns Sync status for the tenant
+     *
+     * @example
+     * ```typescript
+     * const status = await syncManager.getTenantSyncStatus('tenant-123');
+     * if (status.missing.length > 0) {
+     *   console.log(`Missing: ${status.missing.join(', ')}`);
+     * }
+     * if (status.orphans.length > 0) {
+     *   console.log(`Orphans: ${status.orphans.join(', ')}`);
+     * }
+     * ```
+     */
+    getTenantSyncStatus(tenantId: string, migrations?: MigrationFile[]): Promise<TenantSyncStatus>;
+    /**
+     * Mark missing migrations as applied for a tenant
+     *
+     * Records migrations that exist on disk but are not tracked in the database.
+     * Useful for syncing tracking state with already-applied migrations.
+     *
+     * @param tenantId - The tenant identifier
+     * @returns Result of the mark operation
+     *
+     * @example
+     * ```typescript
+     * const result = await syncManager.markMissing('tenant-123');
+     * if (result.success) {
+     *   console.log(`Marked ${result.markedMigrations.length} migrations as applied`);
+     * }
+     * ```
+     */
+    markMissing(tenantId: string): Promise<TenantSyncResult>;
+    /**
+     * Mark missing migrations as applied for all tenants
+     *
+     * Processes all tenants in parallel with configurable concurrency.
+     * Supports progress callbacks and abort-on-error behavior.
+     *
+     * @param options - Sync options
+     * @returns Aggregate results of all mark operations
+     *
+     * @example
+     * ```typescript
+     * const results = await syncManager.markAllMissing({
+     *   concurrency: 10,
+     *   onProgress: (id, status) => console.log(`${id}: ${status}`),
+     * });
+     * console.log(`Succeeded: ${results.succeeded}/${results.total}`);
+     * ```
+     */
+    markAllMissing(options?: SyncOptions): Promise<SyncResults>;
+    /**
+     * Remove orphan migration records for a tenant
+     *
+     * Deletes records from the migrations table that don't have
+     * corresponding files on disk.
+     *
+     * @param tenantId - The tenant identifier
+     * @returns Result of the clean operation
+     *
+     * @example
+     * ```typescript
+     * const result = await syncManager.cleanOrphans('tenant-123');
+     * if (result.success) {
+     *   console.log(`Removed ${result.removedOrphans.length} orphan records`);
+     * }
+     * ```
+     */
+    cleanOrphans(tenantId: string): Promise<TenantSyncResult>;
+    /**
+     * Remove orphan migration records for all tenants
+     *
+     * Processes all tenants in parallel with configurable concurrency.
+     * Supports progress callbacks and abort-on-error behavior.
+     *
+     * @param options - Sync options
+     * @returns Aggregate results of all clean operations
+     *
+     * @example
+     * ```typescript
+     * const results = await syncManager.cleanAllOrphans({
+     *   concurrency: 10,
+     *   onProgress: (id, status) => console.log(`${id}: ${status}`),
+     * });
+     * console.log(`Succeeded: ${results.succeeded}/${results.total}`);
+     * ```
+     */
+    cleanAllOrphans(options?: SyncOptions): Promise<SyncResults>;
+    /**
+     * Get applied migrations for a schema
+     */
+    private getAppliedMigrations;
+    /**
+     * Check if a migration has been applied
+     */
+    private isMigrationApplied;
+    /**
+     * Record a migration as applied (without executing SQL)
+     */
+    private recordMigration;
+    /**
+     * Create a skipped sync result for aborted operations
+     */
+    private createSkippedSyncResult;
+    /**
+     * Create an error sync result for failed operations
+     */
+    private createErrorSyncResult;
+    /**
+     * Aggregate individual sync results into a summary
+     */
+    private aggregateSyncResults;
 }
 /**
- * Applied migration record
+ * Factory function to create a SyncManager instance
+ *
+ * @param config - SyncManager configuration
+ * @param dependencies - Required dependencies
+ * @returns A configured SyncManager instance
+ *
+ * @example
+ * ```typescript
+ * const syncManager = createSyncManager(
+ *   {
+ *     tenantDiscovery: async () => ['t1', 't2'],
+ *     migrationsFolder: './migrations',
+ *     migrationsTable: '__drizzle_migrations',
+ *   },
+ *   {
+ *     createPool: schemaManager.createPool.bind(schemaManager),
+ *     schemaNameTemplate: (id) => `tenant_${id}`,
+ *     migrationsTableExists: schemaManager.migrationsTableExists.bind(schemaManager),
+ *     ensureMigrationsTable: schemaManager.ensureMigrationsTable.bind(schemaManager),
+ *     getOrDetectFormat: migrator.getOrDetectFormat.bind(migrator),
+ *     loadMigrations: migrator.loadMigrations.bind(migrator),
+ *   }
+ * );
+ * ```
+ */
+declare function createSyncManager(config: SyncManagerConfig, dependencies: SyncManagerDependencies): SyncManager;
+
+/**
+ * Applied migration with parsed data
  */
 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;
+ * Configuration for MigrationExecutor
+ */
+interface MigrationExecutorConfig {
+    /** Migration hooks for lifecycle events */
+    hooks?: MigrationHooks | undefined;
 }
 /**
- * Aggregate sync status
+ * Dependencies for MigrationExecutor
  */
-interface SyncStatus {
-    total: number;
-    inSync: number;
-    outOfSync: number;
-    error: number;
-    details: TenantSyncStatus[];
+interface MigrationExecutorDependencies {
+    /** Create a database pool for a schema */
+    createPool: (schemaName: string) => Promise<Pool>;
+    /** Get schema name from tenant ID */
+    schemaNameTemplate: (tenantId: string) => string;
+    /** Check if migrations table exists */
+    migrationsTableExists: (pool: Pool, schemaName: string) => Promise<boolean>;
+    /** Ensure migrations table exists with correct format */
+    ensureMigrationsTable: (pool: Pool, schemaName: string, format: DetectedFormat) => Promise<void>;
+    /** Get or detect table format */
+    getOrDetectFormat: (pool: Pool, schemaName: string) => Promise<DetectedFormat>;
+    /** Load migrations from disk */
+    loadMigrations: () => Promise<MigrationFile[]>;
 }
 /**
- * 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;
+ * Options for migrating a single tenant
+ */
+interface MigrateTenantOptions {
+    /** Whether to skip actual SQL execution (dry run) */
+    dryRun?: boolean | undefined;
+    /** Progress callback */
+    onProgress?: MigrationProgressCallback | undefined;
 }
 /**
- * Aggregate sync results
+ * Configuration for BatchExecutor
  */
-interface SyncResults {
-    total: number;
-    succeeded: number;
-    failed: number;
-    details: TenantSyncResult[];
+interface BatchExecutorConfig {
+    /** Function to discover tenant IDs */
+    tenantDiscovery: () => Promise<string[]>;
 }
 /**
- * Options for sync operations
+ * Options for batch migration operations
  */
-interface SyncOptions {
-    /** Number of concurrent operations */
+interface BatchMigrateOptions {
+    /** Number of concurrent migrations */
     concurrency?: number;
     /** Progress callback */
-    onProgress?: (tenantId: string, status: 'starting' | 'syncing' | 'completed' | 'failed') => void;
+    onProgress?: MigrationProgressCallback;
     /** Error handler */
     onError?: MigrationErrorHandler;
+    /** Dry run mode */
+    dryRun?: boolean;
 }
 
 /**
- * Parallel migration engine for multi-tenant applications
+ * Responsible for executing migrations on individual tenants.
+ *
+ * Extracted from Migrator to follow Single Responsibility Principle.
+ * Handles single-tenant migration operations including:
+ * - Executing migrations with SQL
+ * - Marking migrations as applied (without SQL)
+ * - Checking migration status
+ * - Getting applied/pending migrations
+ *
+ * @example
+ * ```typescript
+ * const executor = new MigrationExecutor(config, dependencies);
+ *
+ * // Migrate a single tenant
+ * const result = await executor.migrateTenant('tenant-123');
+ *
+ * // Mark migrations as applied without executing SQL
+ * const markResult = await executor.markAsApplied('tenant-123');
+ *
+ * // Get tenant status
+ * const status = await executor.getTenantStatus('tenant-123');
+ * ```
  */
-declare class Migrator<TTenantSchema extends Record<string, unknown>, TSharedSchema extends Record<string, unknown>> {
-    private readonly tenantConfig;
-    private readonly migratorConfig;
-    private readonly migrationsTable;
-    constructor(tenantConfig: Config<TTenantSchema, TSharedSchema>, migratorConfig: MigratorConfig);
+declare class MigrationExecutor implements IMigrationExecutor {
+    private readonly config;
+    private readonly deps;
+    constructor(config: MigrationExecutorConfig, deps: MigrationExecutorDependencies);
     /**
-     * Migrate all tenants in parallel
+     * Migrate a single tenant
+     *
+     * Applies all pending migrations to the tenant's schema.
+     * Creates the migrations table if it doesn't exist.
+     *
+     * @param tenantId - The tenant identifier
+     * @param migrations - Optional pre-loaded migrations (avoids reloading from disk)
+     * @param options - Migration options (dryRun, onProgress)
+     * @returns Migration result with applied migrations and duration
+     *
+     * @example
+     * ```typescript
+     * const result = await executor.migrateTenant('tenant-123', undefined, {
+     *   dryRun: false,
+     *   onProgress: (id, status, name) => console.log(`${id}: ${status} ${name}`),
+     * });
+     *
+     * if (result.success) {
+     *   console.log(`Applied ${result.appliedMigrations.length} migrations`);
+     * }
+     * ```
      */
-    migrateAll(options?: MigrateOptions): Promise<MigrationResults>;
+    migrateTenant(tenantId: string, migrations?: MigrationFile[], options?: MigrateTenantOptions): Promise<TenantMigrationResult>;
     /**
-     * Migrate a single tenant
+     * Mark migrations as applied without executing SQL
+     *
+     * Useful for syncing tracking state with already-applied migrations
+     * or when migrations were applied manually.
+     *
+     * @param tenantId - The tenant identifier
+     * @param options - Options with progress callback
+     * @returns Result with list of marked migrations
+     *
+     * @example
+     * ```typescript
+     * const result = await executor.markAsApplied('tenant-123', {
+     *   onProgress: (id, status, name) => console.log(`${id}: marking ${name}`),
+     * });
+     *
+     * console.log(`Marked ${result.appliedMigrations.length} migrations`);
+     * ```
      */
-    migrateTenant(tenantId: string, migrations?: MigrationFile[], options?: {
-        dryRun?: boolean;
-        onProgress?: MigrateOptions['onProgress'];
+    markAsApplied(tenantId: string, options?: {
+        onProgress?: MigrateTenantOptions['onProgress'];
     }): Promise<TenantMigrationResult>;
     /**
-     * Migrate specific tenants
+     * Get migration status for a specific tenant
+     *
+     * Returns information about applied and pending migrations.
+     *
+     * @param tenantId - The tenant identifier
+     * @param migrations - Optional pre-loaded migrations
+     * @returns Migration status with counts and pending list
+     *
+     * @example
+     * ```typescript
+     * const status = await executor.getTenantStatus('tenant-123');
+     * if (status.status === 'behind') {
+     *   console.log(`Pending: ${status.pendingMigrations.join(', ')}`);
+     * }
+     * ```
      */
-    migrateTenants(tenantIds: string[], options?: MigrateOptions): Promise<MigrationResults>;
+    getTenantStatus(tenantId: string, migrations?: MigrationFile[]): Promise<TenantMigrationStatus>;
     /**
-     * Get migration status for all tenants
+     * Execute a single migration on a schema
      */
-    getStatus(): Promise<TenantMigrationStatus[]>;
+    executeMigration(pool: Pool, schemaName: string, migration: MigrationFile, format: DetectedFormat, options?: {
+        markOnly?: boolean;
+        onProgress?: (status: 'applying' | 'recording') => void;
+    }): Promise<void>;
     /**
-     * Get migration status for a specific tenant
+     * Execute multiple migrations on a schema
      */
-    getTenantStatus(tenantId: string, migrations?: MigrationFile[]): Promise<TenantMigrationStatus>;
+    executeMigrations(pool: Pool, schemaName: string, migrations: MigrationFile[], format: DetectedFormat, options?: {
+        markOnly?: boolean;
+        onProgress?: (status: 'applying' | 'recording') => void;
+    }): Promise<string[]>;
     /**
-     * Create a new tenant schema and optionally apply migrations
+     * Record a migration as applied without executing SQL
      */
-    createTenant(tenantId: string, options?: CreateTenantOptions): Promise<void>;
+    recordMigration(pool: Pool, schemaName: string, migration: MigrationFile, format: DetectedFormat): Promise<void>;
     /**
-     * Drop a tenant schema
+     * Get list of applied migrations for a tenant
      */
-    dropTenant(tenantId: string, options?: DropTenantOptions): Promise<void>;
+    getAppliedMigrations(pool: Pool, schemaName: string, format: DetectedFormat): Promise<AppliedMigration[]>;
     /**
-     * Check if a tenant schema exists
+     * Get pending migrations (not yet applied)
      */
-    tenantExists(tenantId: string): Promise<boolean>;
+    getPendingMigrations(pool: Pool, schemaName: string, allMigrations: MigrationFile[], format: DetectedFormat): Promise<MigrationFile[]>;
     /**
-     * Mark migrations as applied without executing SQL
-     * Useful for syncing tracking state with already-applied migrations
+     * Check if a migration has been applied
      */
-    markAsApplied(tenantId: string, options?: {
-        onProgress?: MigrateOptions['onProgress'];
-    }): Promise<TenantMigrationResult>;
+    private isMigrationApplied;
     /**
-     * Mark migrations as applied for all tenants without executing SQL
-     * Useful for syncing tracking state with already-applied migrations
+     * Apply a migration to a schema (execute SQL + record)
      */
-    markAllAsApplied(options?: MigrateOptions): Promise<MigrationResults>;
+    private applyMigration;
+}
+/**
+ * Factory function to create a MigrationExecutor instance
+ *
+ * @param config - Executor configuration (hooks)
+ * @param dependencies - Required dependencies
+ * @returns A configured MigrationExecutor instance
+ *
+ * @example
+ * ```typescript
+ * const executor = createMigrationExecutor(
+ *   { hooks: { beforeTenant: async (id) => console.log(`Starting ${id}`) } },
+ *   {
+ *     createPool: schemaManager.createPool.bind(schemaManager),
+ *     schemaNameTemplate: (id) => `tenant_${id}`,
+ *     migrationsTableExists: schemaManager.migrationsTableExists.bind(schemaManager),
+ *     ensureMigrationsTable: schemaManager.ensureMigrationsTable.bind(schemaManager),
+ *     getOrDetectFormat: async (pool, schema) => getFormatConfig('name', table),
+ *     loadMigrations: async () => loadMigrationsFromDisk(),
+ *   }
+ * );
+ * ```
+ */
+declare function createMigrationExecutor(config: MigrationExecutorConfig, dependencies: MigrationExecutorDependencies): MigrationExecutor;
+
+/**
+ * Responsible for batch migration operations across multiple tenants.
+ *
+ * Extracted from Migrator to follow Single Responsibility Principle.
+ * Handles parallel migration operations including:
+ * - Migrating all tenants with configurable concurrency
+ * - Migrating specific tenants
+ * - Marking all migrations as applied
+ * - Progress tracking and error handling
+ *
+ * @example
+ * ```typescript
+ * const batchExecutor = new BatchExecutor(config, migrationExecutor, loadMigrations);
+ *
+ * // Migrate all tenants with concurrency 10
+ * const results = await batchExecutor.migrateAll({ concurrency: 10 });
+ *
+ * // Migrate specific tenants
+ * const specificResults = await batchExecutor.migrateTenants(['t1', 't2'], {
+ *   onProgress: (id, status) => console.log(`${id}: ${status}`),
+ * });
+ * ```
+ */
+declare class BatchExecutor implements IBatchExecutor {
+    private readonly config;
+    private readonly executor;
+    private readonly loadMigrations;
+    constructor(config: BatchExecutorConfig, executor: MigrationExecutor, loadMigrations: () => Promise<MigrationFile[]>);
     /**
-     * Get sync status for all tenants
-     * Detects divergences between migrations on disk and tracking in database
+     * Migrate all tenants in parallel
+     *
+     * Processes tenants in batches with configurable concurrency.
+     * Supports progress callbacks, error handling, and abort behavior.
+     *
+     * @param options - Migration options (concurrency, dryRun, callbacks)
+     * @returns Aggregate results for all tenants
+     *
+     * @example
+     * ```typescript
+     * const results = await batchExecutor.migrateAll({
+     *   concurrency: 10,
+     *   dryRun: false,
+     *   onProgress: (id, status) => console.log(`${id}: ${status}`),
+     *   onError: (id, error) => {
+     *     console.error(`${id} failed: ${error.message}`);
+     *     return 'continue'; // or 'abort' to stop all
+     *   },
+     * });
+     *
+     * console.log(`Succeeded: ${results.succeeded}/${results.total}`);
+     * ```
      */
-    getSyncStatus(): Promise<SyncStatus>;
+    migrateAll(options?: BatchMigrateOptions): Promise<MigrationResults>;
     /**
-     * Get sync status for a specific tenant
+     * Migrate specific tenants in parallel
+     *
+     * Same as migrateAll but for a subset of tenants.
+     *
+     * @param tenantIds - List of tenant IDs to migrate
+     * @param options - Migration options
+     * @returns Aggregate results for specified tenants
+     *
+     * @example
+     * ```typescript
+     * const results = await batchExecutor.migrateTenants(
+     *   ['tenant-1', 'tenant-2', 'tenant-3'],
+     *   { concurrency: 5 }
+     * );
+     * ```
      */
-    getTenantSyncStatus(tenantId: string, migrations?: MigrationFile[]): Promise<TenantSyncStatus>;
+    migrateTenants(tenantIds: string[], options?: BatchMigrateOptions): Promise<MigrationResults>;
     /**
-     * Mark missing migrations as applied for a tenant
+     * Mark all tenants as applied without executing SQL
+     *
+     * Useful for syncing tracking state with already-applied migrations.
+     * Processes tenants in parallel with configurable concurrency.
+     *
+     * @param options - Migration options
+     * @returns Aggregate results for all tenants
+     *
+     * @example
+     * ```typescript
+     * const results = await batchExecutor.markAllAsApplied({
+     *   concurrency: 10,
+     *   onProgress: (id, status) => console.log(`${id}: ${status}`),
+     * });
+     * ```
      */
-    markMissing(tenantId: string): Promise<TenantSyncResult>;
+    markAllAsApplied(options?: BatchMigrateOptions): Promise<MigrationResults>;
     /**
-     * Mark missing migrations as applied for all tenants
+     * Get migration status for all tenants
+     *
+     * Queries each tenant's migration status sequentially.
+     *
+     * @returns List of migration status for all tenants
+     *
+     * @example
+     * ```typescript
+     * const statuses = await batchExecutor.getStatus();
+     * const behind = statuses.filter(s => s.status === 'behind');
+     * console.log(`${behind.length} tenants need migrations`);
+     * ```
      */
-    markAllMissing(options?: SyncOptions): Promise<SyncResults>;
+    getStatus(): Promise<TenantMigrationStatus[]>;
     /**
-     * Remove orphan migration records for a tenant
+     * Create a skipped result for aborted operations
      */
-    cleanOrphans(tenantId: string): Promise<TenantSyncResult>;
+    private createSkippedResult;
     /**
-     * Remove orphan migration records for all tenants
+     * Create an error result for failed operations
      */
-    cleanAllOrphans(options?: SyncOptions): Promise<SyncResults>;
+    private createErrorResult;
     /**
-     * Load migration files from the migrations folder
+     * Aggregate individual migration results into a summary
      */
-    private loadMigrations;
+    private aggregateResults;
+}
+/**
+ * Factory function to create a BatchExecutor instance
+ *
+ * @param config - Batch configuration (tenantDiscovery)
+ * @param executor - MigrationExecutor instance
+ * @param loadMigrations - Function to load migrations from disk
+ * @returns A configured BatchExecutor instance
+ *
+ * @example
+ * ```typescript
+ * const batchExecutor = createBatchExecutor(
+ *   { tenantDiscovery: async () => ['t1', 't2', 't3'] },
+ *   migrationExecutor,
+ *   async () => loadMigrationsFromDisk('./migrations')
+ * );
+ * ```
+ */
+declare function createBatchExecutor(config: BatchExecutorConfig, executor: MigrationExecutor, loadMigrations: () => Promise<MigrationFile[]>): BatchExecutor;
+
+/**
+ * Cloner
+ *
+ * Clones a tenant to another, including structure and optionally data.
+ *
+ * @module clone/cloner
+ */
+
+/**
+ * Clones tenants with support for introspection + DDL
+ *
+ * @example
+ * ```typescript
+ * const cloner = createCloner(config, dependencies);
+ *
+ * // Schema-only clone
+ * await cloner.cloneTenant('source', 'target');
+ *
+ * // Clone with data
+ * await cloner.cloneTenant('source', 'target', { includeData: true });
+ *
+ * // Clone with anonymization
+ * await cloner.cloneTenant('source', 'target', {
+ *   includeData: true,
+ *   anonymize: {
+ *     enabled: true,
+ *     rules: { users: { email: null, phone: null } },
+ *   },
+ * });
+ * ```
+ */
+declare class Cloner {
+    private readonly deps;
+    private readonly migrationsTable;
+    constructor(config: ClonerConfig, deps: ClonerDependencies);
     /**
-     * Create a pool for a specific schema
+     * Clone a tenant to another
+     *
+     * @param sourceTenantId - Source tenant ID
+     * @param targetTenantId - Target tenant ID
+     * @param options - Clone options
+     * @returns Clone result
      */
-    private createPool;
+    cloneTenant(sourceTenantId: string, targetTenantId: string, options?: CloneTenantOptions): Promise<CloneTenantResult>;
+    private createErrorResult;
+}
+/**
+ * Factory function for Cloner
+ *
+ * @param config - Cloner configuration
+ * @param dependencies - Cloner dependencies
+ * @returns Cloner instance
+ */
+declare function createCloner(config: ClonerConfig, dependencies: ClonerDependencies): Cloner;
+
+/**
+ * Configuration for SharedMigrationExecutor
+ */
+interface SharedMigrationExecutorConfig {
+    /** Schema name for shared tables (default: 'public') */
+    schemaName?: string;
+    /** Table name for tracking migrations */
+    migrationsTable: string;
+    /** Hooks for migration events */
+    hooks?: {
+        beforeMigration?: () => void | Promise<void>;
+        afterMigration?: (migrationName: string, durationMs: number) => void | Promise<void>;
+    };
+}
+/**
+ * Dependencies for SharedMigrationExecutor
+ */
+interface SharedMigrationExecutorDependencies {
+    /** Create a database pool for the shared schema */
+    createPool: () => Promise<Pool>;
+    /** Check if migrations table exists */
+    migrationsTableExists: (pool: Pool, schemaName: string) => Promise<boolean>;
+    /** Ensure migrations table exists with correct format */
+    ensureMigrationsTable: (pool: Pool, schemaName: string, format: DetectedFormat) => Promise<void>;
+    /** Get or detect migration table format */
+    getOrDetectFormat: (pool: Pool, schemaName: string) => Promise<DetectedFormat>;
+    /** Load migrations from disk */
+    loadMigrations: () => Promise<MigrationFile[]>;
+}
+
+/**
+ * Executor for shared schema migrations
+ *
+ * Handles migrations for the shared/public schema, separate from tenant schemas.
+ * Used for tables that are shared across all tenants (e.g., plans, roles, permissions).
+ *
+ * @example
+ * ```typescript
+ * const executor = new SharedMigrationExecutor(config, dependencies);
+ *
+ * // Get status
+ * const status = await executor.getStatus();
+ * console.log(`Pending: ${status.pendingCount}`);
+ *
+ * // Apply migrations
+ * const result = await executor.migrate();
+ * console.log(`Applied: ${result.appliedMigrations.length}`);
+ * ```
+ */
+declare class SharedMigrationExecutor {
+    private readonly config;
+    private readonly deps;
+    private readonly schemaName;
+    constructor(config: SharedMigrationExecutorConfig, deps: SharedMigrationExecutorDependencies);
     /**
-     * Ensure migrations table exists with the correct format
+     * Apply pending migrations to the shared schema
+     *
+     * @param options - Migration options (dryRun, onProgress)
+     * @returns Migration result with applied migrations
+     *
+     * @example
+     * ```typescript
+     * const result = await executor.migrate({
+     *   dryRun: false,
+     *   onProgress: (status, name) => console.log(`${status}: ${name}`),
+     * });
+     *
+     * if (result.success) {
+     *   console.log(`Applied ${result.appliedMigrations.length} migrations`);
+     * }
+     * ```
      */
-    private ensureMigrationsTable;
+    migrate(options?: SharedMigrateOptions): Promise<SharedMigrationResult>;
     /**
-     * Check if migrations table exists
+     * Mark migrations as applied without executing SQL
+     *
+     * Useful for syncing tracking state with already-applied migrations.
+     *
+     * @param options - Options with progress callback
+     * @returns Result with list of marked migrations
      */
-    private migrationsTableExists;
+    markAsApplied(options?: {
+        onProgress?: SharedMigrateOptions['onProgress'];
+    }): Promise<SharedMigrationResult>;
     /**
-     * Get applied migrations for a schema
+     * Get migration status for the shared schema
+     *
+     * @returns Status with applied/pending counts
+     */
+    getStatus(): Promise<SharedMigrationStatus>;
+    /**
+     * Get list of applied migrations
      */
     private getAppliedMigrations;
     /**
@@ -358,47 +1205,17 @@ declare class Migrator<TTenantSchema extends Record<string, unknown>, TSharedSch
      */
     private isMigrationApplied;
     /**
-     * Get or detect the format for a schema
-     * Returns the configured format or auto-detects from existing table
-     */
-    private getOrDetectFormat;
-    /**
-     * Apply a migration to a schema
+     * Apply a migration (execute SQL + record)
      */
     private applyMigration;
     /**
      * Record a migration as applied without executing SQL
-     * Used by markAsApplied to sync tracking state
      */
     private recordMigration;
-    /**
-     * Create a skipped result
-     */
-    private createSkippedResult;
-    /**
-     * Create an error result
-     */
-    private createErrorResult;
-    /**
-     * Aggregate migration results
-     */
-    private aggregateResults;
-    /**
-     * Create a skipped sync result
-     */
-    private createSkippedSyncResult;
-    /**
-     * Create an error sync result
-     */
-    private createErrorSyncResult;
-    /**
-     * Aggregate sync results
-     */
-    private aggregateSyncResults;
 }
 /**
- * Create a migrator instance
+ * Factory function to create a SharedMigrationExecutor
  */
-declare function createMigrator<TTenantSchema extends Record<string, unknown>, TSharedSchema extends Record<string, unknown>>(tenantConfig: Config<TTenantSchema, TSharedSchema>, migratorConfig: MigratorConfig): Migrator<TTenantSchema, TSharedSchema>;
+declare function createSharedMigrationExecutor(config: SharedMigrationExecutorConfig, dependencies: SharedMigrationExecutorDependencies): SharedMigrationExecutor;
 
-export { type AppliedMigration, type CreateTenantOptions, DEFAULT_FORMAT, DRIZZLE_KIT_FORMAT, type DetectedFormat, type DropTenantOptions, type MigrateOptions, type MigrationErrorHandler, type MigrationFile, type MigrationHooks, type MigrationProgressCallback, type MigrationResults, Migrator, type MigratorConfig, type TableFormat, type TenantMigrationResult, type TenantMigrationStatus, createMigrator, detectTableFormat, getFormatConfig };
+export { BatchExecutor, type BatchExecutorConfig, type BatchMigrateOptions, CloneTenantOptions, CloneTenantResult, Cloner, ClonerConfig, ClonerDependencies, type CreateSchemaOptions, DetectedFormat, type DropSchemaOptions, MigrateOptions, type MigrateTenantOptions, MigrationErrorHandler, MigrationExecutor, type MigrationExecutorConfig, type MigrationExecutorDependencies, MigrationFile, MigrationHooks, MigrationProgressCallback, MigrationResults, SchemaManager, SeedFunction, SeedOptions, SeedResults, Seeder, type SeederConfig, type SeederDependencies, SharedMigrateOptions, SharedMigrationExecutor, type SharedMigrationExecutorConfig, type SharedMigrationExecutorDependencies, SharedMigrationResult, SharedMigrationStatus, SyncManager, type SyncManagerConfig, type SyncManagerDependencies, SyncOptions, SyncResults, SyncStatus, TenantMigrationResult, TenantMigrationStatus, TenantSeedResult, TenantSyncResult, TenantSyncStatus, createBatchExecutor, createCloner, createMigrationExecutor, createSchemaManager, createSeeder, createSharedMigrationExecutor, createSyncManager };