@verdant-web/common 2.2.0 → 2.3.0-next.0

package/dist/esm/index.d.ts

@@ -1,21 +0,0 @@
-export * from './protocol.js';
-export * from './timestamp.js';
-export * from './operation.js';
-export * from './baseline.js';
-export * from './replica.js';
-export * from './schema/index.js';
-export * from './utils.js';
-export * from './indexes.js';
-export { migrate, migrationRange, createDefaultMigration, createMigration, } from './migration.js';
-export type { Migration, MigrationIndexDescription, MigrationEngine, } from './migration.js';
-export type { UserInfo } from './presence.js';
-export * from './patch.js';
-export * from './oids.js';
-export * from './EventSubscriber.js';
-export * from './undo.js';
-export * from './batching.js';
-export * from './files.js';
-export type { Ref } from './refs.js';
-export { makeObjectRef, makeFileRef, isRef, compareRefs } from './refs.js';
-export * from './memo.js';
-export * from './error.js';

package/dist/esm/indexes.d.ts

@@ -1,17 +0,0 @@
-import { StorageCollectionSchema, StorageDirectSyntheticSchema } from './index.js';
-export declare const COMPOUND_INDEX_SEPARATOR = "\uFFFFFE";
-export declare const COMPOUND_INDEX_LOWER_BOUND_SEPARATOR = "\0";
-export declare const COMPOUND_INDEX_UPPER_BOUND_SEPARATOR = "\uFFFFFF";
-declare type IndexableFieldValue = string | number | boolean | any[];
-export declare type CompoundIndexValue = string | string[];
-export declare function createCompoundIndexValue(...fields: IndexableFieldValue[]): CompoundIndexValue;
-export declare function createUpperBoundIndexValue(...fields: IndexableFieldValue[]): string;
-export declare function createLowerBoundIndexValue(...fields: IndexableFieldValue[]): string;
-export declare function isDirectSynthetic(index: any): index is StorageDirectSyntheticSchema<any>;
-export declare function computeSynthetics(schema: StorageCollectionSchema, obj: any): Record<string, any>;
-export declare function computeCompoundIndices(schema: StorageCollectionSchema<any, any, any>, doc: any): any;
-export declare function getIndexValues(schema: StorageCollectionSchema<any, any, any>, doc: any): any;
-export declare function assignIndexValues(schema: StorageCollectionSchema<any, any, any>, doc: any): any;
-export declare const NULL_INDEX_VALUE = "null";
-export declare function sanitizeIndexValue(value: unknown): string | number | (string | number)[];
-export {};

package/dist/esm/indexes.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/memo.d.ts

@@ -1,6 +0,0 @@
-/**
- * Memoizes the last invocation of a function with the same memo keys.
- * As long as key identity and set doesn't change, the last computed
- * value will be returned.
- */
-export declare function memoByKeys<TRet, TKeys extends any[]>(fn: (...args: unknown[]) => TRet, getKeys: () => TKeys): (...args: unknown[]) => TRet;

package/dist/esm/memo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/migration.d.ts

@@ -1,174 +0,0 @@
-import { StorageCollectionSchema, StorageSchema, StorageDocument, CollectionFilter, StorageDocumentInit } from './index.js';
-/**@deprecated */
-export interface DroppedCollectionMigrationStrategy<Old extends StorageCollectionSchema<any, any, any>> {
-    (old: Old): void | Promise<void>;
-}
-/**@deprecated */
-export interface PreservedCollectionMigrationStrategy<Old extends StorageCollectionSchema<any, any, any>, New extends StorageCollectionSchema<any, any, any>> {
-    (old: StorageDocument<Old>): StorageDocument<New> | Promise<StorageDocument<New>>;
-}
-/** @deprecated */
-export declare type MigrationsKeyedOnCollection<Old extends StorageSchema<any>, New extends StorageSchema<any>> = PreservedCollectionMigrations<Old, New> | DroppedCollectionMigrations<Old, New>;
-/**@deprecated */
-declare type NotInSchema<Name extends string | number | symbol, Schema extends StorageSchema<any>> = Name extends keyof Schema['collections'] ? never : Name;
-/** @deprecated */
-declare type InSchema<Name extends string | number | symbol, Schema extends StorageSchema<any>> = Name extends keyof Schema['collections'] ? Name : never;
-/** @deprecated */
-declare type DroppedCollections<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
-    [Key in keyof Old['collections'] as NotInSchema<Key, New>]: StorageCollectionSchema<any, any, any>;
-};
-/** @deprecated */
-declare type PreservedCollections<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
-    [Key in keyof Old['collections'] as InSchema<Key, New>]: StorageCollectionSchema<any, any, any>;
-};
-/** @deprecated */
-declare type DroppedCollectionMigrations<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
-    [Key in keyof DroppedCollections<Old, New>]: DroppedCollectionMigrationStrategy<Old['collections'][Key]>;
-};
-/** @deprecated */
-declare type PreservedCollectionMigrations<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
-    [Key in keyof PreservedCollections<Old, New>]: PreservedCollectionMigrationStrategy<Old['collections'][Key], New['collections'][Key]>;
-};
-/** @deprecated */
-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]>;
-/** @deprecated */
-declare type DeprecatedMigrationRunner<Old extends StorageSchema<any>, New extends StorageSchema<any>> = <Collection extends Extract<keyof Old['collections'], string>>(collection: Collection, strategy: StrategyFor<Collection, Old, New>) => Promise<void>;
-/** @deprecated */
-declare type DeprecatedMigrationQueryMaker<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>[]>;
-};
-/** @deprecated */
-declare type DeprecatedMigrationQueries<Old extends StorageSchema<any>> = {
-    [Key in keyof Old['collections']]: DeprecatedMigrationQueryMaker<Old['collections'][Key]>;
-};
-/** @deprecated */
-declare type DeprecatedMigrationMutations<New extends StorageSchema> = {
-    [Key in keyof New['collections']]: {
-        put(document: StorageDocumentInit<New['collections'][Key]>): Promise<StorageDocument<New['collections'][Key]>>;
-        delete(primaryKey: string): Promise<void>;
-    };
-};
-/** @deprecated */
-export interface DeprecatedMigrationTools<Old extends StorageSchema<any>, New extends StorageSchema<any>> {
-    migrate: DeprecatedMigrationRunner<Old, New>;
-    identity: <T>(val: T) => T;
-    /**
-     * @deprecated - default field values are automatically
-     * applied during migration, you don't need to use this.
-     * Please remove it from your migrations - even old ones
-     * (old migrations can be updated!)
-     */
-    withDefaults: (collectionName: string, value: any) => any;
-    queries: DeprecatedMigrationQueries<Old>;
-    mutations: DeprecatedMigrationMutations<New>;
-    info: {
-        changedCollections: keyof Old['collections'][];
-        addedCollections: keyof New['collections'][];
-        removedCollections: keyof Old['collections'][];
-    };
-}
-export interface MigrationEngine {
-    migrate: (collection: string, strategy: (val: any) => any) => Promise<void>;
-    queries: MigrationQueries<any>;
-    mutations: MigrationMutations<any>;
-    /** OIDs of any new documents created during the migration */
-    newOids: string[];
-    /** Promises that should be resolved before completing the migration */
-    awaitables: Promise<any>[];
-    /** Deletes all documents in a collection - used for removed collections */
-    deleteCollection: (collection: string) => Promise<void>;
-    log: (...messages: any[]) => void;
-}
-/** @deprecated */
-declare type DeprecatedMigrationProcedure<Old extends StorageSchema, New extends StorageSchema> = (tools: DeprecatedMigrationTools<Old, New>) => Promise<void>;
-declare type EmptySchema = {
-    version: 0;
-    collections: {};
-};
-/** @deprecated - use createMigration */
-export declare function migrate<Schema extends StorageSchema>(schema: Schema, procedure: DeprecatedMigrationProcedure<EmptySchema, Schema>): Migration<EmptySchema, Schema>;
-/** @deprecated = use createMigration */
-export declare function migrate<Old extends StorageSchema, New extends StorageSchema>(oldSchema: Old, newSchema: New, procedure: DeprecatedMigrationProcedure<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) => 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[];
-/** @deprecated - use createMigration with no procedure function */
-export declare function createDefaultMigration(schema: StorageSchema): Migration<{
-    version: 0;
-    collections: {};
-}>;
-/** @deprecated - use createMigration with no procedure function */
-export declare function createDefaultMigration<Old extends StorageSchema>(oldSchema: Old, newSchema: StorageSchema): Migration<Old>;
-/** New, simpler type-safety migration tools */
-declare type DocumentShape<Init = any, Snapshot = any> = {
-    init: Init;
-    snapshot: Snapshot;
-};
-declare type SchemaDocuments = Record<string, DocumentShape>;
-declare type CollectionProcedure<OldSnapshot, NewInit> = {
-    (old: OldSnapshot): NewInit | Promise<NewInit>;
-};
-declare type MigrationQueries<Old extends SchemaDocuments> = {
-    [Key in keyof Old]: {
-        get(primaryKey: string): Promise<Old[Key]['snapshot'] | undefined>;
-        findOne(query: CollectionFilter): Promise<Old[Key]['snapshot'] | undefined>;
-        findAll(query?: CollectionFilter): Promise<Old[Key]['snapshot'][]>;
-    };
-};
-declare type MigrationMutations<New extends SchemaDocuments> = {
-    [Key in keyof New]: {
-        put(document: New[Key]['init']): Promise<New[Key]['snapshot']>;
-        delete(primaryKey: string): Promise<void>;
-    };
-};
-declare type MigrationTools<Old extends SchemaDocuments, New extends SchemaDocuments> = {
-    /**
-     * Process a change in a collection's documents by taking in each existing
-     * document and returning its new shape. This is typed so you can be
-     * confident the proper transformations are made.
-     */
-    migrate: <Collection extends keyof Old & keyof New>(collection: Collection, strategy: CollectionProcedure<Old[Collection]['snapshot'], New[Collection]['init']>) => Promise<void>;
-    mutations: MigrationMutations<New>;
-    queries: MigrationQueries<Old>;
-    info: {
-        changedCollections: (keyof Old & keyof New)[];
-        addedCollections: (keyof New)[];
-        removedCollections: (keyof Old)[];
-    };
-};
-declare type MigrationProcedure<Old extends SchemaDocuments, New extends SchemaDocuments> = {
-    (tools: MigrationTools<Old, New>): Promise<void>;
-};
-declare type InitialMigrationTools<New extends SchemaDocuments> = {
-    mutations: MigrationMutations<New>;
-};
-declare type InitialMigrationProcedure<New extends SchemaDocuments> = {
-    (tools: InitialMigrationTools<New>): Promise<void>;
-};
-export declare function createMigration<New extends SchemaDocuments>(newSchema: StorageSchema, procedure?: InitialMigrationProcedure<New>): any;
-export declare function createMigration<Old extends SchemaDocuments, New extends SchemaDocuments>(oldSchema: StorageSchema, newSchema: StorageSchema, procedure?: MigrationProcedure<Old, New>): any;
-export {};

package/dist/esm/oids.d.ts

@@ -1,101 +0,0 @@
-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 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, createSubId?: () => string): string;
-export declare function ensureCompatibleOid(obj: any, rootOid: ObjectIdentifier, createSubId?: () => string): string;
-export declare function createOid(collection: string, documentId: string, subId?: string): string;
-export declare function createSubOid(root: ObjectIdentifier, createSubId?: () => string): string;
-export declare function decomposeOid(oid: ObjectIdentifier): {
-    collection: string;
-    id: string;
-    subId?: string;
-};
-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
- * all of an OID's possible sub-objects.
- */
-export declare function getOidSubIdRange(oid: ObjectIdentifier): string[];
-export declare function getLegacyDotOidSubIdRange(oid: ObjectIdentifier): string[];
-export declare function getRoots(oids: ObjectIdentifier[]): string[];
-export declare function areOidsRelated(oidA: ObjectIdentifier, oidB: ObjectIdentifier): boolean;
-/**
- * Recursively rewrites any OIDs in an object which are 'foreign' -
- * i.e. relate to some other object/entity - to be local to the
- * current object. This is deterministic, so it can be done
- * on multiple clients independently with predictable results.
- */
-export declare function fixForeignOids(obj: any): void;
-export declare function isLegacyDotOid(oid: ObjectIdentifier): boolean;
-export declare function convertLegacyOid(oid: ObjectIdentifier): string;
-export declare const MATCH_LEGACY_OID_JSON_STRING: RegExp;
-export declare function replaceLegacyOidsInJsonString(string: string): string;
-export declare function replaceLegacyOidsInObject(obj: any): any;
-export declare function isRootOid(oid: ObjectIdentifier): boolean;

package/dist/esm/oids.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/operation.d.ts

@@ -1,142 +0,0 @@
-import { DocumentBaseline } from './baseline.js';
-import { FileRef } from './files.js';
-import { ObjectIdentifier } from './oids.js';
-export declare type ObjectRef = {
-    '@@type': 'ref';
-    id: ObjectIdentifier;
-};
-export declare function isObjectRef(obj: any): obj is ObjectRef;
-export declare type Normalized<T> = {
-    [key in keyof T]: T[key] extends Object ? ObjectRef : T[key];
-};
-export declare type PropertyName = string | number;
-/**
- * List patches can target a particular child list or
- * nested lists. The first path item is the property path
- * of the first child list, any subsequent values are nested
- * list indices.
- */
-export declare type PropertyValue = string | number | boolean | null | undefined | ObjectRef | FileRef;
-interface BaseOperationPatch {
-}
-export interface OperationPatchInitialize extends BaseOperationPatch {
-    op: 'initialize';
-    value: any;
-}
-export interface OperationPatchSet extends BaseOperationPatch {
-    op: 'set';
-    name: PropertyName;
-    value: PropertyValue;
-}
-export interface OperationPatchRemove extends BaseOperationPatch {
-    op: 'remove';
-    name: PropertyName;
-}
-export interface OperationPatchListPush extends BaseOperationPatch {
-    op: 'list-push';
-    value: PropertyValue;
-}
-export interface OperationPatchListInsert extends BaseOperationPatch {
-    op: 'list-insert';
-    index: number;
-    value?: PropertyValue;
-    values?: PropertyValue[];
-}
-export interface OperationPatchListDelete extends BaseOperationPatch {
-    op: 'list-delete';
-    index: number;
-    count: number;
-}
-/**
- * Optimal for lists of object references. Moves
- * the selected item to the target index even if it
- * is not at the original index anymore.
- */
-export interface OperationPatchListMoveByRef extends BaseOperationPatch {
-    op: 'list-move-by-ref';
-    value: ObjectRef | FileRef;
-    index: number;
-}
-/**
- * Suitable for any list move, whether object lists
- * or primitive lists.
- */
-export interface OperationPatchListMoveByIndex extends BaseOperationPatch {
-    op: 'list-move-by-index';
-    from: number;
-    to: number;
-}
-/**
- * Removes all instances of the value from
- * the list. Good for set behavior or removing
- * a specific item even if it changes index
- * from conflicts.
- */
-export interface OperationPatchListRemove extends BaseOperationPatch {
-    op: 'list-remove';
-    value: PropertyValue;
-    only?: 'first' | 'last';
-}
-export interface OperationPatchListAdd extends BaseOperationPatch {
-    op: 'list-add';
-    value: PropertyValue;
-}
-export interface OperationPatchDelete extends BaseOperationPatch {
-    op: 'delete';
-}
-export interface OperationPatchTouch extends BaseOperationPatch {
-    op: 'touch';
-}
-export declare type OperationPatch = OperationPatchInitialize | OperationPatchSet | OperationPatchRemove | OperationPatchListPush | OperationPatchListInsert | OperationPatchListDelete | OperationPatchListMoveByRef | OperationPatchListMoveByIndex | OperationPatchListRemove | OperationPatchDelete | OperationPatchListAdd | OperationPatchTouch;
-export declare type Operation = {
-    oid: ObjectIdentifier;
-    timestamp: string;
-    data: OperationPatch;
-};
-export declare function diffToPatches<T extends {
-    [key: string]: any;
-} | any[]>(from: T, to: T, getNow: () => string, createSubId?: () => string, patches?: Operation[], options?: {
-    /**
-     * If an object is merged with another and the new one does not
-     * have an OID assigned, assume it is the same identity as previous
-     */
-    mergeUnknownObjects?: boolean;
-    /**
-     * If an incoming value is not assigned on the new object, use the previous value.
-     * If false, undefined properties will erase the previous value.
-     */
-    defaultUndefined?: boolean;
-}): Operation[];
-export declare function shallowDiffToPatches(from: any, to: any, getNow: () => string, patches?: Operation[]): Operation[];
-/**
- * Takes a basic object and constructs a patch list to create it and
- * all of its nested objects.
- */
-export declare function initialToPatches(initial: any, rootOid: ObjectIdentifier, getNow: () => string, createSubId?: () => string, patches?: Operation[]): Operation[];
-export declare function shallowInitialToPatches(initial: any, rootOid: ObjectIdentifier, getNow: () => string, patches?: Operation[]): Operation[];
-export declare function groupPatchesByOid(patches: Operation[]): Record<string, Operation[]>;
-export declare function groupPatchesByRootOid(patches: Operation[]): Record<string, Operation[]>;
-export declare function groupBaselinesByRootOid(baselines: DocumentBaseline[]): Record<string, DocumentBaseline<any>[]>;
-export declare type NormalizedObject = {
-    [key: PropertyName]: PropertyValue;
-} | Array<PropertyValue>;
-/**
- * The incoming object should already be normalized!
- * This function will mutate the base object.
- */
-export declare function applyPatch<T extends NormalizedObject>(base: T | undefined, patch: OperationPatch, 
-/**
- * Optionally supply a list to which any refs which
- * are removed during the patch will be appended.
- */
-deletedRefs?: (FileRef | ObjectRef)[]): T | undefined;
-export declare function applyOperations<T extends NormalizedObject>(base: T | undefined, operations: Operation[], deletedRefs?: (ObjectRef | FileRef)[]): T | undefined;
-/**
- * Mutates the original object in place. Returns all referenced
- * objects oids.
- */
-export declare function substituteRefsWithObjects(base: any, refs: Map<ObjectIdentifier, any>, used?: ObjectIdentifier[]): ObjectIdentifier[];
-export declare function substituteFirstLevelObjectsWithRefs<Base extends {
-    [key: string]: any;
-} | any[]>(base: Base, refObjects?: Map<ObjectIdentifier, any>): Map<ObjectIdentifier, any>;
-export {};

package/dist/esm/operation.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/patch.d.ts

@@ -1,28 +0,0 @@
-/**
- * High-level patch creation for use with complex nested objects.
- */
-import { FileRef } from './files.js';
-import { ObjectIdentifier } from './oids.js';
-import { ObjectRef, Operation, PropertyName } from './operation.js';
-export declare class PatchCreator {
-    private getNow;
-    private createSubId?;
-    constructor(getNow: () => string, createSubId?: (() => string) | undefined);
-    isPrimitive: (value: any) => boolean;
-    createDiff: (from: any, to: any, options?: {
-        mergeUnknownObjects?: boolean;
-        defaultUndefined?: boolean;
-    }) => Operation[];
-    createInitialize: (obj: any, oid: ObjectIdentifier) => Operation[];
-    createSet: (oid: ObjectIdentifier, key: PropertyName, value: any) => Operation[];
-    createRemove: (oid: ObjectIdentifier, key: PropertyName) => Operation[];
-    createListPush: (oid: ObjectIdentifier, value: any) => Operation[];
-    createListAdd: (oid: ObjectIdentifier, value: any) => Operation[];
-    createListInsert: (oid: ObjectIdentifier, index: number, value: any) => Operation[];
-    createListRemove: (oid: ObjectIdentifier, value: any, only?: 'first' | 'last') => Operation[];
-    createListDelete: (oid: ObjectIdentifier, index: number, count?: number) => Operation[];
-    createListMoveByRef: (oid: ObjectIdentifier, value: ObjectRef | FileRef, index: number) => Operation[];
-    createListMoveByIndex: (oid: ObjectIdentifier, fromIndex: number, toIndex: number) => Operation[];
-    createDelete: (oid: ObjectIdentifier) => Operation[];
-    createDeleteAll: (oids: ObjectIdentifier[]) => Operation[];
-}

package/dist/esm/presence.d.ts

@@ -1,29 +0,0 @@
-export interface UserInfo<Profile, Presence> {
-    /**
-     * @deprecated - include the ID in your Profile data instead.
-     *
-     * This is the ID representing the user who is utilizing a
-     * replica client to connect to the storage network.
-     * One user may have multiple replica clients active at once,
-     * but their presence will only reflect the most recent
-     * replica used.
-     */
-    id: string;
-    /**
-     * This is the ID representing the replica client that is
-     * connected to the storage network. This is used to
-     * identify the client when sending messages to it.
-     */
-    replicaId: string;
-    /**
-     * This is the user's server profile. This data is associated
-     * with the logged in user of the app and cannot be modified
-     * by the local replica directly.
-     */
-    profile: Profile;
-    /**
-     * Presence info which can update frequently as a replica
-     * makes changes. The shape of presence is up to you.
-     */
-    presence: Presence;
-}