shelving 1.105.0 → 1.106.0

package/change/Change.d.ts

@@ -0,0 +1,83 @@
+import type { AsyncProvider, Provider } from "../provider/Provider.js";
+import type { ImmutableArray } from "../util/array.js";
+import type { Data } from "../util/data.js";
+import type { ItemQuery } from "../util/item.js";
+import type { Updates } from "../util/update.js";
+import { type Optional } from "../util/optional.js";
+/** A change to a database. */
+export interface Change {
+    readonly action: string;
+}
+/** A change to a database collection. */
+export interface CollectionChange<T extends Data> extends Change {
+    readonly collection: string;
+    readonly id?: string | never;
+    readonly query?: ItemQuery<T> | never;
+}
+/** Add an item to a database collection. */
+export interface AddItemChange<T extends Data> extends CollectionChange<T> {
+    readonly action: "add";
+    readonly id?: never;
+    readonly query?: never;
+    readonly data: T;
+}
+/** Change an item in a database collection. */
+export interface ItemChange<T extends Data> extends CollectionChange<T> {
+    readonly id: string;
+    readonly query?: never;
+}
+/** Set an item in a database collection. */
+export interface SetItemChange<T extends Data> extends ItemChange<T> {
+    readonly action: "set";
+    readonly data: T;
+}
+/** Update an item in a database collection. */
+export interface UpdateItemChange<T extends Data> extends ItemChange<T> {
+    readonly action: "update";
+    readonly updates: Updates<T>;
+}
+/** Delete an item in a database collection. */
+export interface DeleteItemChange<T extends Data> extends ItemChange<T> {
+    readonly action: "delete";
+}
+/** Change multiple items in a database collection. */
+export interface QueryChange<T extends Data> extends CollectionChange<T> {
+    readonly query: ItemQuery<T>;
+    readonly id?: never;
+}
+/** Set multiple items in a database collection. */
+export interface SetQueryChange<T extends Data> extends QueryChange<T> {
+    readonly action: "set";
+    readonly data: T;
+}
+/** Update multiple items in a database collection. */
+export interface UpdateQueryChange<T extends Data> extends QueryChange<T> {
+    readonly action: "update";
+    readonly updates: Updates<T>;
+}
+/** Delete multiple items in a database collection. */
+export interface DeleteQueryChange<T extends Data> extends QueryChange<T> {
+    readonly action: "delete";
+}
+/** Write an item in a database collection. */
+export type WriteItemChange<T extends Data> = SetItemChange<T> | UpdateItemChange<T> | DeleteItemChange<T>;
+/** Write multiple item in a database collection. */
+export type WriteQueryChange<T extends Data> = SetQueryChange<T> | UpdateQueryChange<T> | DeleteQueryChange<T>;
+/** Write an item or multiple items in a database collection. */
+export type WriteChange<T extends Data> = AddItemChange<T> | WriteItemChange<T> | WriteQueryChange<T>;
+/** Write a set of changes to a synchronous provider. */
+export declare function writeProviderChanges<T extends Data>(provider: Provider, ...changes: Optional<WriteChange<T>>[]): ImmutableArray<WriteChange<T>>;
+/**
+ * Write a single change to a synchronous provider.
+ * @param change Change that should be written.
+ * @return Change that was written.
+ */
+export declare function writeProviderChange<T extends Data>(provider: Provider, change: WriteChange<T>): WriteChange<T>;
+/** Write a set of changes to an asynchronous provider. */
+export declare function writeAsyncProviderChanges<T extends Data>(provider: AsyncProvider, ...changes: Optional<WriteChange<T>>[]): Promise<ImmutableArray<WriteChange<T>>>;
+/**
+ * Write a single change to an asynchronous provider.
+ * @param change Change that should be written.
+ * @return Change that was written.
+ */
+export declare function writeAsyncProviderChange<T extends Data>(provider: AsyncProvider, change: WriteChange<T>): Promise<WriteChange<T>>;

package/change/Change.js

@@ -0,0 +1,67 @@
+import { notOptional } from "../util/optional.js";
+/** Write a set of changes to a synchronous provider. */
+export function writeProviderChanges(provider, ...changes) {
+    return changes.filter(notOptional).map(change => writeProviderChange(provider, change));
+}
+/**
+ * Write a single change to a synchronous provider.
+ * @param change Change that should be written.
+ * @return Change that was written.
+ */
+export function writeProviderChange(provider, change) {
+    const { action, collection, id, query } = change;
+    if (action === "add") {
+        // `add` change returns a `set` change so it includes the ID to reflect the change that was written.
+        return { action: "set", collection, id: provider.addItem(collection, change.data), data: change.data };
+    }
+    else if (id) {
+        if (action === "set")
+            provider.setItem(collection, id, change.data);
+        else if (action === "update")
+            provider.updateItem(collection, id, change.updates);
+        else if (action === "delete")
+            provider.deleteItem(collection, id);
+    }
+    else if (query) {
+        if (action === "set")
+            provider.setQuery(collection, query, change.data);
+        else if (action === "update")
+            provider.updateQuery(collection, query, change.updates);
+        else if (action === "delete")
+            provider.deleteQuery(collection, query);
+    }
+    return change;
+}
+/** Write a set of changes to an asynchronous provider. */
+export function writeAsyncProviderChanges(provider, ...changes) {
+    return Promise.all(changes.filter(notOptional).map(change => writeAsyncProviderChange(provider, change)));
+}
+/**
+ * Write a single change to an asynchronous provider.
+ * @param change Change that should be written.
+ * @return Change that was written.
+ */
+export async function writeAsyncProviderChange(provider, change) {
+    const { collection, action, id, query } = change;
+    if (action === "add") {
+        // `add` change returns a `set` change so it includes the ID to reflect the change that was written.
+        return { action: "set", collection, id: await provider.addItem(collection, change.data), data: change.data };
+    }
+    else if (id) {
+        if (action === "set")
+            await provider.setItem(collection, id, change.data);
+        else if (action === "update")
+            await provider.updateItem(collection, id, change.updates);
+        else if (action === "delete")
+            await provider.deleteItem(collection, id);
+    }
+    else if (query) {
+        if (action === "set")
+            await provider.setQuery(collection, query, change.data);
+        else if (action === "update")
+            await provider.updateQuery(collection, query, change.updates);
+        else if (action === "delete")
+            await provider.deleteQuery(collection, query);
+    }
+    return change;
+}

package/change/index.d.ts

@@ -0,0 +1 @@
+export * from "./Change.js";

package/change/index.js

@@ -0,0 +1 @@
+export * from "./Change.js";

package/db/CollectionReference.d.ts

@@ -1,13 +1,13 @@
-import type { AddChange, DeleteChange, SetChange, UpdateChange } from "./Change.js";
-import type { ItemArray, ItemData, ItemQuery, ItemValue } from "./ItemReference.js";
-import type { AsyncProvider, Provider } from "../provider/Provider.js";
+import type { AddItemChange, DeleteItemChange, DeleteQueryChange, SetItemChange, SetQueryChange, UpdateItemChange, UpdateQueryChange } from "../change/Change.js";
+import type { AbstractProvider, AsyncProvider, Provider } from "../provider/Provider.js";
 import type { Data } from "../util/data.js";
+import type { ItemArray, ItemData, ItemQuery, ItemValue } from "../util/item.js";
 import type { Updates } from "../util/update.js";
 import { AsyncItemReference, ItemReference } from "./ItemReference.js";
 import { AsyncQueryReference, QueryReference } from "./QueryReference.js";
 /** Reference to a collection in a synchronous or asynchronous provider. */
 declare abstract class AbstractCollectionReference<T extends Data = Data> {
-    abstract readonly provider: Provider | AsyncProvider;
+    abstract readonly provider: AbstractProvider;
     readonly collection: string;
     constructor(collection: string);
     /**
@@ -15,16 +15,16 @@ declare abstract class AbstractCollectionReference<T extends Data = Data> {
      * @return Array of entities.
      */
     abstract items: ItemArray<T> | PromiseLike<ItemArray<T>>;
-    /**
-     * Count the number of results of this set of items.
-     * @return Number of items matching the query (possibly promised).
-     */
-    abstract count: number | PromiseLike<number>;
     /**
      * Does at least one item exist for this query?
      * @return `true` if a item exists or `false` otherwise (possibly promised).
      */
     abstract exists: boolean | PromiseLike<boolean>;
+    /**
+     * Count the number of results of this set of items.
+     * @return Number of items matching the query (possibly promised).
+     */
+    abstract count: number | PromiseLike<number>;
     /**
      * Get the first item matched by this query or `null` if this query has no results.
      * @throws RequiredError if there were no results for this query.
@@ -44,24 +44,38 @@ declare abstract class AbstractCollectionReference<T extends Data = Data> {
     abstract query(query?: ItemQuery<T>): QueryReference<T> | AsyncQueryReference<T>;
     /** Create a query on this item's collection. */
     abstract item(id: string): ItemReference<T> | AsyncItemReference<T>;
-    /** Get an item from this collection. */
-    abstract get(id: string): ItemValue<T> | Promise<ItemValue<T>>;
-    /** Add an item to this collection. */
-    abstract add(data: T): string | Promise<string>;
-    /** Set a document in this collection. */
-    abstract set(id: string, data: T): void | Promise<void>;
-    /** Update a document in this collection. */
-    abstract update(id: string, updates: Updates<T>): void | Promise<void>;
-    /** Delete a document in this collection. */
-    abstract delete(id: string): void | Promise<void>;
-    /** Get an add change for this collection. */
-    getAdd(data: T): AddChange<T>;
-    /** Get a set change for this collection. */
-    getSet(id: string, data: T): SetChange<T>;
-    /** Get an update change for this collection. */
-    getUpdate(id: string, updates: Updates<T>): UpdateChange<T>;
-    /** Get a delete change for this collection. */
-    getDelete(id: string): DeleteChange;
+    /** Get an add change for an item in a database collection. */
+    getItemAdd(data: T): AddItemChange<T>;
+    /** Get a set change for an item in a database collection. */
+    getItemSet(id: string, data: T): SetItemChange<T>;
+    /** Get an update change for an item in a database collection. */
+    getItemUpdate(id: string, updates: Updates<T>): UpdateItemChange<T>;
+    /** Get a delete change for an item in a database collection. */
+    getItemDelete(id: string): DeleteItemChange<T>;
+    /** Get a set change for multiple items in a database collection. */
+    getQuerySet(query: ItemQuery<T>, data: T): SetQueryChange<T>;
+    /** Get an update change for multiple items in a database collection. */
+    getQueryUpdate(query: ItemQuery<T>, updates: Updates<T>): UpdateQueryChange<T>;
+    /** Get a delete change for multiple items in a database collection. */
+    getQueryDelete(query: ItemQuery<T>): DeleteQueryChange<T>;
+    /** Add an item to a database collection. */
+    abstract addItem(data: T): string | Promise<string>;
+    /** Get an item from a database collection. */
+    abstract getItem(id: string): ItemValue<T> | Promise<ItemValue<T>>;
+    /** Set an item to a database collection. */
+    abstract setItem(id: string, data: T): void | Promise<void>;
+    /** Update an item to a database collection. */
+    abstract updateItem(id: string, updates: Updates<T>): void | Promise<void>;
+    /** Delete an item to a database collection. */
+    abstract deleteItem(id: string): void | Promise<void>;
+    /** Get multiple items from a database collection. */
+    abstract getQuery(query: ItemQuery<T>): ItemArray<T> | Promise<ItemArray<T>>;
+    /** Set multiple items in a database collection. */
+    abstract setQuery(query: ItemQuery<T>, data: T): number | Promise<number>;
+    /** Update multiple items in a database collection. */
+    abstract updateQuery(query: ItemQuery<T>, updates: Updates<T>): number | Promise<number>;
+    /** Delete multiple items in a database collection. */
+    abstract deleteQuery(query: ItemQuery<T>): number | Promise<number>;
     toString(): string;
 }
 /** Reference to a collection in a synchronous provider. */
@@ -69,35 +83,43 @@ export declare class CollectionReference<T extends Data = Data> extends Abstract
     readonly provider: Provider;
     constructor(provider: Provider, collection: string);
     get items(): ItemArray<T>;
-    get count(): number;
     get exists(): boolean;
+    get count(): number;
     get first(): ItemValue<T>;
     get last(): ItemValue<T>;
     get data(): ItemData<T>;
     query(constraints?: ItemQuery<T>): QueryReference<T>;
     item(id: string): ItemReference<T>;
-    get(id: string): ItemValue<T>;
-    add(data: T): string;
-    set(id: string, data: T): void;
-    update(id: string, updates: Updates<T>): void;
-    delete(id: string): void;
+    addItem(data: T): string;
+    getItem(id: string): ItemValue<T>;
+    setItem(id: string, data: T): void;
+    updateItem(id: string, updates: Updates<T>): void;
+    deleteItem(id: string): void;
+    getQuery(query: ItemQuery<T>): ItemArray<T>;
+    setQuery(query: ItemQuery<T>, data: T): number;
+    updateQuery(query: ItemQuery<T>, updates: Updates<T>): number;
+    deleteQuery(query: ItemQuery<T>): number;
 }
 /** Reference to a collection in an asynchronous provider. */
 export declare class AsyncCollectionReference<T extends Data = Data> extends AbstractCollectionReference<T> {
     readonly provider: AsyncProvider;
     constructor(provider: AsyncProvider, collection: string);
     get items(): Promise<ItemArray<T>>;
-    get count(): Promise<number>;
     get exists(): Promise<boolean>;
+    get count(): Promise<number>;
     get first(): Promise<ItemValue<T>>;
     get last(): Promise<ItemValue<T>>;
     get data(): Promise<ItemData<T>>;
     query(query?: ItemQuery<T>): AsyncQueryReference<T>;
     item(id: string): AsyncItemReference<T>;
-    get(id: string): Promise<ItemValue<T>>;
-    add(data: T): Promise<string>;
-    set(id: string, data: T): Promise<void>;
-    update(id: string, updates: Updates<T>): Promise<void>;
-    delete(id: string): Promise<void>;
+    addItem(data: T): Promise<string>;
+    getItem(id: string): Promise<ItemValue<T>>;
+    setItem(id: string, data: T): Promise<void>;
+    updateItem(id: string, updates: Updates<T>): Promise<void>;
+    deleteItem(id: string): Promise<void>;
+    getQuery(query: ItemQuery<T>): Promise<ItemArray<T>>;
+    setQuery(query: ItemQuery<T>, data: T): Promise<number>;
+    updateQuery(query: ItemQuery<T>, updates: Updates<T>): Promise<number>;
+    deleteQuery(query: ItemQuery<T>): Promise<number>;
 }
 export {};

package/db/CollectionReference.js

@@ -1,28 +1,42 @@
-import { countArray, getFirstItem, getOptionalFirstItem, getOptionalLastItem, isArrayLength } from "../util/array.js";
+import { countArray, getFirstItem, getOptionalFirstItem, getOptionalLastItem } from "../util/array.js";
 import { AsyncItemReference, ItemReference } from "./ItemReference.js";
 import { AsyncQueryReference, QueryReference } from "./QueryReference.js";
+const NO_QUERY = {}; // eslint-disable-line @typescript-eslint/no-explicit-any
+const SINGLE_QUERY = { $limit: 1 }; // eslint-disable-line @typescript-eslint/no-explicit-any
 /** Reference to a collection in a synchronous or asynchronous provider. */
 class AbstractCollectionReference {
     collection;
     constructor(collection) {
         this.collection = collection;
     }
-    /** Get an add change for this collection. */
-    getAdd(data) {
+    /** Get an add change for an item in a database collection. */
+    getItemAdd(data) {
         return { action: "add", collection: this.collection, data };
     }
-    /** Get a set change for this collection. */
-    getSet(id, data) {
+    /** Get a set change for an item in a database collection. */
+    getItemSet(id, data) {
         return { action: "set", collection: this.collection, id, data };
     }
-    /** Get an update change for this collection. */
-    getUpdate(id, updates) {
+    /** Get an update change for an item in a database collection. */
+    getItemUpdate(id, updates) {
         return { action: "update", collection: this.collection, id, updates };
     }
-    /** Get a delete change for this collection. */
-    getDelete(id) {
+    /** Get a delete change for an item in a database collection. */
+    getItemDelete(id) {
         return { action: "delete", collection: this.collection, id };
     }
+    /** Get a set change for multiple items in a database collection. */
+    getQuerySet(query, data) {
+        return { action: "set", collection: this.collection, query, data };
+    }
+    /** Get an update change for multiple items in a database collection. */
+    getQueryUpdate(query, updates) {
+        return { action: "update", collection: this.collection, query, updates };
+    }
+    /** Get a delete change for multiple items in a database collection. */
+    getQueryDelete(query) {
+        return { action: "delete", collection: this.collection, query };
+    }
     // Implement toString()
     toString() {
         return this.collection;
@@ -36,22 +50,22 @@ export class CollectionReference extends AbstractCollectionReference {
         this.provider = provider;
     }
     get items() {
-        return _getItemArray(this);
+        return this.provider.getQuery(this.collection, NO_QUERY);
+    }
+    get exists() {
+        return !!this.first;
     }
     get count() {
         return this.items.length;
     }
-    get exists() {
-        return !!_getSingleItemArray(this).length;
-    }
     get first() {
-        return getOptionalFirstItem(_getSingleItemArray(this));
+        return getOptionalFirstItem(this.provider.getQuery(this.collection, SINGLE_QUERY));
     }
     get last() {
         return getOptionalLastItem(this.items);
     }
     get data() {
-        return getFirstItem(_getSingleItemArray(this));
+        return getFirstItem(this.provider.getQuery(this.collection, SINGLE_QUERY));
     }
     query(constraints) {
         return new QueryReference(this.provider, this.collection, constraints);
@@ -59,21 +73,33 @@ export class CollectionReference extends AbstractCollectionReference {
     item(id) {
         return new ItemReference(this.provider, this.collection, id);
     }
-    get(id) {
-        return this.provider.getItem(this.collection, id);
-    }
-    add(data) {
+    addItem(data) {
         return this.provider.addItem(this.collection, data);
     }
-    set(id, data) {
+    getItem(id) {
+        return this.provider.getItem(this.collection, id);
+    }
+    setItem(id, data) {
         return this.provider.setItem(this.collection, id, data);
     }
-    update(id, updates) {
+    updateItem(id, updates) {
         return this.provider.updateItem(this.collection, id, updates);
     }
-    delete(id) {
+    deleteItem(id) {
         return this.provider.deleteItem(this.collection, id);
     }
+    getQuery(query) {
+        return this.provider.getQuery(this.collection, query);
+    }
+    setQuery(query, data) {
+        return this.provider.setQuery(this.collection, query, data);
+    }
+    updateQuery(query, updates) {
+        return this.provider.updateQuery(this.collection, query, updates);
+    }
+    deleteQuery(query) {
+        return this.provider.deleteQuery(this.collection, query);
+    }
 }
 /** Reference to a collection in an asynchronous provider. */
 export class AsyncCollectionReference extends AbstractCollectionReference {
@@ -83,22 +109,22 @@ export class AsyncCollectionReference extends AbstractCollectionReference {
         this.provider = provider;
     }
     get items() {
-        return _getItemArray(this);
+        return this.provider.getQuery(this.collection, NO_QUERY);
+    }
+    get exists() {
+        return this.first.then(Boolean);
     }
     get count() {
         return this.items.then(countArray);
     }
-    get exists() {
-        return _getSingleItemArray(this).then(isArrayLength);
-    }
     get first() {
-        return _getSingleItemArray(this).then(getOptionalFirstItem);
+        return this.provider.getQuery(this.collection, SINGLE_QUERY).then(getOptionalFirstItem);
     }
     get last() {
         return this.items.then(getOptionalLastItem);
     }
     get data() {
-        return _getSingleItemArray(this).then(getFirstItem);
+        return this.provider.getQuery(this.collection, SINGLE_QUERY).then(getFirstItem);
     }
     query(query) {
         return new AsyncQueryReference(this.provider, this.collection, query);
@@ -106,25 +132,31 @@ export class AsyncCollectionReference extends AbstractCollectionReference {
     item(id) {
         return new AsyncItemReference(this.provider, this.collection, id);
     }
-    get(id) {
-        return this.provider.getItem(this.collection, id);
-    }
-    add(data) {
+    addItem(data) {
         return this.provider.addItem(this.collection, data);
     }
-    set(id, data) {
+    getItem(id) {
+        return this.provider.getItem(this.collection, id);
+    }
+    setItem(id, data) {
         return this.provider.setItem(this.collection, id, data);
     }
-    update(id, updates) {
+    updateItem(id, updates) {
         return this.provider.updateItem(this.collection, id, updates);
     }
-    delete(id) {
+    deleteItem(id) {
         return this.provider.deleteItem(this.collection, id);
     }
-}
-function _getItemArray({ provider, collection }) {
-    return provider.getQuery(collection, {});
-}
-function _getSingleItemArray({ provider, collection }) {
-    return provider.getQuery(collection, { $limit: 1 });
+    getQuery(query) {
+        return this.provider.getQuery(this.collection, query);
+    }
+    setQuery(query, data) {
+        return this.provider.setQuery(this.collection, query, data);
+    }
+    updateQuery(query, updates) {
+        return this.provider.updateQuery(this.collection, query, updates);
+    }
+    deleteQuery(query) {
+        return this.provider.deleteQuery(this.collection, query);
+    }
 }

package/db/Database.d.ts

@@ -1,41 +1,58 @@
-import type { AddChange, DeleteChange, ItemChanges, SetChange, UpdateChange, WriteChange } from "./Change.js";
-import type { ItemQuery, ItemValue } from "./ItemReference.js";
-import type { AsyncProvider, Provider } from "../provider/Provider.js";
-import type { Data, DataKey, Datas } from "../util/data.js";
+import type { AddItemChange, DeleteItemChange, DeleteQueryChange, SetItemChange, SetQueryChange, UpdateItemChange, UpdateQueryChange, WriteChange } from "../change/Change.js";
+import type { AbstractProvider, AsyncProvider, Provider } from "../provider/Provider.js";
+import type { ImmutableArray } from "../util/array.js";
+import type { DataKey, DataValue, Datas } from "../util/data.js";
+import type { ItemArray, ItemQuery, ItemValue } from "../util/item.js";
 import type { Optional } from "../util/optional.js";
 import type { Updates } from "../util/update.js";
 import { AsyncCollectionReference, CollectionReference } from "./CollectionReference.js";
 import { AsyncItemReference, ItemReference } from "./ItemReference.js";
 import { AsyncQueryReference, QueryReference } from "./QueryReference.js";
 /** Database with a synchronous or asynchronous provider. */
-declare abstract class AbstractDatabase<T extends Datas> {
-    abstract readonly provider: Provider | AsyncProvider;
+export declare abstract class AbstractDatabase<T extends Datas> {
+    abstract readonly provider: AbstractProvider;
     /** Create a query on a collection in this database. */
     abstract collection<K extends DataKey<T>>(collection: K): CollectionReference<T[K]> | AsyncCollectionReference<T[K]>;
     /** Create a query on a collection in this database. */
     abstract query<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): QueryReference<T[K]> | AsyncQueryReference<T[K]>;
     /** Reference an item in a collection in this database. */
     abstract item<K extends DataKey<T>>(collection: K, id: string): ItemReference<T[K]> | AsyncItemReference<T[K]>;
-    /** Run a set of changes in this database. */
-    abstract change(...changes: Optional<WriteChange<Data>>[]): ItemChanges | Promise<ItemChanges>;
-    /** Get a document from a collection in this database. */
-    abstract get<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]> | Promise<ItemValue<T[K]>>;
-    /** Add a document to a collection in this database. */
-    abstract add<K extends DataKey<T>>(collection: K, data: T[K]): string | Promise<string>;
-    /** Set a document in a collection in this database. */
-    abstract set<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void | Promise<void>;
-    /** Update a document in a collection in this database. */
-    abstract update<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void | Promise<void>;
-    /** Delete a document from a collection in this database. */
-    abstract delete<K extends DataKey<T>>(collection: K, id: string): void | Promise<void>;
-    /** Get an add change for a collection in this database. */
-    getAdd<K extends DataKey<T>>(collection: K, data: T[K]): AddChange<T[K]>;
-    /** Get a set change for a collection in this database. */
-    getSet<K extends DataKey<T>>(collection: K, id: string, data: T[K]): SetChange<T[K]>;
-    /** Get an update change for a collection in this database. */
-    getUpdate<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): UpdateChange<T[K]>;
-    /** Get a delete change for a collection in this database. */
-    getDelete<K extends DataKey<T>>(collection: K, id: string): DeleteChange;
+    /** Get an add change for an item in a database collection. */
+    getItemAdd<K extends DataKey<T>>(collection: K, data: T[K]): AddItemChange<T[K]>;
+    /** Get a set change for an item in a database collection. */
+    getItemSet<K extends DataKey<T>>(collection: K, id: string, data: T[K]): SetItemChange<T[K]>;
+    /** Get an update change for an item in a database collection. */
+    getItemUpdate<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): UpdateItemChange<T[K]>;
+    /** Get a delete change for an item in a database collection. */
+    getItemDelete<K extends DataKey<T>>(collection: K, id: string): DeleteItemChange<T[K]>;
+    /** Get a set change for multiple items in a database collection. */
+    getQuerySet<K extends DataKey<T>>(collection: K, query: ItemQuery<T>, data: T[K]): SetQueryChange<T[K]>;
+    /** Get an update change for multiple items in a database collection. */
+    getQueryUpdate<K extends DataKey<T>>(collection: K, query: ItemQuery<T>, updates: Updates<T[K]>): UpdateQueryChange<T[K]>;
+    /** Get a delete change for multiple items in a database collection. */
+    getQueryDelete<K extends DataKey<T>>(collection: K, query: ItemQuery<T>): DeleteQueryChange<T>;
+    /** Add an item to a database collection. */
+    abstract addItem<K extends DataKey<T>>(collection: K, data: T[K]): string | Promise<string>;
+    /** Get an item from a database collection. */
+    abstract getItem<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]> | Promise<ItemValue<T[K]>>;
+    /** Set an item to a database collection. */
+    abstract setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void | Promise<void>;
+    /** Update an item to a database collection. */
+    abstract updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void | Promise<void>;
+    /** Delete an item to a database collection. */
+    abstract deleteItem<K extends DataKey<T>>(collection: K, id: string): void | Promise<void>;
+    /** Get multiple items from a database collection. */
+    abstract getQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): ItemArray<T[K]> | Promise<ItemArray<T[K]>>;
+    /** Set multiple items in a database collection. */
+    abstract setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): number | Promise<number>;
+    /** Update multiple items in a database collection. */
+    abstract updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates<T[K]>): number | Promise<number>;
+    /** Delete multiple items in a database collection. */
+    abstract deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): number | Promise<number>;
+    /** Write a single change to this database. */
+    abstract writeChange<K extends DataKey<T>>(change: WriteChange<T[K]>): WriteChange<T[K]> | PromiseLike<WriteChange<T[K]>>;
+    /** Write a set of changes to this database. */
+    abstract writeChanges(...changes: Optional<WriteChange<DataValue<T>>>[]): ImmutableArray<WriteChange<DataValue<T>>> | PromiseLike<ImmutableArray<WriteChange<DataValue<T>>>>;
 }
 /** Database with a synchronous provider. */
 export declare class Database<T extends Datas = Datas> extends AbstractDatabase<T> {
@@ -44,12 +61,17 @@ export declare class Database<T extends Datas = Datas> extends AbstractDatabase<
     collection<K extends DataKey<T>>(collection: K): CollectionReference<T[K]>;
     query<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): QueryReference<T[K]>;
     item<K extends DataKey<T>>(collection: K, id: string): ItemReference<T[K]>;
-    change(...changes: Optional<WriteChange<Data>>[]): ItemChanges;
-    get<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
-    add<K extends DataKey<T>>(collection: K, data: T[K]): string;
-    set<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
-    update<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
-    delete<K extends DataKey<T>>(collection: K, id: string): void;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
+    getItem<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
+    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
+    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
+    deleteItem<K extends DataKey<T>>(collection: K, id: string): void;
+    getQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): ItemArray<T[K]>;
+    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): number;
+    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates<T[K]>): number;
+    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): number;
+    writeChange<K extends DataKey<T>>(change: WriteChange<T[K]>): WriteChange<T[K]>;
+    writeChanges(...changes: Optional<WriteChange<DataValue<T>>>[]): ImmutableArray<WriteChange<DataValue<T>>>;
 }
 /** Database with a synchronous provider. */
 export declare class AsyncDatabase<T extends Datas = Datas> extends AbstractDatabase<T> {
@@ -58,11 +80,15 @@ export declare class AsyncDatabase<T extends Datas = Datas> extends AbstractData
     collection<K extends DataKey<T>>(collection: K): AsyncCollectionReference<T[K]>;
     query<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): AsyncQueryReference<T[K]>;
     item<K extends DataKey<T>>(collection: K, id: string): AsyncItemReference<T[K]>;
-    change(...changes: Optional<WriteChange<Data>>[]): Promise<ItemChanges>;
-    get<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    add<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
-    set<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    update<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    delete<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
+    getItem<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
+    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
+    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
+    deleteItem<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
+    getQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<ItemArray<T[K]>>;
+    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): Promise<number>;
+    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates<T[K]>): Promise<number>;
+    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<number>;
+    writeChange<K extends DataKey<T>>(change: WriteChange<T[K]>): PromiseLike<WriteChange<T[K]>>;
+    writeChanges(...changes: Optional<WriteChange<DataValue<T>>>[]): PromiseLike<ImmutableArray<WriteChange<DataValue<T>>>>;
 }
-export {};