noormme 1.1.0 → 1.2.0

package/dist/esm/schema/test/integration.test.js

@@ -8,39 +8,43 @@ const mockKysely = {
     selectFrom: jest.fn().mockReturnThis(),
     select: jest.fn().mockReturnThis(),
     where: jest.fn().mockReturnThis(),
-    execute: jest.fn().mockResolvedValue([])
+    execute: jest.fn().mockResolvedValue([]),
 };
 // Mock discovery services
 jest.mock('../core/discovery/table-metadata-discovery.js', () => ({
     TableMetadataDiscovery: {
         getInstance: jest.fn().mockReturnValue({
-            discoverTables: jest.fn().mockResolvedValue([])
-        })
-    }
+            discoverTables: jest.fn().mockResolvedValue([]),
+        }),
+    },
 }));
 jest.mock('../core/discovery/relationship-discovery.js', () => ({
     RelationshipDiscovery: {
         getInstance: jest.fn().mockReturnValue({
-            discoverRelationships: jest.fn().mockResolvedValue([])
-        })
-    }
+            discoverRelationships: jest.fn().mockResolvedValue([]),
+        }),
+    },
 }));
 jest.mock('../core/discovery/view-discovery.js', () => ({
     ViewDiscovery: {
         getInstance: jest.fn().mockReturnValue({
-            discoverViews: jest.fn().mockResolvedValue([])
-        })
-    }
+            discoverViews: jest.fn().mockResolvedValue([]),
+        }),
+    },
 }));
 jest.mock('../dialects/sqlite/discovery/sqlite-index-discovery.js', () => ({
     SQLiteIndexDiscovery: {
         getInstance: jest.fn().mockReturnValue({
             discoverIndexes: jest.fn().mockResolvedValue([]),
             discoverTableIndexes: jest.fn().mockResolvedValue([]),
-            getTableSize: jest.fn().mockResolvedValue({ pages: 0, size: 0, estimatedRows: 0 }),
-            analyzeIndexEfficiency: jest.fn().mockReturnValue({ recommendations: [] })
-        })
-    }
+            getTableSize: jest
+                .fn()
+                .mockResolvedValue({ pages: 0, size: 0, estimatedRows: 0 }),
+            analyzeIndexEfficiency: jest
+                .fn()
+                .mockReturnValue({ recommendations: [] }),
+        }),
+    },
 }));
 jest.mock('../dialects/sqlite/discovery/sqlite-constraint-discovery.js', () => ({
     SQLiteConstraintDiscovery: {
@@ -49,9 +53,11 @@ jest.mock('../dialects/sqlite/discovery/sqlite-constraint-discovery.js', () => (
             isForeignKeySupportEnabled: jest.fn().mockResolvedValue(true),
             getForeignKeyInfo: jest.fn().mockResolvedValue([]),
             discoverTableConstraints: jest.fn().mockResolvedValue([]),
-            analyzeConstraintCompatibility: jest.fn().mockReturnValue({ recommendations: [], compatibilityIssues: [] })
-        })
-    }
+            analyzeConstraintCompatibility: jest
+                .fn()
+                .mockReturnValue({ recommendations: [], compatibilityIssues: [] }),
+        }),
+    },
 }));
 describe('Schema Strategy Integration Tests', () => {
     let coordinator;
@@ -139,7 +145,7 @@ describe('Schema Strategy Integration Tests', () => {
                 selectFrom: jest.fn().mockReturnThis(),
                 select: jest.fn().mockReturnThis(),
                 where: jest.fn().mockReturnThis(),
-                execute: jest.fn().mockResolvedValue([])
+                execute: jest.fn().mockResolvedValue([]),
             };
             const result = await coordinator.discoverSchema(mockKyselyWithError, {}, 'sqlite');
             expect(result).toBeDefined();

package/dist/esm/schema/test/schema-discovery-coordinator.test.js

@@ -6,7 +6,7 @@ const mockKysely = {
     selectFrom: jest.fn(),
     select: jest.fn(),
     where: jest.fn(),
-    execute: jest.fn()
+    execute: jest.fn(),
 };
 // Mock DiscoveryFactory
 const mockFactory = {
@@ -19,7 +19,7 @@ const mockFactory = {
     createDiscoveryServices: jest.fn(),
     getDialectCapabilities: jest.fn(),
     isDialectSupported: jest.fn(),
-    getSupportedDialects: jest.fn()
+    getSupportedDialects: jest.fn(),
 };
 // Mock SQLite coordinator
 const mockSQLiteCoordinator = {
@@ -32,7 +32,7 @@ const mockSQLiteCoordinator = {
     viewDiscovery: {},
     indexDiscovery: {},
     constraintDiscovery: {},
-    enhanceTablesWithSQLiteMetadata: jest.fn()
+    enhanceTablesWithSQLiteMetadata: jest.fn(),
 };
 describe('SchemaDiscoveryCoordinator', () => {
     let coordinator;
@@ -47,7 +47,7 @@ describe('SchemaDiscoveryCoordinator', () => {
             relationshipDiscovery: {},
             viewDiscovery: {},
             indexDiscovery: {},
-            constraintDiscovery: {}
+            constraintDiscovery: {},
         });
         mockFactory.getDialectCapabilities.mockReturnValue({
             supportsViews: true,
@@ -55,7 +55,7 @@ describe('SchemaDiscoveryCoordinator', () => {
             supportsConstraints: true,
             supportsForeignKeys: true,
             supportsCheckConstraints: true,
-            supportsDeferredConstraints: false
+            supportsDeferredConstraints: false,
         });
         mockFactory.isDialectSupported.mockReturnValue(true);
         coordinator = SchemaDiscoveryCoordinator.getInstance();
@@ -78,7 +78,7 @@ describe('SchemaDiscoveryCoordinator', () => {
                 views: [],
                 indexes: [],
                 constraints: [],
-                relationships: []
+                relationships: [],
             };
             mockSQLiteCoordinator.discoverSchema.mockResolvedValue(mockSchemaInfo);
             const result = await coordinator.discoverSchema(mockKysely, {}, 'sqlite');
@@ -112,7 +112,7 @@ describe('SchemaDiscoveryCoordinator', () => {
                 supportsConstraints: true,
                 supportsForeignKeys: true,
                 supportsCheckConstraints: true,
-                supportsDeferredConstraints: false
+                supportsDeferredConstraints: false,
             });
         });
     });
@@ -121,14 +121,14 @@ describe('SchemaDiscoveryCoordinator', () => {
             const config = {
                 excludeTables: ['migrations'],
                 includeViews: true,
-                customTypeMappings: { 'jsonb': 'Record<string, any>' }
+                customTypeMappings: { jsonb: 'Record<string, any>' },
             };
             const mockSchemaInfo = {
                 tables: [],
                 views: [],
                 indexes: [],
                 constraints: [],
-                relationships: []
+                relationships: [],
             };
             mockSQLiteCoordinator.discoverSchema.mockResolvedValue(mockSchemaInfo);
             await coordinator.discoverSchema(mockKysely, config, 'sqlite');

package/dist/esm/schema/test/simple-schema-test.js

@@ -9,52 +9,52 @@ describe('Schema Strategy - Basic Tests', () => {
     test('should verify DiscoveryFactory exists', () => {
         // Test that we can import the DiscoveryFactory
         expect(() => {
-            const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+            const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
             return DiscoveryFactory;
         }).not.toThrow();
     });
     test('should verify SchemaDiscoveryCoordinator exists', () => {
         // Test that we can import the SchemaDiscoveryCoordinator
         expect(() => {
-            const { SchemaDiscoveryCoordinator } = require('../core/coordinators/schema-discovery.coordinator.js');
+            const { SchemaDiscoveryCoordinator, } = require('../core/coordinators/schema-discovery.coordinator.js');
             return SchemaDiscoveryCoordinator;
         }).not.toThrow();
     });
     test('should verify SQLite coordinator exists', () => {
         // Test that we can import the SQLite coordinator
         expect(() => {
-            const { SQLiteDiscoveryCoordinator } = require('../dialects/sqlite/sqlite-discovery.coordinator.js');
+            const { SQLiteDiscoveryCoordinator, } = require('../dialects/sqlite/sqlite-discovery.coordinator.js');
             return SQLiteDiscoveryCoordinator;
         }).not.toThrow();
     });
     test('should verify singleton pattern works for DiscoveryFactory', () => {
-        const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+        const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
         const instance1 = DiscoveryFactory.getInstance();
         const instance2 = DiscoveryFactory.getInstance();
         expect(instance1).toBe(instance2);
     });
     test('should verify singleton pattern works for SchemaDiscoveryCoordinator', () => {
-        const { SchemaDiscoveryCoordinator } = require('../core/coordinators/schema-discovery.coordinator.js');
+        const { SchemaDiscoveryCoordinator, } = require('../core/coordinators/schema-discovery.coordinator.js');
         const instance1 = SchemaDiscoveryCoordinator.getInstance();
         const instance2 = SchemaDiscoveryCoordinator.getInstance();
         expect(instance1).toBe(instance2);
     });
     test('should verify dialect support', () => {
-        const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+        const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
         const factory = DiscoveryFactory.getInstance();
         expect(factory.isDialectSupported('postgresql')).toBe(true);
         expect(factory.isDialectSupported('sqlite')).toBe(true);
         expect(factory.isDialectSupported('mysql')).toBe(false);
     });
     test('should verify error handling for unsupported dialects', () => {
-        const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+        const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
         const factory = DiscoveryFactory.getInstance();
         expect(() => {
             factory.createIndexDiscovery('oracle');
         }).toThrow('Unsupported dialect');
     });
     test('should verify PostgreSQL capabilities', () => {
-        const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+        const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
         const factory = DiscoveryFactory.getInstance();
         const capabilities = factory.getDialectCapabilities('postgresql');
         expect(capabilities.supportsViews).toBe(true);
@@ -65,7 +65,7 @@ describe('Schema Strategy - Basic Tests', () => {
         expect(capabilities.supportsDeferredConstraints).toBe(true);
     });
     test('should verify SQLite capabilities', () => {
-        const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+        const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
         const factory = DiscoveryFactory.getInstance();
         const capabilities = factory.getDialectCapabilities('sqlite');
         expect(capabilities.supportsViews).toBe(true);

package/dist/esm/schema/test/sqlite-discovery-coordinator.test.js

@@ -10,15 +10,15 @@ import { SQLiteConstraintDiscovery } from '../dialects/sqlite/discovery/sqlite-c
 const mockKysely = {
     selectFrom: jest.fn(),
     select: jest.fn(),
-    execute: jest.fn()
+    execute: jest.fn(),
 };
 // Mock DatabaseIntrospector
 jest.mock('../../dialect/database-introspector.js', () => ({
     DatabaseIntrospector: jest.fn().mockImplementation(() => ({
         getTables: jest.fn(),
         getTableMetadata: jest.fn(),
-        getViews: jest.fn()
-    }))
+        getViews: jest.fn(),
+    })),
 }));
 const mockTableData = [
     {
@@ -26,19 +26,19 @@ const mockTableData = [
         columns: [
             { name: 'id', type: 'INTEGER', isPrimaryKey: true, isNullable: false },
             { name: 'email', type: 'TEXT', isNullable: false },
-            { name: 'created_at', type: 'DATETIME', isNullable: false }
+            { name: 'created_at', type: 'DATETIME', isNullable: false },
         ],
-        primaryKey: ['id']
+        primaryKey: ['id'],
     },
     {
         name: 'posts',
         columns: [
             { name: 'id', type: 'INTEGER', isPrimaryKey: true, isNullable: false },
             { name: 'user_id', type: 'INTEGER', isNullable: false },
-            { name: 'title', type: 'TEXT', isNullable: false }
+            { name: 'title', type: 'TEXT', isNullable: false },
         ],
-        primaryKey: ['id']
-    }
+        primaryKey: ['id'],
+    },
 ];
 const mockIndexData = [
     {
@@ -46,23 +46,23 @@ const mockIndexData = [
         columns: ['email'],
         unique: true,
         isPrimary: false,
-        definition: 'CREATE UNIQUE INDEX users_email_idx ON users(email)'
+        definition: 'CREATE UNIQUE INDEX users_email_idx ON users(email)',
     },
     {
         name: 'posts_user_id_idx',
         columns: ['user_id'],
         unique: false,
         isPrimary: false,
-        definition: 'CREATE INDEX posts_user_id_idx ON posts(user_id)'
-    }
+        definition: 'CREATE INDEX posts_user_id_idx ON posts(user_id)',
+    },
 ];
 const mockConstraintData = [
     {
         name: 'users_email_check',
         type: 'CHECK',
         definition: "email LIKE '%@%'",
-        valid: true
-    }
+        valid: true,
+    },
 ];
 const mockForeignKeyData = [
     {
@@ -71,8 +71,8 @@ const mockForeignKeyData = [
         referencedTable: 'users',
         referencedColumn: 'id',
         onDelete: 'CASCADE',
-        onUpdate: 'NO ACTION'
-    }
+        onUpdate: 'NO ACTION',
+    },
 ];
 const mockViewData = [
     {
@@ -80,9 +80,9 @@ const mockViewData = [
         definition: 'SELECT u.email, p.title FROM users u JOIN posts p ON u.id = p.user_id',
         columns: [
             { name: 'email', type: 'TEXT' },
-            { name: 'title', type: 'TEXT' }
-        ]
-    }
+            { name: 'title', type: 'TEXT' },
+        ],
+    },
 ];
 const mockRelationshipData = [
     {
@@ -90,13 +90,13 @@ const mockRelationshipData = [
         fromColumn: 'user_id',
         toTable: 'users',
         toColumn: 'id',
-        type: 'many-to-one'
-    }
+        type: 'many-to-one',
+    },
 ];
 const mockTableSize = {
     pages: 10,
     size: 40960,
-    estimatedRows: 100
+    estimatedRows: 100,
 };
 describe('SQLiteDiscoveryCoordinator', () => {
     let coordinator;
@@ -111,35 +111,45 @@ describe('SQLiteDiscoveryCoordinator', () => {
         SQLiteDiscoveryCoordinator.instance = undefined;
         // Create mocks
         mockTableDiscovery = {
-            discoverTables: jest.fn().mockResolvedValue(mockTableData)
+            discoverTables: jest.fn().mockResolvedValue(mockTableData),
         };
         mockRelationshipDiscovery = {
-            discoverRelationships: jest.fn().mockResolvedValue(mockRelationshipData)
+            discoverRelationships: jest.fn().mockResolvedValue(mockRelationshipData),
         };
         mockViewDiscovery = {
-            discoverViews: jest.fn().mockResolvedValue(mockViewData)
+            discoverViews: jest.fn().mockResolvedValue(mockViewData),
         };
         mockIndexDiscovery = {
             discoverTableIndexes: jest.fn().mockResolvedValue(mockIndexData),
             getTableSize: jest.fn().mockResolvedValue(mockTableSize),
             analyzeIndexEfficiency: jest.fn().mockReturnValue({
-                recommendations: ['Consider using covering indexes for better performance']
-            })
+                recommendations: [
+                    'Consider using covering indexes for better performance',
+                ],
+            }),
         };
         mockConstraintDiscovery = {
             isForeignKeySupportEnabled: jest.fn().mockResolvedValue(true),
             discoverTableConstraints: jest.fn().mockResolvedValue(mockConstraintData),
             getForeignKeyInfo: jest.fn().mockResolvedValue(mockForeignKeyData),
             analyzeConstraintCompatibility: jest.fn().mockReturnValue({
-                recommendations: ['Consider optimizing constraint definitions']
-            })
+                recommendations: ['Consider optimizing constraint definitions'],
+            }),
         };
         // Mock static methods
-        jest.spyOn(TableMetadataDiscovery, 'getInstance').mockReturnValue(mockTableDiscovery);
-        jest.spyOn(RelationshipDiscovery, 'getInstance').mockReturnValue(mockRelationshipDiscovery);
+        jest
+            .spyOn(TableMetadataDiscovery, 'getInstance')
+            .mockReturnValue(mockTableDiscovery);
+        jest
+            .spyOn(RelationshipDiscovery, 'getInstance')
+            .mockReturnValue(mockRelationshipDiscovery);
         jest.spyOn(ViewDiscovery, 'getInstance').mockReturnValue(mockViewDiscovery);
-        jest.spyOn(SQLiteIndexDiscovery, 'getInstance').mockReturnValue(mockIndexDiscovery);
-        jest.spyOn(SQLiteConstraintDiscovery, 'getInstance').mockReturnValue(mockConstraintDiscovery);
+        jest
+            .spyOn(SQLiteIndexDiscovery, 'getInstance')
+            .mockReturnValue(mockIndexDiscovery);
+        jest
+            .spyOn(SQLiteConstraintDiscovery, 'getInstance')
+            .mockReturnValue(mockConstraintDiscovery);
         coordinator = SQLiteDiscoveryCoordinator.getInstance();
     });
     afterEach(() => {
@@ -189,8 +199,8 @@ describe('SQLiteDiscoveryCoordinator', () => {
                         name: 'users_email_idx',
                         columns: ['email'],
                         unique: true,
-                        definition: 'CREATE UNIQUE INDEX users_email_idx ON users(email)'
-                    })
+                        definition: 'CREATE UNIQUE INDEX users_email_idx ON users(email)',
+                    }),
                 ]),
                 constraints: mockConstraintData,
                 foreignKeys: expect.arrayContaining([
@@ -199,10 +209,10 @@ describe('SQLiteDiscoveryCoordinator', () => {
                         column: 'user_id',
                         referencedTable: 'users',
                         referencedColumn: 'id',
-                        onDelete: 'CASCADE'
-                    })
+                        onDelete: 'CASCADE',
+                    }),
                 ]),
-                tableSize: mockTableSize
+                tableSize: mockTableSize,
             });
         });
         it('should skip views when includeViews is false', async () => {
@@ -218,7 +228,7 @@ describe('SQLiteDiscoveryCoordinator', () => {
                 name: 'users',
                 indexes: [],
                 foreignKeys: [],
-                tableSize: undefined
+                tableSize: undefined,
             });
         });
         it('should handle constraint discovery errors gracefully', async () => {
@@ -248,7 +258,7 @@ describe('SQLiteDiscoveryCoordinator', () => {
                 supportsAutoIncrement: true,
                 supportsRowId: true,
                 supportsTriggers: true,
-                supportsFullTextSearch: true
+                supportsFullTextSearch: true,
             });
         });
     });
@@ -257,7 +267,7 @@ describe('SQLiteDiscoveryCoordinator', () => {
             mockConstraintDiscovery.isForeignKeySupportEnabled.mockResolvedValue(false);
             const tables = [
                 { name: 'users', primaryKey: ['id'], indexes: [], foreignKeys: [] },
-                { name: 'posts', primaryKey: ['id'], indexes: [], foreignKeys: [] }
+                { name: 'posts', primaryKey: ['id'], indexes: [], foreignKeys: [] },
             ];
             const recommendations = await coordinator.getRecommendations(mockKysely, tables);
             expect(mockConstraintDiscovery.isForeignKeySupportEnabled).toHaveBeenCalled();
@@ -271,14 +281,16 @@ describe('SQLiteDiscoveryCoordinator', () => {
         });
         it('should recommend enabling foreign keys when disabled', async () => {
             mockConstraintDiscovery.isForeignKeySupportEnabled.mockResolvedValue(false);
-            const tables = [{ name: 'users', primaryKey: ['id'], indexes: [], foreignKeys: [] }];
+            const tables = [
+                { name: 'users', primaryKey: ['id'], indexes: [], foreignKeys: [] },
+            ];
             const recommendations = await coordinator.getRecommendations(mockKysely, tables);
             expect(recommendations).toContain('Consider enabling foreign key support with PRAGMA foreign_keys = ON for better data integrity');
         });
         it('should recommend primary key for tables without one', async () => {
             const tables = [
                 { name: 'users', primaryKey: [], indexes: [], foreignKeys: [] },
-                { name: 'posts', primaryKey: ['id'], indexes: [], foreignKeys: [] }
+                { name: 'posts', primaryKey: ['id'], indexes: [], foreignKeys: [] },
             ];
             const recommendations = await coordinator.getRecommendations(mockKysely, tables);
             expect(recommendations).toContain('Table users should have a primary key for better performance');
@@ -286,9 +298,13 @@ describe('SQLiteDiscoveryCoordinator', () => {
         it('should handle recommendation errors gracefully', async () => {
             mockConstraintDiscovery.isForeignKeySupportEnabled.mockResolvedValue(false);
             mockIndexDiscovery.discoverTableIndexes.mockRejectedValue(new Error('Index analysis failed'));
-            const tables = [{ name: 'users', primaryKey: ['id'], indexes: [], foreignKeys: [] }];
+            const tables = [
+                { name: 'users', primaryKey: ['id'], indexes: [], foreignKeys: [] },
+            ];
             const recommendations = await coordinator.getRecommendations(mockKysely, tables);
-            expect(recommendations).toEqual(['Consider enabling foreign key support with PRAGMA foreign_keys = ON for better data integrity']);
+            expect(recommendations).toEqual([
+                'Consider enabling foreign key support with PRAGMA foreign_keys = ON for better data integrity',
+            ]);
         });
         it('should handle empty tables array', async () => {
             const recommendations = await coordinator.getRecommendations(mockKysely, []);
@@ -304,7 +320,7 @@ describe('SQLiteDiscoveryCoordinator', () => {
                 'Use WAL mode for better concurrency: PRAGMA journal_mode = WAL',
                 'Set appropriate cache size: PRAGMA cache_size = -64000',
                 'Enable query optimization: PRAGMA optimize',
-                'Consider using prepared statements for better performance'
+                'Consider using prepared statements for better performance',
             ]);
         });
     });
@@ -350,14 +366,14 @@ describe('SQLiteDiscoveryCoordinator', () => {
             const config = {
                 excludeTables: ['temp_*'],
                 includeViews: true,
-                customTypeMappings: { 'INTEGER': 'number' }
+                customTypeMappings: { INTEGER: 'number' },
             };
             await coordinator.discoverSchema(mockKysely, config);
             expect(mockTableDiscovery.discoverTables).toHaveBeenCalledWith(expect.any(Object), // DatabaseIntrospector
             {
                 excludeTables: ['temp_*'],
                 includeViews: true,
-                customTypeMappings: { 'INTEGER': 'number' }
+                customTypeMappings: { INTEGER: 'number' },
             });
         });
         it('should use default configuration when none provided', async () => {
@@ -365,7 +381,7 @@ describe('SQLiteDiscoveryCoordinator', () => {
             expect(mockTableDiscovery.discoverTables).toHaveBeenCalledWith(expect.any(Object), {
                 excludeTables: undefined,
                 includeViews: undefined,
-                customTypeMappings: undefined
+                customTypeMappings: undefined,
             });
         });
     });

package/dist/esm/schema/test/test-runner.js

@@ -76,7 +76,7 @@ export default {
         'sqlite-discovery-coordinator.test.ts',
         'dialect-capabilities.test.ts',
         'error-handling.test.ts',
-        'integration.test.ts'
+        'integration.test.ts',
     ],
     coverage: {
         factory: '100%',
@@ -84,6 +84,6 @@ export default {
         sqlite: '100%',
         capabilities: '100%',
         errorHandling: '100%',
-        integration: '100%'
-    }
+        integration: '100%',
+    },
 };

package/dist/esm/sqlite-migration/index.d.ts

@@ -1,6 +1,6 @@
 export { SQLiteMigrationManager } from './sqlite-migration-manager.js';
 export { SQLiteMigrationProvider } from './sqlite-migration-provider.js';
-export type { SQLiteMigrationConfig, SQLiteMigrationResult, SQLiteMigrationPlan } from './sqlite-migration-manager.js';
-export type { SQLiteMigrationFile, SQLiteMigrationProviderConfig } from './sqlite-migration-provider.js';
+export type { SQLiteMigrationConfig, SQLiteMigrationResult, SQLiteMigrationPlan, } from './sqlite-migration-manager.js';
+export type { SQLiteMigrationFile, SQLiteMigrationProviderConfig, } from './sqlite-migration-provider.js';
 export declare function createSQLiteMigrationManager(db: any, config?: Partial<import('./sqlite-migration-manager.js').SQLiteMigrationConfig>, logger?: import('../logging/logger.js').Logger): Promise<import('./sqlite-migration-manager.js').SQLiteMigrationManager>;
 export declare function createSQLiteMigrationProvider(config?: Partial<import('./sqlite-migration-provider.js').SQLiteMigrationProviderConfig>, logger?: import('../logging/logger.js').Logger): Promise<import('./sqlite-migration-provider.js').SQLiteMigrationProvider>;