drizzle-multitenant 1.1.0 → 1.2.0

package/dist/migrator-BDgFzSh8.d.ts

@@ -0,0 +1,824 @@
+import { C as Config } from './types-BhK96FPC.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;
+}
+/**
+ * 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;
+}
+
+/**
+ * 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;
+    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>;
+    /**
+     * 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;
+    /**
+     * 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 AppliedMigration as A, type TableFormat as B, type CreateTenantOptions as C, type DropTenantOptions as D, type ColumnInfo as E, type ConstraintInfo as F, type TableSchema as G, type TenantSchema as H, type IndexInfo as I, type ColumnDrift as J, type IndexDrift as K, type ConstraintDrift as L, Migrator as M, type TableDrift as N, type TenantSchemaDrift as O, type SchemaDriftStatus as P, type SchemaDriftOptions as Q, type CloneProgressCallback as R, type SeedFunction as S, type TenantMigrationResult as T, type CloneProgressStatus as U, type AnonymizeOptions as V, type AnonymizeRules as W, type AnonymizeValue as X, type MigratorConfig as a, 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 DetectedFormat as m, type SyncStatus as n, type TenantSyncStatus as o, type TenantSyncResult as p, type SyncOptions as q, type SyncResults as r, type ClonerConfig as s, type ClonerDependencies as t, type CloneTenantOptions as u, type CloneTenantResult as v, detectTableFormat as w, getFormatConfig as x, DEFAULT_FORMAT as y, DRIZZLE_KIT_FORMAT as z };