@verdant-web/store 3.4.0-next.0 → 3.4.0

package/dist/esm/BackoffScheduler.d.ts

@@ -0,0 +1,19 @@
+import { EventSubscriber } from '@verdant-web/common';
+export declare class BackoffScheduler extends EventSubscriber<{
+    trigger: () => void;
+}> {
+    private readonly backoff;
+    private timer;
+    private isScheduled;
+    constructor(backoff: Backoff);
+    next: () => void;
+    reset: () => void;
+}
+export declare class Backoff {
+    current: number;
+    private readonly max;
+    private readonly factor;
+    constructor(max: number, factor: number);
+    next: () => void;
+    reset: () => void;
+}

package/dist/esm/DocumentManager.d.ts

@@ -0,0 +1,28 @@
+import { StorageSchema } from '@verdant-web/common';
+import { EntityStore } from './entities/EntityStore.js';
+import { Metadata } from './metadata/Metadata.js';
+/**
+ * Exposes functionality for creating documents,
+ * the only mutation which is available as an entry
+ * point in the storage system.
+ */
+export declare class DocumentManager<Schema extends StorageSchema<any>> {
+    private meta;
+    private schema;
+    private entities;
+    constructor(meta: Metadata, schema: Schema, entities: EntityStore);
+    private getOid;
+    private addDefaults;
+    create: (collection: string, init: any, options?: {
+        undoable?: boolean;
+    }) => any;
+    delete: (collection: string, primaryKey: string, options?: {
+        undoable?: boolean;
+    }) => Promise<void>;
+    deleteAll: (ids: [string, string][], options?: {
+        undoable?: boolean;
+    }) => Promise<void>;
+    deleteAllFromCollection: (collection: string, ids: string[], options?: {
+        undoable?: boolean;
+    }) => Promise<void>;
+}

package/dist/esm/FakeWeakRef.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This exists since I'm a little anxious about using WeakRef in production
+ * and want to be able to roll it back quickly to debug issues. Basically by adding
+ * import { WeakRef } from 'FakeWeakRef' to the top of the file, we can switch back
+ * to using a simple object reference.
+ */
+export declare class FakeWeakRef<T extends symbol | object> {
+    constructor(value: T);
+    value: T;
+    deref(): T | undefined;
+}

package/dist/esm/IDBService.d.ts

@@ -0,0 +1,30 @@
+import { Context } from './context.js';
+import { Disposable } from './utils/Disposable.js';
+export declare class IDBService extends Disposable {
+    protected db: IDBDatabase;
+    protected log?: Context['log'];
+    private globalAbortController;
+    constructor(db: IDBDatabase, { log }?: {
+        log?: Context['log'];
+    });
+    createTransaction: (storeNames: string[], opts?: {
+        mode?: 'readonly' | 'readwrite';
+        abort?: AbortSignal;
+    }) => IDBTransaction;
+    run: <T>(storeName: string, getRequest: (store: IDBObjectStore) => IDBRequest<T>, opts?: {
+        mode?: 'readonly' | 'readwrite';
+        transaction?: IDBTransaction;
+        abort?: AbortSignal;
+    }) => Promise<T>;
+    runAll: <T>(storeName: string, getRequests: (store: IDBObjectStore) => IDBRequest<T>[], opts?: {
+        mode: 'readonly' | 'readwrite';
+        transaction?: IDBTransaction;
+        abort?: AbortSignal;
+    }) => Promise<T[]>;
+    iterate: <T>(storeName: string, getRequest: (store: IDBObjectStore) => IDBRequest | IDBRequest[], iterator: (value: T, store: IDBObjectStore) => void, opts?: {
+        mode?: 'readonly' | 'readwrite';
+        transaction?: IDBTransaction;
+        abort?: AbortSignal;
+    }) => Promise<void>;
+    clear: (storeName: string) => Promise<undefined>;
+}

package/dist/esm/UndoHistory.d.ts

@@ -0,0 +1,16 @@
+import { EventSubscriber } from '@verdant-web/common';
+type Undoable = () => Undoable | Promise<Undoable | null> | null;
+export declare class UndoHistory extends EventSubscriber<{
+    change: () => void;
+}> {
+    private _undoable;
+    private _undone;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    undo: () => Promise<boolean>;
+    redo: () => Promise<boolean>;
+    addUndo: (undoPoint: Undoable) => void;
+    addRedo: (redoPoint: Undoable) => void;
+    clear: () => void;
+}
+export {};

package/dist/esm/__tests__/batching.test.d.ts

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

package/dist/esm/__tests__/documents.test.d.ts

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

package/dist/esm/__tests__/fixtures/testStorage.d.ts

@@ -0,0 +1,76 @@
+import { ClientWithCollections } from '../../index.js';
+export declare const todoCollection: import("@verdant-web/common").StorageCollectionSchema<{
+    id: import("@verdant-web/common").StorageStringFieldSchema;
+    content: import("@verdant-web/common").StorageStringFieldSchema;
+    done: import("@verdant-web/common").StorageBooleanFieldSchema;
+    tags: import("@verdant-web/common").StorageArrayFieldSchema<import("@verdant-web/common").StorageStringFieldSchema>;
+    category: import("@verdant-web/common").StorageStringFieldSchema;
+    attachments: import("@verdant-web/common").StorageArrayFieldSchema<import("@verdant-web/common").StorageObjectFieldSchema<{
+        name: import("@verdant-web/common").StorageStringFieldSchema;
+        test: import("@verdant-web/common").StorageNumberFieldSchema;
+    }>>;
+}, {
+    content: {
+        field: "content";
+    };
+    example: {
+        type: "string";
+        compute: (doc: import("@verdant-web/common").ShapeFromFields<{
+            id: import("@verdant-web/common").StorageStringFieldSchema;
+            content: import("@verdant-web/common").StorageStringFieldSchema;
+            done: import("@verdant-web/common").StorageBooleanFieldSchema;
+            tags: import("@verdant-web/common").StorageArrayFieldSchema<import("@verdant-web/common").StorageStringFieldSchema>;
+            category: import("@verdant-web/common").StorageStringFieldSchema;
+            attachments: import("@verdant-web/common").StorageArrayFieldSchema<import("@verdant-web/common").StorageObjectFieldSchema<{
+                name: import("@verdant-web/common").StorageStringFieldSchema;
+                test: import("@verdant-web/common").StorageNumberFieldSchema;
+            }>>;
+        }>) => string;
+    };
+}, {
+    tagsSortedByDone: {
+        of: ("done" | "tags")[];
+    };
+    categorySortedByDone: {
+        of: ("done" | "category")[];
+    };
+}>;
+export declare const weirdCollection: import("@verdant-web/common").StorageCollectionSchema<{
+    id: import("@verdant-web/common").StorageStringFieldSchema;
+    weird: import("@verdant-web/common").StorageAnyFieldSchema<any>;
+    map: import("@verdant-web/common").StorageMapFieldSchema<import("@verdant-web/common").StorageStringFieldSchema>;
+    fileList: import("@verdant-web/common").StorageArrayFieldSchema<import("@verdant-web/common").StorageFileFieldSchema>;
+    objectMap: import("@verdant-web/common").StorageMapFieldSchema<import("@verdant-web/common").StorageObjectFieldSchema<{
+        content: import("@verdant-web/common").StorageStringFieldSchema;
+    }>>;
+}, import("@verdant-web/common").StorageSyntheticIndices<{
+    id: import("@verdant-web/common").StorageStringFieldSchema;
+    weird: import("@verdant-web/common").StorageAnyFieldSchema<any>;
+    map: import("@verdant-web/common").StorageMapFieldSchema<import("@verdant-web/common").StorageStringFieldSchema>;
+    fileList: import("@verdant-web/common").StorageArrayFieldSchema<import("@verdant-web/common").StorageFileFieldSchema>;
+    objectMap: import("@verdant-web/common").StorageMapFieldSchema<import("@verdant-web/common").StorageObjectFieldSchema<{
+        content: import("@verdant-web/common").StorageStringFieldSchema;
+    }>>;
+}>, import("@verdant-web/common").CollectionCompoundIndices<{
+    id: import("@verdant-web/common").StorageStringFieldSchema;
+    weird: import("@verdant-web/common").StorageAnyFieldSchema<any>;
+    map: import("@verdant-web/common").StorageMapFieldSchema<import("@verdant-web/common").StorageStringFieldSchema>;
+    fileList: import("@verdant-web/common").StorageArrayFieldSchema<import("@verdant-web/common").StorageFileFieldSchema>;
+    objectMap: import("@verdant-web/common").StorageMapFieldSchema<import("@verdant-web/common").StorageObjectFieldSchema<{
+        content: import("@verdant-web/common").StorageStringFieldSchema;
+    }>>;
+}, import("@verdant-web/common").StorageSyntheticIndices<{
+    id: import("@verdant-web/common").StorageStringFieldSchema;
+    weird: import("@verdant-web/common").StorageAnyFieldSchema<any>;
+    map: import("@verdant-web/common").StorageMapFieldSchema<import("@verdant-web/common").StorageStringFieldSchema>;
+    fileList: import("@verdant-web/common").StorageArrayFieldSchema<import("@verdant-web/common").StorageFileFieldSchema>;
+    objectMap: import("@verdant-web/common").StorageMapFieldSchema<import("@verdant-web/common").StorageObjectFieldSchema<{
+        content: import("@verdant-web/common").StorageStringFieldSchema;
+    }>>;
+}>>>;
+export declare function createTestStorage({ idb, disableRebasing, metadataVersion, log, }?: {
+    idb?: IDBFactory;
+    disableRebasing?: boolean;
+    metadataVersion?: number;
+    log?: (...args: any[]) => void;
+}): Promise<ClientWithCollections>;

package/dist/esm/__tests__/legacyOids.test.d.ts

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

package/dist/esm/__tests__/mutations.test.d.ts

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

package/dist/esm/__tests__/queries.test.d.ts

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

package/dist/esm/__tests__/setup/indexedDB.d.ts

@@ -0,0 +1 @@
+import 'fake-indexeddb/auto';

package/dist/esm/__tests__/undo.test.d.ts

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

package/dist/esm/backup.d.ts

@@ -0,0 +1,10 @@
+import { Client } from './client/Client.js';
+import { ExportData } from './metadata/Metadata.js';
+import { ReturnedFileData } from './files/FileStorage.js';
+export declare function createClientBackup(client: Client): Promise<Blob>;
+export declare function readBackupFile(file: Blob): Promise<{
+    data: ExportData;
+    fileData: Omit<ReturnedFileData, "file">[];
+    files: File[];
+}>;
+export declare function importClientBackup(client: Client, file: Blob): Promise<void>;

package/dist/esm/client/Client.d.ts

@@ -0,0 +1,98 @@
+import { EventSubscriber, Migration } from '@verdant-web/common';
+import { Context } from '../context.js';
+import { DocumentManager } from '../DocumentManager.js';
+import { FileManagerConfig } from '../files/FileManager.js';
+import { ExportData, Metadata } from '../metadata/Metadata.js';
+import { EntityStore } from '../entities/EntityStore.js';
+import { ServerSyncOptions, Sync } from '../sync/Sync.js';
+import { CollectionQueries } from '../queries/CollectionQueries.js';
+import { ReturnedFileData } from '../files/FileStorage.js';
+interface ClientConfig<Presence = any> {
+    syncConfig?: ServerSyncOptions<Presence>;
+    migrations: Migration[];
+    files?: FileManagerConfig;
+}
+export type ClientWithCollections = Client & {
+    [key: string]: CollectionQueries<any, any, any>;
+};
+export declare class Client<Presence = any, Profile = any> extends EventSubscriber<{
+    /**
+     * Called when a change from a future version of the application has
+     * been witnessed. These changes are not applied but it indicates
+     * the app has been updated and a peer is using a newer version.
+     * You should listen to this event and prompt the user to reload
+     * their client, or reload it for them.
+     *
+     * This event may be called multiple times.
+     */
+    futureSeen: () => void;
+}> {
+    private config;
+    private context;
+    readonly meta: Metadata;
+    private _entities;
+    private _queryCache;
+    private _documentManager;
+    private _fileManager;
+    private _closed;
+    readonly collectionNames: string[];
+    private _sync;
+    get sync(): Sync<Presence, Profile>;
+    get entities(): EntityStore;
+    get documentManager(): DocumentManager<any>;
+    constructor(config: ClientConfig, context: Context, components: {
+        meta: Metadata;
+    });
+    private addData;
+    get documentDb(): IDBDatabase;
+    get metaDb(): IDBDatabase;
+    get schema(): import("@verdant-web/common").StorageSchema;
+    get namespace(): string;
+    get undoHistory(): import("../UndoHistory.js").UndoHistory;
+    /**
+     * Batch multiple operations together to be executed in a single transaction.
+     * The changes made will not be included in the same undo history step as
+     * any other changes made outside of the batch. You can also disable undo
+     * for your batch to omit changes from undo history.
+     *
+     * Provide a batch name to apply multiple changes to the same batch
+     * across different invocations. Batches will automatically flush after
+     * a short delay or if they reach a maximum size.
+     */
+    get batch(): ({ undoable, batchName, max, timeout, }?: {
+        undoable?: boolean | undefined;
+        batchName?: string | undefined;
+        max?: number | null | undefined;
+        timeout?: number | null | undefined;
+    }) => import("../entities/OperationBatcher.js").OperationBatch;
+    stats: () => Promise<any>;
+    close: () => Promise<void>;
+    __dangerous__resetLocal: () => Promise<void>;
+    export: ({ downloadRemoteFiles }?: {
+        downloadRemoteFiles?: boolean | undefined;
+    }) => Promise<{
+        data: ExportData;
+        fileData: Omit<ReturnedFileData, "file">[];
+        files: File[];
+    }>;
+    private getFileExportName;
+    private parseFileExportname;
+    import: ({ data, fileData, files, }: {
+        data: ExportData;
+        fileData: Array<Omit<ReturnedFileData, 'file'>>;
+        files: File[];
+    }) => Promise<void>;
+    /**
+     * Export all data, then re-import it. This might resolve
+     * some issues with the local database, but it should
+     * only be done as a second-to-last resort. The last resort
+     * would be __dangerous__resetLocal on ClientDescriptor, which
+     * clears all local data.
+     *
+     * Unlike __dangerous__resetLocal, this method allows local-only
+     * clients to recover data, whereas __dangerous__resetLocal only
+     * lets networked clients recover from the server.
+     */
+    __dangerous__hardReset: () => Promise<void>;
+}
+export {};

package/dist/esm/client/ClientDescriptor.d.ts

@@ -0,0 +1,76 @@
+import { Migration, StorageSchema } from '@verdant-web/common';
+import { FileManagerConfig } from '../files/FileManager.js';
+import { ServerSyncOptions } from '../sync/Sync.js';
+import { UndoHistory } from '../UndoHistory.js';
+import { Client } from './Client.js';
+import { METADATA_VERSION_KEY } from './constants.js';
+export interface ClientDescriptorOptions<Presence = any, Profile = any> {
+    /** The schema used to create this client */
+    schema: StorageSchema<any>;
+    /** Migrations, in order, to upgrade to each successive version of the schema */
+    migrations: Migration<any>[];
+    /** Provide a sync config to turn on synchronization with a server */
+    sync?: ServerSyncOptions<Profile, Presence>;
+    /** Optionally override the IndexedDB implementation */
+    indexedDb?: IDBFactory;
+    /**
+     * Namespaces are used to separate data from different clients in IndexedDB.
+     */
+    namespace: string;
+    /**
+     * Provide your own UndoHistory to have a unified undo system across multiple
+     * clients if you so desire.
+     */
+    undoHistory?: UndoHistory;
+    /**
+     * Provide a log function to log internal debug messages
+     */
+    log?: (...args: any[]) => void;
+    disableRebasing?: boolean;
+    /**
+     * Provide a specific schema number to override the schema version
+     * in the database. This is useful for testing migrations or recovering
+     * from a mistakenly deployed incorrect schema. A specific version is required
+     * so that you don't leave this on accidentally for all new schemas.
+     */
+    overrideSchemaConflict?: number;
+    /**
+     * Configuration for file management
+     */
+    files?: FileManagerConfig;
+    /**
+     * Enables experimental WeakRef usage to cull documents
+     * from cache that aren't being used. This is a performance
+     * optimization which has been tested under all Verdant's test
+     * suites but I still want to keep testing it in the real world
+     * before turning it on.
+     */
+    EXPERIMENTAL_weakRefs?: boolean;
+    [METADATA_VERSION_KEY]?: number;
+}
+/**
+ * Since storage initialization is async, this class wraps the core
+ * Storage creation promise and exposes some metadata which can
+ * be useful immediately.
+ */
+export declare class ClientDescriptor<Presence = any, Profile = any, ClientImpl extends Client = Client> {
+    private readonly init;
+    private readonly _readyPromise;
+    private resolveReady;
+    private rejectReady;
+    private _resolvedValue;
+    private _initializing;
+    private _namespace;
+    get namespace(): string;
+    constructor(init: ClientDescriptorOptions<Presence, Profile>);
+    private initialize;
+    private initializeDatabases;
+    private initializeWIPDatabases;
+    private cleanupWIPDatabases;
+    get current(): ClientImpl | undefined;
+    get readyPromise(): Promise<ClientImpl>;
+    get schema(): StorageSchema<any>;
+    open: () => Promise<ClientImpl>;
+    close: () => Promise<void>;
+    __dangerous__resetLocal: () => Promise<void>;
+}

package/dist/esm/client/constants.d.ts

@@ -0,0 +1 @@
+export declare const METADATA_VERSION_KEY: unique symbol;

package/dist/esm/constants.d.ts

@@ -0,0 +1 @@
+export declare const TEST_API = "__unsafe__test_api__";

package/dist/esm/context.d.ts

@@ -0,0 +1,38 @@
+import { EventSubscriber, Migration, ObjectIdentifier, StorageSchema } from '@verdant-web/common';
+import { UndoHistory } from './UndoHistory.js';
+/**
+ * Common components utilized across various client
+ * services.
+ */
+export interface Context {
+    namespace: string;
+    metaDb: IDBDatabase;
+    documentDb: IDBDatabase;
+    undoHistory: UndoHistory;
+    schema: StorageSchema;
+    log: (...args: any[]) => void;
+    entityEvents: EventSubscriber<{
+        collectionsChanged: (names: string[]) => void;
+        documentChanged: (oid: ObjectIdentifier) => void;
+    }>;
+    internalEvents: EventSubscriber<{
+        documentDbChanged: (db: IDBDatabase) => void;
+    }>;
+    globalEvents: EventSubscriber<{
+        /**
+         * A change from a future version of the application has been
+         * witnessed. These changes are not applied but it indicates
+         * the app has been updated and we should prompt the user
+         * to reload or have their app user manually reload.
+         *
+         * The parameter is the timestamp of the future change.
+         */
+        futureSeen: (timestamp: string) => void;
+    }>;
+    weakRef<T extends object>(value: T): WeakRef<T>;
+    migrations: Migration<any>[];
+    /**
+     * Get the current logical timestamp
+     */
+    getNow(): string;
+}

package/dist/esm/entities/Entity.d.ts

@@ -0,0 +1,148 @@
+import { EntityValidationProblem, EventSubscriber, ObjectIdentifier, PatchCreator, StorageFieldSchema } from '@verdant-web/common';
+import { Context } from '../context.js';
+import { FileManager } from '../files/FileManager.js';
+import { EntityCache } from './EntityCache.js';
+import { EntityFamilyMetadata, EntityMetadataView } from './EntityMetadata.js';
+import { BaseEntityValue, DataFromInit, EntityChange, EntityEvents, ListEntity, ListItemInit, ListItemValue, ObjectEntity } from './types.js';
+import { EntityStoreEvents } from './EntityStore.js';
+export interface EntityInit {
+    oid: ObjectIdentifier;
+    schema: StorageFieldSchema;
+    entityFamily?: EntityCache;
+    metadataFamily: EntityFamilyMetadata;
+    parent?: Entity;
+    ctx: Context;
+    files: FileManager;
+    readonlyKeys?: string[];
+    fieldPath?: (string | number)[];
+    patchCreator: PatchCreator;
+    events: EntityStoreEvents;
+}
+export declare class Entity<Init = any, KeyValue extends BaseEntityValue = any, Snapshot extends any = DataFromInit<Init>> extends EventSubscriber<EntityEvents> implements ObjectEntity<Init, KeyValue, Snapshot>, ListEntity<Init, KeyValue, Snapshot> {
+    readonly oid: ObjectIdentifier;
+    private readonlyKeys;
+    private fieldPath;
+    private entityFamily;
+    private metadataFamily;
+    private schema;
+    private parent;
+    private ctx;
+    private files;
+    private patchCreator;
+    private events;
+    private _viewData;
+    private validationError;
+    private cachedDeepUpdatedAt;
+    private wasDeletedLastChange;
+    private cachedView;
+    constructor({ oid, schema, entityFamily: childCache, parent, ctx, metadataFamily, readonlyKeys, files, patchCreator, events, }: EntityInit);
+    private onAdd;
+    private onReplace;
+    private onResetAll;
+    private get metadata();
+    /**
+     * The view of this Entity, not including nested
+     * entities (that's the snapshot - see #getSnapshot())
+     *
+     * Nested entities are represented by refs.
+     */
+    private get viewData();
+    /** convenience getter for viewData.view */
+    private get rawView();
+    /**
+     * An Entity's View includes the rendering of its underlying data,
+     * connecting of children where refs were, and validation
+     * and pruning according to schema.
+     */
+    private get view();
+    private childIsNull;
+    get uid(): string;
+    get deleted(): boolean;
+    get invalid(): boolean;
+    get isList(): any;
+    get updatedAt(): number;
+    get deepUpdatedAt(): number;
+    /**
+     * @internal - this is relevant to Verdant's system, not users.
+     *
+     * Indicates whether this document is from an outdated version
+     * of the schema - which means it cannot be used until it is upgraded.
+     */
+    get isOutdatedVersion(): boolean;
+    /**
+     * Pruning - when entities have invalid children, we 'prune' that
+     * data up to the nearest prunable point - a nullable field,
+     * or a list.
+     */
+    protected validate: (...args: unknown[]) => EntityValidationProblem | undefined;
+    private viewWithMappedChildren;
+    /**
+     * A current snapshot of this Entity's data, including nested
+     * Entities.
+     */
+    getSnapshot: () => any;
+    private addPendingOperations;
+    private addConfirmedData;
+    private replaceAllData;
+    private resetAllData;
+    private change;
+    protected deepChange: (target: Entity, ev: EntityChange) => void;
+    private getChild;
+    /**
+     * Gets a value from this Entity. If the value
+     * is an object, it will be wrapped in another
+     * Entity.
+     */
+    get: <Key extends keyof KeyValue>(key: Key) => KeyValue[Key];
+    private processInputValue;
+    private getDeleteMode;
+    /**
+     * Returns the referent value of an item in the list, used for
+     * operations which act on items. if the item is an object,
+     * it will attempt to create an OID reference to it. If it
+     * is a primitive, it will return the primitive.
+     */
+    private getItemRefValue;
+    set: <Key extends keyof Init>(key: Key, value: Init[Key]) => void;
+    /**
+     * Returns a destructured version of this Entity, where child
+     * Entities are accessible at their respective keys.
+     */
+    getAll: () => KeyValue;
+    delete: (key: any) => void;
+    keys: () => string[];
+    entries: () => [string, Exclude<KeyValue[keyof KeyValue], undefined>][];
+    values: () => Exclude<KeyValue[keyof KeyValue], undefined>[];
+    update: (data: any, { merge, replaceSubObjects, }?: {
+        replaceSubObjects?: boolean | undefined;
+        merge?: boolean | undefined;
+    }) => void;
+    get length(): number;
+    push: (value: ListItemInit<Init>) => void;
+    insert: (index: number, value: ListItemInit<Init>) => void;
+    move: (from: number, to: number) => void;
+    moveItem: (item: ListItemValue<KeyValue>, to: number) => void;
+    add: (value: ListItemValue<KeyValue>) => void;
+    removeAll: (item: ListItemValue<KeyValue>) => void;
+    removeFirst: (item: ListItemValue<KeyValue>) => void;
+    removeLast: (item: ListItemValue<KeyValue>) => void;
+    [Symbol.iterator](): {
+        next: () => {
+            readonly value: ListItemValue<KeyValue>;
+            readonly done: false;
+        } | {
+            readonly value: undefined;
+            readonly done: true;
+        };
+    };
+    map: <U>(callback: (value: ListItemValue<KeyValue>, index: number) => U) => U[];
+    filter: (callback: (value: ListItemValue<KeyValue>, index: number) => boolean) => ListItemValue<KeyValue>[];
+    has: (value: ListItemValue<KeyValue>) => boolean;
+    forEach: (callback: (value: ListItemValue<KeyValue>, index: number) => void) => void;
+    some: (predicate: (value: ListItemValue<KeyValue>) => boolean) => boolean;
+    every: (predicate: (value: ListItemValue<KeyValue>) => boolean) => boolean;
+    find: (predicate: (value: ListItemValue<KeyValue>) => boolean) => ListItemValue<KeyValue> | undefined;
+    includes: (value: ListItemValue<KeyValue>) => boolean;
+    __getViewData__: (oid: ObjectIdentifier, type: 'confirmed' | 'pending') => EntityMetadataView;
+    __getFamilyOids__: () => string[];
+}

package/dist/esm/entities/Entity.test.d.ts

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

package/dist/esm/entities/EntityCache.d.ts

@@ -0,0 +1,15 @@
+import { Entity, EntityInit } from './Entity.js';
+import { EntityFile } from '../files/EntityFile.js';
+import { ObjectIdentifier } from '@verdant-web/common';
+export declare class EntityCache {
+    private cache;
+    constructor({ initial }?: {
+        initial?: Entity[];
+    });
+    get: (init: EntityInit) => Entity;
+    has: (oid: ObjectIdentifier) => boolean;
+    getFile: (id: string, options: {
+        downloadRemote: boolean;
+    }) => EntityFile;
+    getCached: (oid: string) => Entity<any, any, any> | EntityFile | undefined;
+}