@verdant-web/common 1.11.0 → 1.12.0

package/dist/esm/indexes.test.js

@@ -1,126 +1,126 @@
-import { describe, expect, it } from 'vitest';
-import { COMPOUND_INDEX_LOWER_BOUND_SEPARATOR, COMPOUND_INDEX_SEPARATOR, COMPOUND_INDEX_UPPER_BOUND_SEPARATOR, createCompoundIndexValue, createLowerBoundIndexValue, createUpperBoundIndexValue, } from './indexes.js';
-describe('compound indexes', () => {
-    it('can be created from two string values', () => {
-        expect(createCompoundIndexValue('a', 'b')).toEqual(`a${COMPOUND_INDEX_SEPARATOR}b`);
-    });
-    it('can be created from two number values', () => {
-        expect(createCompoundIndexValue(1, 2)).toEqual(`1${COMPOUND_INDEX_SEPARATOR}2`);
-    });
-    it('can be created from an array and string value', () => {
-        expect(createCompoundIndexValue(['a', 'b'], 'c')).toEqual([
-            `a${COMPOUND_INDEX_SEPARATOR}c`,
-            `b${COMPOUND_INDEX_SEPARATOR}c`,
-        ]);
-    });
-    it('can be created from a string and array of numbers', () => {
-        expect(createCompoundIndexValue('a', [1, 2])).toEqual([
-            `a${COMPOUND_INDEX_SEPARATOR}1`,
-            `a${COMPOUND_INDEX_SEPARATOR}2`,
-        ]);
-    });
-    it('can be created from an array of strings and an array of booleans', () => {
-        expect(createCompoundIndexValue(['a', 'b'], [true, false])).toEqual([
-            `a${COMPOUND_INDEX_SEPARATOR}true`,
-            `a${COMPOUND_INDEX_SEPARATOR}false`,
-            `b${COMPOUND_INDEX_SEPARATOR}true`,
-            `b${COMPOUND_INDEX_SEPARATOR}false`,
-        ]);
-    });
-    it('remove duplicate array compound index values', () => {
-        expect(createCompoundIndexValue(['a', 'b', 'b'], [true, false, true])).toEqual([
-            `a${COMPOUND_INDEX_SEPARATOR}true`,
-            `a${COMPOUND_INDEX_SEPARATOR}false`,
-            `b${COMPOUND_INDEX_SEPARATOR}true`,
-            `b${COMPOUND_INDEX_SEPARATOR}false`,
-        ]);
-    });
-    it('creates lower bound value for multi-value indexes', () => {
-        expect(createLowerBoundIndexValue('a', 'b')).toEqual(`a${COMPOUND_INDEX_SEPARATOR}b${COMPOUND_INDEX_SEPARATOR}${COMPOUND_INDEX_LOWER_BOUND_SEPARATOR}`);
-    });
-    it('creates upper bound value for multi-value indexes', () => {
-        expect(createUpperBoundIndexValue('a', 'b')).toEqual(`a${COMPOUND_INDEX_SEPARATOR}b${COMPOUND_INDEX_UPPER_BOUND_SEPARATOR}`);
-    }),
-        it('will always be grouped by the first item', () => {
-            expect([
-                createCompoundIndexValue('aaaaaa', 'b'),
-                createCompoundIndexValue('aaaaaa', 'c'),
-                createCompoundIndexValue('aaaaaa', 'd'),
-                createCompoundIndexValue('aaaaaa', 'e'),
-                // extra nefarious!
-                createCompoundIndexValue('aaaaaaa', 'no!'),
-                createCompoundIndexValue('aaaaaa ', 'no!'),
-                createCompoundIndexValue(`aaaaaa😎`, 'no!'),
-                createCompoundIndexValue(`aaaaaa😎😎`, 'no!'),
-                createCompoundIndexValue('aaa', 'no!'),
-                createCompoundIndexValue(`aaaaaaa😎no!`, 'no!'),
-            ].sort()).toEqual([
-                `aaaaaa ${COMPOUND_INDEX_SEPARATOR}no!`,
-                `aaaaaaa😎no!${COMPOUND_INDEX_SEPARATOR}no!`,
-                `aaaaaaa${COMPOUND_INDEX_SEPARATOR}no!`,
-                `aaaaaa😎😎${COMPOUND_INDEX_SEPARATOR}no!`,
-                `aaaaaa😎${COMPOUND_INDEX_SEPARATOR}no!`,
-                // this is the contiguous block of relevant values
-                `aaaaaa${COMPOUND_INDEX_SEPARATOR}b`,
-                `aaaaaa${COMPOUND_INDEX_SEPARATOR}c`,
-                `aaaaaa${COMPOUND_INDEX_SEPARATOR}d`,
-                `aaaaaa${COMPOUND_INDEX_SEPARATOR}e`,
-                // here ends the block
-                `aaa${COMPOUND_INDEX_SEPARATOR}no!`,
-            ]);
-        });
-    it('will be bounded by upper and lower bound values', () => {
-        const match = 'aaaaaa';
-        const sorted = [
-            createCompoundIndexValue(match, 'b'),
-            createCompoundIndexValue(match, 'c'),
-            createCompoundIndexValue(match, 'd'),
-            createCompoundIndexValue(match, 'e'),
-            // extra nefarious!
-            createCompoundIndexValue(`${match}a`, 'no!'),
-            createCompoundIndexValue(`${match} `, 'no!'),
-            createCompoundIndexValue(`${match}😎`, 'no!'),
-            createCompoundIndexValue(`${match}😎😎`, 'no!'),
-            createCompoundIndexValue('aaa', 'no!'),
-            createCompoundIndexValue(`${match}a😎no!`, 'no!'),
-        ].sort();
-        const boundedBlock = sorted.filter((value) => value > createLowerBoundIndexValue(match) &&
-            value < createUpperBoundIndexValue(match));
-        expect(boundedBlock).toEqual([
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}b`,
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}c`,
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}d`,
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}e`,
-        ]);
-    });
-    it('will be bounded by upper and lower bounds when matching multiple sections', () => {
-        const match1 = 'aaaaaa';
-        const match2 = 'bbbbbb';
-        const sorted = [
-            createCompoundIndexValue(match1, match2, 'b'),
-            createCompoundIndexValue(match1, match2, 'c'),
-            createCompoundIndexValue(match1, match2, 'd'),
-            createCompoundIndexValue(match1, match2, 'e'),
-            // extra nefarious!
-            createCompoundIndexValue(`${match1}a`, match2, 'no!'),
-            createCompoundIndexValue(`${match1} `, match2, 'no!'),
-            createCompoundIndexValue(`${match1}😎`, match2, 'no!'),
-            createCompoundIndexValue(`${match1}😎😎`, match2, 'no!'),
-            createCompoundIndexValue('aaa', match2, 'no!'),
-            createCompoundIndexValue(`${match1}a😎no!`, match2, 'no!'),
-            createCompoundIndexValue(match1, `${match2}a😎no!`, 'no!'),
-            createCompoundIndexValue(match1, `${match2} `, 'no!'),
-            createCompoundIndexValue(match1, ' ', 'no!'),
-            createCompoundIndexValue(match1, '\u00001', 'no!'),
-            createCompoundIndexValue(match1, '\uE007f', 'no!'),
-        ].sort();
-        expect(sorted.filter((value) => value > createLowerBoundIndexValue(match1, match2) &&
-            value < createUpperBoundIndexValue(match1, match2))).toEqual([
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}b`,
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}c`,
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}d`,
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}e`,
-        ]);
-    });
-});
+import { describe, expect, it } from 'vitest';
+import { COMPOUND_INDEX_LOWER_BOUND_SEPARATOR, COMPOUND_INDEX_SEPARATOR, COMPOUND_INDEX_UPPER_BOUND_SEPARATOR, createCompoundIndexValue, createLowerBoundIndexValue, createUpperBoundIndexValue, } from './indexes.js';
+describe('compound indexes', () => {
+    it('can be created from two string values', () => {
+        expect(createCompoundIndexValue('a', 'b')).toEqual(`a${COMPOUND_INDEX_SEPARATOR}b`);
+    });
+    it('can be created from two number values', () => {
+        expect(createCompoundIndexValue(1, 2)).toEqual(`1${COMPOUND_INDEX_SEPARATOR}2`);
+    });
+    it('can be created from an array and string value', () => {
+        expect(createCompoundIndexValue(['a', 'b'], 'c')).toEqual([
+            `a${COMPOUND_INDEX_SEPARATOR}c`,
+            `b${COMPOUND_INDEX_SEPARATOR}c`,
+        ]);
+    });
+    it('can be created from a string and array of numbers', () => {
+        expect(createCompoundIndexValue('a', [1, 2])).toEqual([
+            `a${COMPOUND_INDEX_SEPARATOR}1`,
+            `a${COMPOUND_INDEX_SEPARATOR}2`,
+        ]);
+    });
+    it('can be created from an array of strings and an array of booleans', () => {
+        expect(createCompoundIndexValue(['a', 'b'], [true, false])).toEqual([
+            `a${COMPOUND_INDEX_SEPARATOR}true`,
+            `a${COMPOUND_INDEX_SEPARATOR}false`,
+            `b${COMPOUND_INDEX_SEPARATOR}true`,
+            `b${COMPOUND_INDEX_SEPARATOR}false`,
+        ]);
+    });
+    it('remove duplicate array compound index values', () => {
+        expect(createCompoundIndexValue(['a', 'b', 'b'], [true, false, true])).toEqual([
+            `a${COMPOUND_INDEX_SEPARATOR}true`,
+            `a${COMPOUND_INDEX_SEPARATOR}false`,
+            `b${COMPOUND_INDEX_SEPARATOR}true`,
+            `b${COMPOUND_INDEX_SEPARATOR}false`,
+        ]);
+    });
+    it('creates lower bound value for multi-value indexes', () => {
+        expect(createLowerBoundIndexValue('a', 'b')).toEqual(`a${COMPOUND_INDEX_SEPARATOR}b${COMPOUND_INDEX_SEPARATOR}${COMPOUND_INDEX_LOWER_BOUND_SEPARATOR}`);
+    });
+    it('creates upper bound value for multi-value indexes', () => {
+        expect(createUpperBoundIndexValue('a', 'b')).toEqual(`a${COMPOUND_INDEX_SEPARATOR}b${COMPOUND_INDEX_UPPER_BOUND_SEPARATOR}`);
+    }),
+        it('will always be grouped by the first item', () => {
+            expect([
+                createCompoundIndexValue('aaaaaa', 'b'),
+                createCompoundIndexValue('aaaaaa', 'c'),
+                createCompoundIndexValue('aaaaaa', 'd'),
+                createCompoundIndexValue('aaaaaa', 'e'),
+                // extra nefarious!
+                createCompoundIndexValue('aaaaaaa', 'no!'),
+                createCompoundIndexValue('aaaaaa ', 'no!'),
+                createCompoundIndexValue(`aaaaaa😎`, 'no!'),
+                createCompoundIndexValue(`aaaaaa😎😎`, 'no!'),
+                createCompoundIndexValue('aaa', 'no!'),
+                createCompoundIndexValue(`aaaaaaa😎no!`, 'no!'),
+            ].sort()).toEqual([
+                `aaaaaa ${COMPOUND_INDEX_SEPARATOR}no!`,
+                `aaaaaaa😎no!${COMPOUND_INDEX_SEPARATOR}no!`,
+                `aaaaaaa${COMPOUND_INDEX_SEPARATOR}no!`,
+                `aaaaaa😎😎${COMPOUND_INDEX_SEPARATOR}no!`,
+                `aaaaaa😎${COMPOUND_INDEX_SEPARATOR}no!`,
+                // this is the contiguous block of relevant values
+                `aaaaaa${COMPOUND_INDEX_SEPARATOR}b`,
+                `aaaaaa${COMPOUND_INDEX_SEPARATOR}c`,
+                `aaaaaa${COMPOUND_INDEX_SEPARATOR}d`,
+                `aaaaaa${COMPOUND_INDEX_SEPARATOR}e`,
+                // here ends the block
+                `aaa${COMPOUND_INDEX_SEPARATOR}no!`,
+            ]);
+        });
+    it('will be bounded by upper and lower bound values', () => {
+        const match = 'aaaaaa';
+        const sorted = [
+            createCompoundIndexValue(match, 'b'),
+            createCompoundIndexValue(match, 'c'),
+            createCompoundIndexValue(match, 'd'),
+            createCompoundIndexValue(match, 'e'),
+            // extra nefarious!
+            createCompoundIndexValue(`${match}a`, 'no!'),
+            createCompoundIndexValue(`${match} `, 'no!'),
+            createCompoundIndexValue(`${match}😎`, 'no!'),
+            createCompoundIndexValue(`${match}😎😎`, 'no!'),
+            createCompoundIndexValue('aaa', 'no!'),
+            createCompoundIndexValue(`${match}a😎no!`, 'no!'),
+        ].sort();
+        const boundedBlock = sorted.filter((value) => value > createLowerBoundIndexValue(match) &&
+            value < createUpperBoundIndexValue(match));
+        expect(boundedBlock).toEqual([
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}b`,
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}c`,
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}d`,
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}e`,
+        ]);
+    });
+    it('will be bounded by upper and lower bounds when matching multiple sections', () => {
+        const match1 = 'aaaaaa';
+        const match2 = 'bbbbbb';
+        const sorted = [
+            createCompoundIndexValue(match1, match2, 'b'),
+            createCompoundIndexValue(match1, match2, 'c'),
+            createCompoundIndexValue(match1, match2, 'd'),
+            createCompoundIndexValue(match1, match2, 'e'),
+            // extra nefarious!
+            createCompoundIndexValue(`${match1}a`, match2, 'no!'),
+            createCompoundIndexValue(`${match1} `, match2, 'no!'),
+            createCompoundIndexValue(`${match1}😎`, match2, 'no!'),
+            createCompoundIndexValue(`${match1}😎😎`, match2, 'no!'),
+            createCompoundIndexValue('aaa', match2, 'no!'),
+            createCompoundIndexValue(`${match1}a😎no!`, match2, 'no!'),
+            createCompoundIndexValue(match1, `${match2}a😎no!`, 'no!'),
+            createCompoundIndexValue(match1, `${match2} `, 'no!'),
+            createCompoundIndexValue(match1, ' ', 'no!'),
+            createCompoundIndexValue(match1, '\u00001', 'no!'),
+            createCompoundIndexValue(match1, '\uE007f', 'no!'),
+        ].sort();
+        expect(sorted.filter((value) => value > createLowerBoundIndexValue(match1, match2) &&
+            value < createUpperBoundIndexValue(match1, match2))).toEqual([
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}b`,
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}c`,
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}d`,
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}e`,
+        ]);
+    });
+});
 //# sourceMappingURL=indexes.test.js.map

package/dist/esm/migration.d.ts

@@ -1,98 +1,98 @@
-import { StorageCollectionSchema, StorageSchema, StorageDocument, CollectionFilter, StorageDocumentInit } from './index.js';
-export interface DroppedCollectionMigrationStrategy<Old extends StorageCollectionSchema<any, any, any>> {
-    (old: Old): void | Promise<void>;
-}
-export interface PreservedCollectionMigrationStrategy<Old extends StorageCollectionSchema<any, any, any>, New extends StorageCollectionSchema<any, any, any>> {
-    (old: StorageDocument<Old>): StorageDocument<New> | Promise<StorageDocument<New>>;
-}
-declare type MigrationStrategy<Old extends StorageCollectionSchema<any, any, any>, New extends StorageCollectionSchema<any, any, any>> = DroppedCollectionMigrationStrategy<Old> | PreservedCollectionMigrationStrategy<Old, New>;
-export declare type MigrationsKeyedOnCollection<Old extends StorageSchema<any>, New extends StorageSchema<any>> = PreservedCollectionMigrations<Old, New> | DroppedCollectionMigrations<Old, New>;
-declare type NotInSchema<Name extends string | number | symbol, Schema extends StorageSchema<any>> = Name extends keyof Schema['collections'] ? never : Name;
-declare type InSchema<Name extends string | number | symbol, Schema extends StorageSchema<any>> = Name extends keyof Schema['collections'] ? Name : never;
-declare type DroppedCollections<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
-    [Key in keyof Old['collections'] as NotInSchema<Key, New>]: StorageCollectionSchema<any, any, any>;
-};
-declare type PreservedCollections<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
-    [Key in keyof Old['collections'] as InSchema<Key, New>]: StorageCollectionSchema<any, any, any>;
-};
-declare type DroppedCollectionMigrations<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
-    [Key in keyof DroppedCollections<Old, New>]: DroppedCollectionMigrationStrategy<Old['collections'][Key]>;
-};
-declare type PreservedCollectionMigrations<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
-    [Key in keyof PreservedCollections<Old, New>]: PreservedCollectionMigrationStrategy<Old['collections'][Key], New['collections'][Key]>;
-};
-declare type StrategyFor<Key extends string, Old extends StorageSchema<any>, New extends StorageSchema<any>> = Key extends keyof New['collections'] ? PreservedCollectionMigrationStrategy<Old['collections'][Key], New['collections'][Key]> : DroppedCollectionMigrationStrategy<Old['collections'][Key]>;
-declare type MigrationRunner<Old extends StorageSchema<any>, New extends StorageSchema<any>> = <Collection extends Extract<keyof Old['collections'], string>>(collection: Collection, strategy: StrategyFor<Collection, Old, New>) => Promise<void>;
-declare type MigrationQueryMaker<Collection extends StorageCollectionSchema<any, any, any>> = {
-    get(primaryKey: string): Promise<StorageDocument<Collection> | undefined>;
-    findOne(query: CollectionFilter): Promise<StorageDocument<Collection> | undefined>;
-    findAll(query?: CollectionFilter): Promise<StorageDocument<Collection>[]>;
-};
-declare type MigrationQueries<Old extends StorageSchema<any>> = {
-    [Key in keyof Old['collections']]: MigrationQueryMaker<Old['collections'][Key]>;
-};
-declare type MigrationMutations<New extends StorageSchema> = {
-    [Key in keyof New['collections']]: {
-        put(document: StorageDocumentInit<New['collections'][Key]>): Promise<StorageDocument<New['collections'][Key]>>;
-        delete(primaryKey: string): Promise<void>;
-    };
-};
-export interface MigrationTools<Old extends StorageSchema<any>, New extends StorageSchema<any>> {
-    migrate: MigrationRunner<Old, New>;
-    identity: <T>(val: T) => T;
-    withDefaults: (collectionName: string, value: any) => any;
-    queries: MigrationQueries<Old>;
-    mutations: MigrationMutations<New>;
-    info: {
-        changedCollections: keyof Old['collections'][];
-        addedCollections: keyof New['collections'][];
-        removedCollections: keyof Old['collections'][];
-    };
-}
-export interface MigrationEngine<Old extends StorageSchema, New extends StorageSchema> {
-    migrate: (collection: string, strategy: MigrationStrategy<any, any>) => Promise<void>;
-    queries: MigrationQueries<Old>;
-    mutations: MigrationMutations<New>;
-    /** OIDs of any new documents created during the migration */
-    newOids: string[];
-    /** Promises that should be resolved before completing the migration */
-    awaitables: Promise<any>[];
-}
-declare type MigrationProcedure<Old extends StorageSchema, New extends StorageSchema> = (tools: MigrationTools<Old, New>) => Promise<void>;
-declare type EmptySchema = {
-    version: 0;
-    collections: {};
-};
-export declare function migrate<Schema extends StorageSchema>(schema: Schema, procedure: MigrationProcedure<EmptySchema, Schema>): Migration<EmptySchema, Schema>;
-export declare function migrate<Old extends StorageSchema, New extends StorageSchema>(oldSchema: Old, newSchema: New, procedure: MigrationProcedure<Old, New>): Migration<Old, New>;
-export interface MigrationIndexDescription {
-    name: string;
-    multiEntry: boolean;
-    synthetic: boolean;
-    compound: boolean;
-}
-export interface Migration<Old extends StorageSchema = any, New extends StorageSchema = any> {
-    version: number;
-    oldSchema: Old;
-    newSchema: New;
-    migrate: (engine: MigrationEngine<Old, New>) => Promise<void>;
-    /** Collections which are added in the new schema and not present in the old */
-    addedCollections: string[];
-    /** Collections which were removed from the old schema */
-    removedCollections: string[];
-    /** All collections which exist after the migration has completed - i.e. the ones in the new schema */
-    allCollections: string[];
-    /** Only the collections which were in the old schema */
-    oldCollections: string[];
-    /** Collections whose fields or indexes changed between schemas */
-    changedCollections: string[];
-    addedIndexes: Record<string, MigrationIndexDescription[]>;
-    removedIndexes: Record<string, MigrationIndexDescription[]>;
-}
-export declare function migrationRange(from: number, to: number): number[];
-export declare function createDefaultMigration(schema: StorageSchema): Migration<{
-    version: 0;
-    collections: {};
-}>;
-export declare function createDefaultMigration<Old extends StorageSchema>(oldSchema: Old, newSchema: StorageSchema): Migration<Old>;
-export {};
+import { StorageCollectionSchema, StorageSchema, StorageDocument, CollectionFilter, StorageDocumentInit } from './index.js';
+export interface DroppedCollectionMigrationStrategy<Old extends StorageCollectionSchema<any, any, any>> {
+    (old: Old): void | Promise<void>;
+}
+export interface PreservedCollectionMigrationStrategy<Old extends StorageCollectionSchema<any, any, any>, New extends StorageCollectionSchema<any, any, any>> {
+    (old: StorageDocument<Old>): StorageDocument<New> | Promise<StorageDocument<New>>;
+}
+declare type MigrationStrategy<Old extends StorageCollectionSchema<any, any, any>, New extends StorageCollectionSchema<any, any, any>> = DroppedCollectionMigrationStrategy<Old> | PreservedCollectionMigrationStrategy<Old, New>;
+export declare type MigrationsKeyedOnCollection<Old extends StorageSchema<any>, New extends StorageSchema<any>> = PreservedCollectionMigrations<Old, New> | DroppedCollectionMigrations<Old, New>;
+declare type NotInSchema<Name extends string | number | symbol, Schema extends StorageSchema<any>> = Name extends keyof Schema['collections'] ? never : Name;
+declare type InSchema<Name extends string | number | symbol, Schema extends StorageSchema<any>> = Name extends keyof Schema['collections'] ? Name : never;
+declare type DroppedCollections<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
+    [Key in keyof Old['collections'] as NotInSchema<Key, New>]: StorageCollectionSchema<any, any, any>;
+};
+declare type PreservedCollections<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
+    [Key in keyof Old['collections'] as InSchema<Key, New>]: StorageCollectionSchema<any, any, any>;
+};
+declare type DroppedCollectionMigrations<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
+    [Key in keyof DroppedCollections<Old, New>]: DroppedCollectionMigrationStrategy<Old['collections'][Key]>;
+};
+declare type PreservedCollectionMigrations<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
+    [Key in keyof PreservedCollections<Old, New>]: PreservedCollectionMigrationStrategy<Old['collections'][Key], New['collections'][Key]>;
+};
+declare type StrategyFor<Key extends string, Old extends StorageSchema<any>, New extends StorageSchema<any>> = Key extends keyof New['collections'] ? PreservedCollectionMigrationStrategy<Old['collections'][Key], New['collections'][Key]> : DroppedCollectionMigrationStrategy<Old['collections'][Key]>;
+declare type MigrationRunner<Old extends StorageSchema<any>, New extends StorageSchema<any>> = <Collection extends Extract<keyof Old['collections'], string>>(collection: Collection, strategy: StrategyFor<Collection, Old, New>) => Promise<void>;
+declare type MigrationQueryMaker<Collection extends StorageCollectionSchema<any, any, any>> = {
+    get(primaryKey: string): Promise<StorageDocument<Collection> | undefined>;
+    findOne(query: CollectionFilter): Promise<StorageDocument<Collection> | undefined>;
+    findAll(query?: CollectionFilter): Promise<StorageDocument<Collection>[]>;
+};
+declare type MigrationQueries<Old extends StorageSchema<any>> = {
+    [Key in keyof Old['collections']]: MigrationQueryMaker<Old['collections'][Key]>;
+};
+declare type MigrationMutations<New extends StorageSchema> = {
+    [Key in keyof New['collections']]: {
+        put(document: StorageDocumentInit<New['collections'][Key]>): Promise<StorageDocument<New['collections'][Key]>>;
+        delete(primaryKey: string): Promise<void>;
+    };
+};
+export interface MigrationTools<Old extends StorageSchema<any>, New extends StorageSchema<any>> {
+    migrate: MigrationRunner<Old, New>;
+    identity: <T>(val: T) => T;
+    withDefaults: (collectionName: string, value: any) => any;
+    queries: MigrationQueries<Old>;
+    mutations: MigrationMutations<New>;
+    info: {
+        changedCollections: keyof Old['collections'][];
+        addedCollections: keyof New['collections'][];
+        removedCollections: keyof Old['collections'][];
+    };
+}
+export interface MigrationEngine<Old extends StorageSchema, New extends StorageSchema> {
+    migrate: (collection: string, strategy: MigrationStrategy<any, any>) => Promise<void>;
+    queries: MigrationQueries<Old>;
+    mutations: MigrationMutations<New>;
+    /** OIDs of any new documents created during the migration */
+    newOids: string[];
+    /** Promises that should be resolved before completing the migration */
+    awaitables: Promise<any>[];
+}
+declare type MigrationProcedure<Old extends StorageSchema, New extends StorageSchema> = (tools: MigrationTools<Old, New>) => Promise<void>;
+declare type EmptySchema = {
+    version: 0;
+    collections: {};
+};
+export declare function migrate<Schema extends StorageSchema>(schema: Schema, procedure: MigrationProcedure<EmptySchema, Schema>): Migration<EmptySchema, Schema>;
+export declare function migrate<Old extends StorageSchema, New extends StorageSchema>(oldSchema: Old, newSchema: New, procedure: MigrationProcedure<Old, New>): Migration<Old, New>;
+export interface MigrationIndexDescription {
+    name: string;
+    multiEntry: boolean;
+    synthetic: boolean;
+    compound: boolean;
+}
+export interface Migration<Old extends StorageSchema = any, New extends StorageSchema = any> {
+    version: number;
+    oldSchema: Old;
+    newSchema: New;
+    migrate: (engine: MigrationEngine<Old, New>) => Promise<void>;
+    /** Collections which are added in the new schema and not present in the old */
+    addedCollections: string[];
+    /** Collections which were removed from the old schema */
+    removedCollections: string[];
+    /** All collections which exist after the migration has completed - i.e. the ones in the new schema */
+    allCollections: string[];
+    /** Only the collections which were in the old schema */
+    oldCollections: string[];
+    /** Collections whose fields or indexes changed between schemas */
+    changedCollections: string[];
+    addedIndexes: Record<string, MigrationIndexDescription[]>;
+    removedIndexes: Record<string, MigrationIndexDescription[]>;
+}
+export declare function migrationRange(from: number, to: number): number[];
+export declare function createDefaultMigration(schema: StorageSchema): Migration<{
+    version: 0;
+    collections: {};
+}>;
+export declare function createDefaultMigration<Old extends StorageSchema>(oldSchema: Old, newSchema: StorageSchema): Migration<Old>;
+export {};