@verdant-web/common 1.11.0 → 1.11.1

package/dist/cjs/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 {};

package/dist/cjs/migration.js

@@ -1,128 +1,128 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDefaultMigration = exports.migrationRange = exports.migrate = void 0;
-const index_js_1 = require("./index.js");
-const emptySchema = {
-    version: 0,
-    collections: {},
-};
-function migrate(oldSchemaOrNewSchema, newSchemaOrProcedure, procedureIfTwoSchemas) {
-    const isProcedureSecondArgument = typeof newSchemaOrProcedure === 'function';
-    const oldSchema = isProcedureSecondArgument
-        ? emptySchema
-        : oldSchemaOrNewSchema;
-    const newSchema = isProcedureSecondArgument
-        ? oldSchemaOrNewSchema
-        : newSchemaOrProcedure;
-    const procedure = isProcedureSecondArgument
-        ? newSchemaOrProcedure
-        : procedureIfTwoSchemas;
-    // diff to determine changed collections
-    const changedCollections = Object.keys(newSchema.collections).filter((key) => oldSchema.collections[key] &&
-        (0, index_js_1.stableStringify)(oldSchema.collections[key]) !==
-            (0, index_js_1.stableStringify)(newSchema.collections[key]));
-    const removedCollections = Object.keys(oldSchema.collections).filter((key) => !newSchema.collections[key]);
-    const addedCollections = Object.keys(newSchema.collections).filter((key) => !oldSchema.collections[key]);
-    const addedIndexes = {};
-    const removedIndexes = {};
-    for (const changed of [...changedCollections, ...addedCollections]) {
-        const oldIndexes = getIndexes(oldSchema.collections[changed]);
-        const newIndexes = getIndexes(newSchema.collections[changed]);
-        const added = newIndexes.filter((index) => !oldIndexes.find((i) => i.name === index.name));
-        const removed = oldIndexes.filter((index) => !newIndexes.find((i) => i.name === index.name));
-        if (added.length > 0) {
-            addedIndexes[changed] = added;
-        }
-        if (removed.length > 0) {
-            removedIndexes[changed] = removed;
-        }
-    }
-    return {
-        version: newSchema.version,
-        migrate: async (engine) => {
-            const migratedCollections = [];
-            await procedure({
-                migrate: async (collection, strategy) => {
-                    // @ts-ignore
-                    await engine.migrate(collection, strategy);
-                    migratedCollections.push(collection);
-                },
-                identity: (val) => val,
-                withDefaults: (collectionName, val) => {
-                    return (0, index_js_1.addFieldDefaults)(newSchema.collections[collectionName], val);
-                },
-                info: {
-                    changedCollections,
-                    addedCollections,
-                    removedCollections,
-                },
-                queries: engine.queries,
-                mutations: engine.mutations,
-            });
-            const unmigrated = changedCollections.filter((collection) => !migratedCollections.includes(collection));
-            if (unmigrated.length > 0) {
-                console.error('Unmigrated changed collections:', unmigrated);
-            }
-        },
-        removedCollections,
-        addedIndexes,
-        removedIndexes,
-        allCollections: Object.keys(newSchema.collections),
-        changedCollections,
-        addedCollections,
-        oldCollections: Object.keys(oldSchema.collections),
-        oldSchema,
-        newSchema,
-    };
-}
-exports.migrate = migrate;
-function migrationRange(from, to) {
-    return [...Array(to - from).keys()].map((i) => 1 + i + from);
-}
-exports.migrationRange = migrationRange;
-function getIndexes(collection) {
-    if (!collection)
-        return [];
-    const fields = Object.keys(collection.fields)
-        .filter((key) => collection.fields[key].indexed)
-        .map((key) => ({
-        name: key,
-        multiEntry: collection.fields[key].type === 'array',
-        synthetic: false,
-        compound: false,
-    }));
-    return [
-        ...fields,
-        ...Object.keys(collection.synthetics || {}).map((key) => ({
-            name: key,
-            multiEntry: ['array', 'string[]', 'number[]', 'boolean[]'].includes(collection.synthetics[key].type),
-            synthetic: true,
-            compound: false,
-        })),
-        ...Object.keys(collection.compounds || {}).map((key) => ({
-            name: key,
-            multiEntry: collection.compounds[key].of.some((fieldName) => (collection.fields[fieldName] || collection.synthetics[fieldName])
-                .type === 'array'),
-            synthetic: false,
-            compound: true,
-        })),
-    ];
-}
-function createDefaultMigration(schema, newSchema) {
-    let oldSchema = newSchema
-        ? schema
-        : {
-            version: 0,
-            collections: {},
-        };
-    return migrate(oldSchema, newSchema || schema, async ({ migrate, withDefaults, info }) => {
-        if ((newSchema || schema).version === 1)
-            return;
-        for (const collection of info.changedCollections) {
-            // @ts-ignore indefinite type resolution
-            await migrate(collection, (old) => withDefaults(collection, old));
-        }
-    });
-}
-exports.createDefaultMigration = createDefaultMigration;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultMigration = exports.migrationRange = exports.migrate = void 0;
+const index_js_1 = require("./index.js");
+const emptySchema = {
+    version: 0,
+    collections: {},
+};
+function migrate(oldSchemaOrNewSchema, newSchemaOrProcedure, procedureIfTwoSchemas) {
+    const isProcedureSecondArgument = typeof newSchemaOrProcedure === 'function';
+    const oldSchema = isProcedureSecondArgument
+        ? emptySchema
+        : oldSchemaOrNewSchema;
+    const newSchema = isProcedureSecondArgument
+        ? oldSchemaOrNewSchema
+        : newSchemaOrProcedure;
+    const procedure = isProcedureSecondArgument
+        ? newSchemaOrProcedure
+        : procedureIfTwoSchemas;
+    // diff to determine changed collections
+    const changedCollections = Object.keys(newSchema.collections).filter((key) => oldSchema.collections[key] &&
+        (0, index_js_1.stableStringify)(oldSchema.collections[key]) !==
+            (0, index_js_1.stableStringify)(newSchema.collections[key]));
+    const removedCollections = Object.keys(oldSchema.collections).filter((key) => !newSchema.collections[key]);
+    const addedCollections = Object.keys(newSchema.collections).filter((key) => !oldSchema.collections[key]);
+    const addedIndexes = {};
+    const removedIndexes = {};
+    for (const changed of [...changedCollections, ...addedCollections]) {
+        const oldIndexes = getIndexes(oldSchema.collections[changed]);
+        const newIndexes = getIndexes(newSchema.collections[changed]);
+        const added = newIndexes.filter((index) => !oldIndexes.find((i) => i.name === index.name));
+        const removed = oldIndexes.filter((index) => !newIndexes.find((i) => i.name === index.name));
+        if (added.length > 0) {
+            addedIndexes[changed] = added;
+        }
+        if (removed.length > 0) {
+            removedIndexes[changed] = removed;
+        }
+    }
+    return {
+        version: newSchema.version,
+        migrate: async (engine) => {
+            const migratedCollections = [];
+            await procedure({
+                migrate: async (collection, strategy) => {
+                    // @ts-ignore
+                    await engine.migrate(collection, strategy);
+                    migratedCollections.push(collection);
+                },
+                identity: (val) => val,
+                withDefaults: (collectionName, val) => {
+                    return (0, index_js_1.addFieldDefaults)(newSchema.collections[collectionName], val);
+                },
+                info: {
+                    changedCollections,
+                    addedCollections,
+                    removedCollections,
+                },
+                queries: engine.queries,
+                mutations: engine.mutations,
+            });
+            const unmigrated = changedCollections.filter((collection) => !migratedCollections.includes(collection));
+            if (unmigrated.length > 0) {
+                console.error('Unmigrated changed collections:', unmigrated);
+            }
+        },
+        removedCollections,
+        addedIndexes,
+        removedIndexes,
+        allCollections: Object.keys(newSchema.collections),
+        changedCollections,
+        addedCollections,
+        oldCollections: Object.keys(oldSchema.collections),
+        oldSchema,
+        newSchema,
+    };
+}
+exports.migrate = migrate;
+function migrationRange(from, to) {
+    return [...Array(to - from).keys()].map((i) => 1 + i + from);
+}
+exports.migrationRange = migrationRange;
+function getIndexes(collection) {
+    if (!collection)
+        return [];
+    const fields = Object.keys(collection.fields)
+        .filter((key) => collection.fields[key].indexed)
+        .map((key) => ({
+        name: key,
+        multiEntry: collection.fields[key].type === 'array',
+        synthetic: false,
+        compound: false,
+    }));
+    return [
+        ...fields,
+        ...Object.keys(collection.synthetics || {}).map((key) => ({
+            name: key,
+            multiEntry: ['array', 'string[]', 'number[]', 'boolean[]'].includes(collection.synthetics[key].type),
+            synthetic: true,
+            compound: false,
+        })),
+        ...Object.keys(collection.compounds || {}).map((key) => ({
+            name: key,
+            multiEntry: collection.compounds[key].of.some((fieldName) => (collection.fields[fieldName] || collection.synthetics[fieldName])
+                .type === 'array'),
+            synthetic: false,
+            compound: true,
+        })),
+    ];
+}
+function createDefaultMigration(schema, newSchema) {
+    let oldSchema = newSchema
+        ? schema
+        : {
+            version: 0,
+            collections: {},
+        };
+    return migrate(oldSchema, newSchema || schema, async ({ migrate, withDefaults, info }) => {
+        if ((newSchema || schema).version === 1)
+            return;
+        for (const collection of info.changedCollections) {
+            // @ts-ignore indefinite type resolution
+            await migrate(collection, (old) => withDefaults(collection, old));
+        }
+    });
+}
+exports.createDefaultMigration = createDefaultMigration;
 //# sourceMappingURL=migration.js.map

package/dist/cjs/oids.d.ts

@@ -1,87 +1,87 @@
-import { ObjectRef } from './operation.js';
-/**
- * OIDs
- *
- * OIDs are used to identify objects in the document. They also encode
- * information about the object useful to identifying an object found
- * on its own and associating it back to its parent.
- *
- * An OID is structured as such:
- * <collection>/<root id>[/<key paths>]:<random>
- *
- * OIDs have a few characteristics:
- * - They include the collection name of the parent document
- * - They include the primary key of the parent document
- * - They include the key path of the object within the document
- * - They include a random sequence to identify different objects which
- *   exist at the same key path
- *
- * Collection name and document key are used to link any isolated
- * object back to its parent document.
- *
- * The key path is used for authorization - to associate the object
- * (or an operation related to it by OID) with the field it inhabits
- * to utilize authorization rules from that field in the schema.
- *
- * The random sequence allows the application to encode different
- * identities for objects at the same position in a document for
- * conflict resolution purposes
- */
-export declare type ObjectIdentifier = string;
-export declare type KeyPath = (string | number)[];
-export declare const LEGACY_OID_KEY = "__@@oid_do_not_use";
-export declare const OID_KEY = "@@id";
-export declare function getOid(obj: any): string;
-export declare function maybeGetOid(obj: any): ObjectIdentifier | undefined;
-export declare function assignOid(obj: any, oid: ObjectIdentifier): any;
-export declare function hasOid(obj: any): boolean;
-export declare function removeOid(obj: any): any;
-export declare function isOidKey(key: string): boolean;
-/**
- * For sub-objects, assign a random sub-OID if no OID
- * is already assigned.
- */
-export declare function ensureOid(obj: any, rootOid: ObjectIdentifier, key: string | number, createSubId?: () => string): string;
-export declare function createOid(collection: string, documentId: string, keyPath?: KeyPath, subId?: string): string;
-export declare function createSubOid(root: ObjectIdentifier, key: string | number, createSubId?: () => string): string;
-export declare function decomposeOid(oid: ObjectIdentifier): {
-    collection: string;
-    id: string;
-    subId?: string;
-    keyPath: KeyPath;
-};
-export declare function assertAllLevelsHaveOids(obj: any, root?: any): void;
-export declare function assignOidsToAllSubObjects(obj: any, createSubId?: () => string): void;
-export declare function assignOidProperty(obj: any, oid: ObjectIdentifier): any;
-export declare function maybeGetOidProperty(obj: any): any;
-/**
- * Assigns a special property to all objects in the given object
- * which have an OID
- */
-export declare function assignOidPropertiesToAllSubObjects(obj: any): void;
-/**
- *
- * Removes the special property from all objects in the given object
- * which have an OID, transferring the OID from the property to the OID
- * system in-memory.
- */
-export declare function removeOidPropertiesFromAllSubObjects(obj: any): void;
-export declare function removeOidsFromAllSubObjects(obj: any): void;
-export declare function createOidSubId(): string;
-export declare function createRef(oid: ObjectIdentifier): ObjectRef;
-export declare function normalize(obj: any, refs?: Map<ObjectIdentifier, any>): Map<ObjectIdentifier, any>;
-/**
- * Only normalizes direct children. The created map
- * of objects will still have nested objects.
- */
-export declare function normalizeFirstLevel(obj: any): {
-    refs: Map<string, any>;
-    oidKeyPairs: Map<string, string | number>;
-};
-export declare function getOidRoot(oid: ObjectIdentifier): string;
-/**
- * Returns an inclusive range of OIDs that represent
- * a root object and all of its sub-objects.
- */
-export declare function getOidRange(oid: ObjectIdentifier): string[];
-export declare function getRoots(oids: ObjectIdentifier[]): string[];
+import { ObjectRef } from './operation.js';
+/**
+ * OIDs
+ *
+ * OIDs are used to identify objects in the document. They also encode
+ * information about the object useful to identifying an object found
+ * on its own and associating it back to its parent.
+ *
+ * An OID is structured as such:
+ * <collection>/<root id>[/<key paths>]:<random>
+ *
+ * OIDs have a few characteristics:
+ * - They include the collection name of the parent document
+ * - They include the primary key of the parent document
+ * - They include the key path of the object within the document
+ * - They include a random sequence to identify different objects which
+ *   exist at the same key path
+ *
+ * Collection name and document key are used to link any isolated
+ * object back to its parent document.
+ *
+ * The key path is used for authorization - to associate the object
+ * (or an operation related to it by OID) with the field it inhabits
+ * to utilize authorization rules from that field in the schema.
+ *
+ * The random sequence allows the application to encode different
+ * identities for objects at the same position in a document for
+ * conflict resolution purposes
+ */
+export declare type ObjectIdentifier = string;
+export declare type KeyPath = (string | number)[];
+export declare const LEGACY_OID_KEY = "__@@oid_do_not_use";
+export declare const OID_KEY = "@@id";
+export declare function getOid(obj: any): string;
+export declare function maybeGetOid(obj: any): ObjectIdentifier | undefined;
+export declare function assignOid(obj: any, oid: ObjectIdentifier): any;
+export declare function hasOid(obj: any): boolean;
+export declare function removeOid(obj: any): any;
+export declare function isOidKey(key: string): boolean;
+/**
+ * For sub-objects, assign a random sub-OID if no OID
+ * is already assigned.
+ */
+export declare function ensureOid(obj: any, rootOid: ObjectIdentifier, key: string | number, createSubId?: () => string): string;
+export declare function createOid(collection: string, documentId: string, keyPath?: KeyPath, subId?: string): string;
+export declare function createSubOid(root: ObjectIdentifier, key: string | number, createSubId?: () => string): string;
+export declare function decomposeOid(oid: ObjectIdentifier): {
+    collection: string;
+    id: string;
+    subId?: string;
+    keyPath: KeyPath;
+};
+export declare function assertAllLevelsHaveOids(obj: any, root?: any): void;
+export declare function assignOidsToAllSubObjects(obj: any, createSubId?: () => string): void;
+export declare function assignOidProperty(obj: any, oid: ObjectIdentifier): any;
+export declare function maybeGetOidProperty(obj: any): any;
+/**
+ * Assigns a special property to all objects in the given object
+ * which have an OID
+ */
+export declare function assignOidPropertiesToAllSubObjects(obj: any): void;
+/**
+ *
+ * Removes the special property from all objects in the given object
+ * which have an OID, transferring the OID from the property to the OID
+ * system in-memory.
+ */
+export declare function removeOidPropertiesFromAllSubObjects(obj: any): void;
+export declare function removeOidsFromAllSubObjects(obj: any): void;
+export declare function createOidSubId(): string;
+export declare function createRef(oid: ObjectIdentifier): ObjectRef;
+export declare function normalize(obj: any, refs?: Map<ObjectIdentifier, any>): Map<ObjectIdentifier, any>;
+/**
+ * Only normalizes direct children. The created map
+ * of objects will still have nested objects.
+ */
+export declare function normalizeFirstLevel(obj: any): {
+    refs: Map<string, any>;
+    oidKeyPairs: Map<string, string | number>;
+};
+export declare function getOidRoot(oid: ObjectIdentifier): string;
+/**
+ * Returns an inclusive range of OIDs that represent
+ * a root object and all of its sub-objects.
+ */
+export declare function getOidRange(oid: ObjectIdentifier): string[];
+export declare function getRoots(oids: ObjectIdentifier[]): string[];