shelving 1.39.0 → 1.40.0

package/db/Database.d.ts

@@ -15,22 +15,22 @@ export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
     readonly provider: Provider;
     constructor(validators: V, provider: Provider);
     /** Create a query on a collection in this model. */
-    query<K extends Key<V>>(collection: K, filters?: Filters<ValidatorType<V[K]>>, sorts?: Sorts<ValidatorType<V[K]>>, limit?: number | null): DataQuery<ValidatorType<V[K]>>;
+    query<K extends Key<V>>(collection: K, filters?: Filters<ValidatorType<V[K]>>, sorts?: Sorts<ValidatorType<V[K]>>, limit?: number | null): DatabaseQuery<ValidatorType<V[K]>>;
     /** Reference a document in a collection in this model. */
-    doc<K extends Key<V>>(collection: K, id: string): DataDocument<ValidatorType<V[K]>>;
+    doc<K extends Key<V>>(collection: K, id: string): DatabaseDocument<ValidatorType<V[K]>>;
     /** Create a writer for this database from a set of separate writes. */
     writer(...writes: Nullish<Write>[]): Write;
     /** Perform one or more writes on this database and return the `Writes` instance representing the combined changes. */
     write(...writes: Nullish<Write>[]): Promise<Write>;
 }
 /** A documents reference within a specific database. */
-export declare class DataQuery<T extends Data = Data> extends Query<T> implements Observable<Results<T>>, Validatable<Entries<T>>, Iterable<Entry<T>> {
+export declare class DatabaseQuery<T extends Data = Data> extends Query<T> implements Observable<Results<T>>, Validatable<Entries<T>>, Iterable<Entry<T>> {
     readonly provider: Provider;
     readonly validator: Validator<T>;
     readonly collection: string;
     constructor(provider: Provider, validator: Validator<T>, collection: string, filters?: Filters<T>, sorts?: Sorts<T>, limit?: number | null);
     /** Reference a document in this query's collection. */
-    doc(id: string): DataDocument<T>;
+    doc(id: string): DatabaseDocument<T>;
     /**
      * Create a new document with a random ID.
      * - Created document is guaranteed to have a unique ID.
@@ -107,18 +107,18 @@ export declare class DataQuery<T extends Data = Data> extends Query<T> implement
     toString(): string;
 }
 /** Get the data for a document from a result for that document. */
-export declare function getQueryData<T extends Data>(entries: Entries<T>, ref: DataQuery<T>): Entry<T>;
+export declare function getQueryData<T extends Data>(entries: Entries<T>, ref: DatabaseQuery<T>): Entry<T>;
 /** A document reference within a specific database. */
-export declare class DataDocument<T extends Data = Data> implements Observable<Result<T>>, Validatable<T> {
+export declare class DatabaseDocument<T extends Data = Data> implements Observable<Result<T>>, Validatable<T> {
     readonly provider: Provider;
     readonly validator: Validator<T>;
     readonly collection: string;
     readonly id: string;
     constructor(provider: Provider, validator: Validator<T>, collection: string, id: string);
     /** Create a query on this document's collection. */
-    query(filters?: Filters<T>, sorts?: Sorts<T>, limit?: number | null): DataQuery<T>;
+    query(filters?: Filters<T>, sorts?: Sorts<T>, limit?: number | null): DatabaseQuery<T>;
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
-    get optional(): DataQuery<T>;
+    get optional(): DatabaseQuery<T>;
     /**
      * Does this document exist?
      * @return `true` if a document exists or `false` otherwise (possibly promised).
@@ -154,7 +154,7 @@ export declare class DataDocument<T extends Data = Data> implements Observable<R
     /** Represent a write that sets the complete data of this document in a database. */
     setter(data: T): DocumentSet<T>;
     /** Represent a write that updates this document in a database. */
-    updater(updates: Update<T> | PropUpdates<T>): DocumentUpdate<T>;
+    updater(updates: PropUpdates<T>): DocumentUpdate<T>;
     /** Represent a write that deletes this document in a database. */
     deleter(): DocumentDelete<T>;
     /** Validate data for this query reference. */
@@ -162,4 +162,4 @@ export declare class DataDocument<T extends Data = Data> implements Observable<R
     toString(): string;
 }
 /** Get the data for a document from a result for that document. */
-export declare function getDocumentData<T extends Data>(result: Result<T>, ref: DataDocument<T>): T;
+export declare function getDocumentData<T extends Data>(result: Result<T>, ref: DatabaseDocument<T>): T;

package/db/Database.js

@@ -19,11 +19,11 @@ export class Database {
     }
     /** Create a query on a collection in this model. */
     query(collection, filters, sorts, limit) {
-        return new DataQuery(this.provider, this.validators[collection], collection, filters, sorts, limit);
+        return new DatabaseQuery(this.provider, this.validators[collection], collection, filters, sorts, limit);
     }
     /** Reference a document in a collection in this model. */
     doc(collection, id) {
-        return new DataDocument(this.provider, this.validators[collection], collection, id);
+        return new DatabaseDocument(this.provider, this.validators[collection], collection, id);
     }
     /** Create a writer for this database from a set of separate writes. */
     writer(...writes) {
@@ -37,7 +37,7 @@ export class Database {
     }
 }
 /** A documents reference within a specific database. */
-export class DataQuery extends Query {
+export class DatabaseQuery extends Query {
     constructor(provider, validator, collection, filters, sorts, limit) {
         super(filters, sorts, limit);
         this.provider = provider;
@@ -46,7 +46,7 @@ export class DataQuery extends Query {
     }
     /** Reference a document in this query's collection. */
     doc(id) {
-        return new DataDocument(this.provider, this.validator, this.collection, id);
+        return new DatabaseDocument(this.provider, this.validator, this.collection, id);
     }
     /**
      * Create a new document with a random ID.
@@ -174,7 +174,7 @@ export function getQueryData(entries, ref) {
     throw new QueryRequiredError(ref);
 }
 /** A document reference within a specific database. */
-export class DataDocument {
+export class DatabaseDocument {
     constructor(provider, validator, collection, id) {
         this.provider = provider;
         this.validator = validator;
@@ -183,11 +183,11 @@ export class DataDocument {
     }
     /** Create a query on this document's collection. */
     query(filters, sorts, limit) {
-        return new DataQuery(this.provider, this.validator, this.collection, filters, sorts, limit);
+        return new DatabaseQuery(this.provider, this.validator, this.collection, filters, sorts, limit);
     }
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
     get optional() {
-        return new DataQuery(this.provider, this.validator, this.collection, new Filters(new EqualFilter("id", this.id)));
+        return new DatabaseQuery(this.provider, this.validator, this.collection, new Filters(new EqualFilter("id", this.id)));
     }
     /**
      * Does this document exist?

package/db/Pagination.d.ts

@@ -1,6 +1,6 @@
 import { Results, Entry, Entries, Data } from "../util/index.js";
 import { State } from "../stream/index.js";
-import { DataQuery } from "./Database.js";
+import { DatabaseQuery } from "./Database.js";
 /**
  * State that wraps a `Documents` reference to enable pagination.
  * - If you pass in initial values, it will use that as the first page.
@@ -8,9 +8,9 @@ import { DataQuery } from "./Database.js";
  */
 export declare class Pagination<T extends Data> extends State<Results<T>> implements Iterable<Entry<T>> {
     protected _pending: boolean;
-    readonly ref: DataQuery<T>;
+    readonly ref: DatabaseQuery<T>;
     readonly limit: number;
-    constructor(ref: DataQuery<T>);
+    constructor(ref: DatabaseQuery<T>);
     /**
      * Load more results after the end.
      * - Promise that needs to be handled.

package/db/Write.d.ts

@@ -1,6 +1,6 @@
 import { PropUpdates, Update } from "../update/index.js";
-import { ImmutableArray, Data, Transformable } from "../util/index.js";
-import type { Database, DataDocument } from "./Database.js";
+import { ImmutableArray, Data, Transformable, Key, Nullish } from "../util/index.js";
+import type { Database, DatabaseDocument } from "./Database.js";
 /** Represent a write made to a database. */
 export declare abstract class Write implements Transformable<Database, void | PromiseLike<void>> {
     abstract transform(db: Database): void | PromiseLike<void>;
@@ -19,19 +19,23 @@ export declare class Writes extends Write {
 export declare abstract class DocumentWrite<T extends Data> extends Write {
     readonly collection: string;
     readonly id: string;
-    constructor({ collection, id }: DataDocument<T>);
+    constructor({ collection, id }: DatabaseDocument<T>);
 }
 /** Represent a set operation made to a single document in a database. */
 export declare class DocumentSet<T extends Data> extends DocumentWrite<T> {
     readonly data: T;
-    constructor(ref: DataDocument<T>, data: T);
+    constructor(ref: DatabaseDocument<T>, data: T);
     transform(db: Database): Promise<void>;
+    /** Set one of the props on this set operation to a different value. */
+    set<K extends Key<T>>(key: Nullish<K>, value: T[K]): this;
 }
 /** Represent an update operation made to a single document in a database. */
 export declare class DocumentUpdate<T extends Data> extends DocumentWrite<T> {
-    readonly updates: Update<T>;
-    constructor(ref: DataDocument<T>, updates: Update<T> | PropUpdates<T>);
+    readonly updates: PropUpdates<T>;
+    constructor(ref: DatabaseDocument<T>, updates: PropUpdates<T>);
     transform(db: Database): Promise<void>;
+    /** update one of the props on this set operation to a different value. */
+    update<K extends Key<T>>(key: Nullish<K>, value: T[K] | Update<T[K]>): this;
 }
 /** Represent a delete operation made to a single document in a database. */
 export declare class DocumentDelete<T extends Data> extends DocumentWrite<T> {

package/db/Write.js

@@ -1,5 +1,4 @@
-import { DataUpdate, Update } from "../update/index.js";
-import { transform } from "../util/index.js";
+import { transform, isNullish } from "../util/index.js";
 /** Represent a write made to a database. */
 export class Write {
 }
@@ -35,16 +34,28 @@ export class DocumentSet extends DocumentWrite {
     async transform(db) {
         await db.doc(this.collection, this.id).set(this.data);
     }
+    /** Set one of the props on this set operation to a different value. */
+    set(key, value) {
+        if (isNullish(key))
+            return this;
+        return { __proto__: Object.getPrototypeOf(this), ...this, data: { ...this.data, [key]: value } };
+    }
 }
 /** Represent an update operation made to a single document in a database. */
 export class DocumentUpdate extends DocumentWrite {
     constructor(ref, updates) {
         super(ref);
-        this.updates = updates instanceof Update ? updates : new DataUpdate(updates);
+        this.updates = updates;
     }
     async transform(db) {
         await db.doc(this.collection, this.id).update(this.updates);
     }
+    /** update one of the props on this set operation to a different value. */
+    update(key, value) {
+        if (isNullish(key))
+            return this;
+        return { __proto__: Object.getPrototypeOf(this), ...this, updates: { ...this.updates, [key]: value } };
+    }
 }
 /** Represent a delete operation made to a single document in a database. */
 export class DocumentDelete extends DocumentWrite {

package/db/errors.d.ts

@@ -1,24 +1,24 @@
 import type { Data } from "../util/index.js";
 import { RequiredError, ValidationError } from "../error/index.js";
 import type { Feedback } from "../feedback/index.js";
-import type { DataDocument, DataQuery } from "./Database.js";
+import type { DatabaseDocument, DatabaseQuery } from "./Database.js";
 /** Thrown if a document doesn't exist. */
 export declare class DocumentRequiredError<T extends Data> extends RequiredError {
-    ref: DataDocument<T>;
-    constructor(ref: DataDocument<T>);
+    ref: DatabaseDocument<T>;
+    constructor(ref: DatabaseDocument<T>);
 }
 /** Thrown if a query doesn't exist. */
 export declare class QueryRequiredError<T extends Data> extends RequiredError {
-    ref: DataQuery<T>;
-    constructor(ref: DataQuery<T>);
+    ref: DatabaseQuery<T>;
+    constructor(ref: DatabaseQuery<T>);
 }
 /** Thrown if a document can't validate. */
 export declare class DocumentValidationError<T extends Data> extends ValidationError {
-    ref: DataDocument<T>;
-    constructor(ref: DataDocument<T>, feedback: Feedback);
+    ref: DatabaseDocument<T>;
+    constructor(ref: DatabaseDocument<T>, feedback: Feedback);
 }
 /** Thrown if a query can't validate a set of results. */
 export declare class QueryValidationError<T extends Data> extends ValidationError {
-    ref: DataQuery<T>;
-    constructor(ref: DataQuery<T>, feedback: Feedback);
+    ref: DatabaseQuery<T>;
+    constructor(ref: DatabaseQuery<T>, feedback: Feedback);
 }

package/firestore/client/FirestoreClientProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Firestore } from "firebase/firestore";
-import { Entries, Provider, DataDocument, DataQuery, Result, Observer, Update, AsynchronousProvider, Data, Unsubscriber } from "../../index.js";
+import { Entries, Provider, DatabaseDocument, DatabaseQuery, Result, Observer, Update, AsynchronousProvider, Data, Unsubscriber } from "../../index.js";
 /**
  * Firestore client database provider.
  * - Works with the Firebase JS SDK.
@@ -9,15 +9,15 @@ import { Entries, Provider, DataDocument, DataQuery, Result, Observer, Update, A
 export declare class FirestoreClientProvider extends Provider implements AsynchronousProvider {
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
-    get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
-    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
-    add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
-    set<T extends Data>(ref: DataDocument<T>, data: T): Promise<void>;
-    update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): Promise<void>;
-    delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
-    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Entries<T>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T): Promise<number>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;
+    get<T extends Data>(ref: DatabaseDocument<T>): Promise<Result<T>>;
+    subscribe<T extends Data>(ref: DatabaseDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
+    add<T extends Data>(ref: DatabaseQuery<T>, data: T): Promise<string>;
+    set<T extends Data>(ref: DatabaseDocument<T>, data: T): Promise<void>;
+    update<T extends Data>(ref: DatabaseDocument<T>, updates: Update<T>): Promise<void>;
+    delete<T extends Data>(ref: DatabaseDocument<T>): Promise<void>;
+    getQuery<T extends Data>(ref: DatabaseQuery<T>): Promise<Entries<T>>;
+    subscribeQuery<T extends Data>(ref: DatabaseQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
+    setQuery<T extends Data>(ref: DatabaseQuery<T>, data: T): Promise<number>;
+    updateQuery<T extends Data>(ref: DatabaseQuery<T>, updates: Update<T>): Promise<number>;
+    deleteQuery<T extends Data>(ref: DatabaseQuery<T>): Promise<number>;
 }

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Firestore } from "firebase/firestore/lite";
-import { Provider, DataDocument, DataQuery, Result, Update, AsynchronousProvider, Data, Entries, Unsubscriber } from "../../index.js";
+import { Provider, DatabaseDocument, DatabaseQuery, Result, Update, AsynchronousProvider, Data, Entries, Unsubscriber } from "../../index.js";
 /**
  * Firestore Lite client database provider.
  * - Works with the Firebase JS SDK.
@@ -9,15 +9,15 @@ import { Provider, DataDocument, DataQuery, Result, Update, AsynchronousProvider
 export declare class FirestoreClientProvider extends Provider implements AsynchronousProvider {
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
-    get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
+    get<T extends Data>(ref: DatabaseDocument<T>): Promise<Result<T>>;
     subscribe(): Unsubscriber;
-    add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
-    set<T extends Data>(ref: DataDocument<T>, data: T): Promise<void>;
-    update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): Promise<void>;
-    delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
-    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Entries<T>>;
+    add<T extends Data>(ref: DatabaseQuery<T>, data: T): Promise<string>;
+    set<T extends Data>(ref: DatabaseDocument<T>, data: T): Promise<void>;
+    update<T extends Data>(ref: DatabaseDocument<T>, updates: Update<T>): Promise<void>;
+    delete<T extends Data>(ref: DatabaseDocument<T>): Promise<void>;
+    getQuery<T extends Data>(ref: DatabaseQuery<T>): Promise<Entries<T>>;
     subscribeQuery(): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T | Update<T> | undefined): Promise<number>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;
+    setQuery<T extends Data>(ref: DatabaseQuery<T>, data: T | Update<T> | undefined): Promise<number>;
+    updateQuery<T extends Data>(ref: DatabaseQuery<T>, updates: Update<T>): Promise<number>;
+    deleteQuery<T extends Data>(ref: DatabaseQuery<T>): Promise<number>;
 }

package/firestore/server/FirestoreServerProvider.d.ts

@@ -1,5 +1,5 @@
 import { Firestore } from "@google-cloud/firestore";
-import { Provider, DataDocument, DataQuery, Observer, Result, Update, Data, AsynchronousProvider, Entry, Entries, Unsubscriber } from "../../index.js";
+import { Provider, DatabaseDocument, DatabaseQuery, Observer, Result, Update, Data, AsynchronousProvider, Entry, Entries, Unsubscriber } from "../../index.js";
 /**
  * Firestore server database provider.
  * - Works with the Firebase Admin SDK for Node.JS
@@ -7,15 +7,15 @@ import { Provider, DataDocument, DataQuery, Observer, Result, Update, Data, Asyn
 export declare class FirestoreServerProvider extends Provider implements AsynchronousProvider {
     readonly firestore: Firestore;
     constructor(firestore?: Firestore);
-    get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
-    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
-    add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
-    set<T extends Data>(ref: DataDocument<T>, data: T): Promise<void>;
-    update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): Promise<void>;
-    delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
-    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Iterable<Entry<T>>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T | Update<T> | undefined): Promise<number>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;
+    get<T extends Data>(ref: DatabaseDocument<T>): Promise<Result<T>>;
+    subscribe<T extends Data>(ref: DatabaseDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
+    add<T extends Data>(ref: DatabaseQuery<T>, data: T): Promise<string>;
+    set<T extends Data>(ref: DatabaseDocument<T>, data: T): Promise<void>;
+    update<T extends Data>(ref: DatabaseDocument<T>, updates: Update<T>): Promise<void>;
+    delete<T extends Data>(ref: DatabaseDocument<T>): Promise<void>;
+    getQuery<T extends Data>(ref: DatabaseQuery<T>): Promise<Iterable<Entry<T>>>;
+    subscribeQuery<T extends Data>(ref: DatabaseQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
+    setQuery<T extends Data>(ref: DatabaseQuery<T>, data: T | Update<T> | undefined): Promise<number>;
+    updateQuery<T extends Data>(ref: DatabaseQuery<T>, updates: Update<T>): Promise<number>;
+    deleteQuery<T extends Data>(ref: DatabaseQuery<T>): Promise<number>;
 }

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.39.0",
+	"version": "1.40.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/provider/BatchProvider.d.ts

@@ -1,5 +1,5 @@
 import { MutableObject, Result, Observer, Unsubscriber, Observable, Entries, Results, Data } from "../util/index.js";
-import type { DataDocument, DataQuery } from "../db/index.js";
+import type { DatabaseDocument, DatabaseQuery } from "../db/index.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /**
  * Provider that batches multiple database reads from a source provider together, for efficiency.
@@ -15,12 +15,12 @@ export declare class BatchProvider extends ThroughProvider {
     protected readonly _gets: MutableObject<Promise<any>>;
     /** List of currently ongoing subscription streams. */
     protected readonly _subs: MutableObject<Observable<any>>;
-    get<T extends Data>(ref: DataDocument<T>): Result<T> | Promise<Result<T>>;
+    get<T extends Data>(ref: DatabaseDocument<T>): Result<T> | Promise<Result<T>>;
     /** Await a result and delete it from get requests when done. */
     private _awaitDocument;
-    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
-    getQuery<T extends Data>(ref: DataQuery<T>): Entries<T> | Promise<Entries<T>>;
+    subscribe<T extends Data>(ref: DatabaseDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
+    getQuery<T extends Data>(ref: DatabaseQuery<T>): Entries<T> | Promise<Entries<T>>;
     /** Await a set of results and delete from get requests when done. */
     private _awaitDocuments;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    subscribeQuery<T extends Data>(ref: DatabaseQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
 }

package/provider/CacheProvider.d.ts

@@ -1,4 +1,4 @@
-import type { DataDocument, DataQuery } from "../db/index.js";
+import type { DatabaseDocument, DatabaseQuery } from "../db/index.js";
 import { Update } from "../update/index.js";
 import { Result, Unsubscriber, Observer, Entries, Data } from "../util/index.js";
 import type { Provider, AsynchronousProvider } from "./Provider.js";
@@ -12,24 +12,24 @@ export declare class CacheProvider extends ThroughProvider implements Asynchrono
     private _times;
     constructor(source: Provider, cache?: MemoryProvider);
     /** Is a given document or query in the cache? */
-    isCached<T extends Data>(ref: DataDocument<T> | DataQuery<T>): boolean;
+    isCached<T extends Data>(ref: DatabaseDocument<T> | DatabaseQuery<T>): boolean;
     /** Get the cache age for a given document or query reference. */
-    getCachedAge<T extends Data>(ref: DataDocument<T> | DataQuery<T>): number;
+    getCachedAge<T extends Data>(ref: DatabaseDocument<T> | DatabaseQuery<T>): number;
     /** Cache an individual document result. */
     private _cacheResult;
-    get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
-    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
-    add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
-    set<T extends Data>(ref: DataDocument<T>, data: T): Promise<void>;
-    update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): Promise<void>;
-    delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
+    get<T extends Data>(ref: DatabaseDocument<T>): Promise<Result<T>>;
+    subscribe<T extends Data>(ref: DatabaseDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
+    add<T extends Data>(ref: DatabaseQuery<T>, data: T): Promise<string>;
+    set<T extends Data>(ref: DatabaseDocument<T>, data: T): Promise<void>;
+    update<T extends Data>(ref: DatabaseDocument<T>, updates: Update<T>): Promise<void>;
+    delete<T extends Data>(ref: DatabaseDocument<T>): Promise<void>;
     /** Cache a set of document entries. */
     private _cacheEntries;
-    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Entries<T>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T): Promise<number>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;
+    getQuery<T extends Data>(ref: DatabaseQuery<T>): Promise<Entries<T>>;
+    subscribeQuery<T extends Data>(ref: DatabaseQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
+    setQuery<T extends Data>(ref: DatabaseQuery<T>, data: T): Promise<number>;
+    updateQuery<T extends Data>(ref: DatabaseQuery<T>, updates: Update<T>): Promise<number>;
+    deleteQuery<T extends Data>(ref: DatabaseQuery<T>): Promise<number>;
     /** Reset this provider and clear all data. */
     reset(): void;
 }

package/provider/MemoryProvider.d.ts

@@ -1,6 +1,6 @@
 import { Data, Result, Entries, Unsubscriber, Observer } from "../util/index.js";
 import { Update } from "../update/index.js";
-import { DataQuery, DataDocument } from "../db/index.js";
+import { DatabaseQuery, DatabaseDocument } from "../db/index.js";
 import { Provider, SynchronousProvider } from "./Provider.js";
 /**
  * Fast in-memory store for data.
@@ -11,17 +11,17 @@ export declare class MemoryProvider extends Provider implements SynchronousProvi
     /** List of tables in `{ path: Table }` format. */
     private _tables;
     private _table;
-    get<T extends Data>(ref: DataDocument<T>): Result<T>;
-    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
-    add<T extends Data>(ref: DataQuery<T>, data: T): string;
-    set<T extends Data>(ref: DataDocument<T>, data: T): void;
-    update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): void;
-    delete<T extends Data>(ref: DataDocument<T>): void;
-    getQuery<T extends Data>(ref: DataQuery<T>): Entries<T>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T): number;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): number;
+    get<T extends Data>(ref: DatabaseDocument<T>): Result<T>;
+    subscribe<T extends Data>(ref: DatabaseDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
+    add<T extends Data>(ref: DatabaseQuery<T>, data: T): string;
+    set<T extends Data>(ref: DatabaseDocument<T>, data: T): void;
+    update<T extends Data>(ref: DatabaseDocument<T>, updates: Update<T>): void;
+    delete<T extends Data>(ref: DatabaseDocument<T>): void;
+    getQuery<T extends Data>(ref: DatabaseQuery<T>): Entries<T>;
+    subscribeQuery<T extends Data>(ref: DatabaseQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
+    setQuery<T extends Data>(ref: DatabaseQuery<T>, data: T): number;
+    updateQuery<T extends Data>(ref: DatabaseQuery<T>, updates: Update<T>): number;
+    deleteQuery<T extends Data>(ref: DatabaseQuery<T>): number;
     /** Reset this provider and clear all data. */
     reset(): void;
 }

package/provider/Provider.d.ts

@@ -1,5 +1,5 @@
 import type { Observer, Unsubscriber, Result, Entries, Data } from "../util/index.js";
-import type { DataDocument, DataQuery } from "../db/Database.js";
+import type { DatabaseDocument, DatabaseQuery } from "../db/Database.js";
 import type { Update } from "../update/index.js";
 /** Provides access to data (e.g. IndexedDB, Firebase, or in-memory cache providers). */
 export declare abstract class Provider {
@@ -9,7 +9,7 @@ export declare abstract class Provider {
      * @param ref Document reference specifying which document to get.
      * @return The document object, or `undefined` if it doesn't exist.
      */
-    abstract get<T extends Data>(ref: DataDocument<T>): Result<T> | PromiseLike<Result<T>>;
+    abstract get<T extends Data>(ref: DatabaseDocument<T>): Result<T> | PromiseLike<Result<T>>;
     /**
      * Subscribe to the result of a document.
      * - `next()` is called once with the initial result, and again any time the result changes.
@@ -19,7 +19,7 @@ export declare abstract class Provider {
      *
      * @return Function that ends the subscription.
      */
-    abstract subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
+    abstract subscribe<T extends Data>(ref: DatabaseDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
     /**
      * Create a new document with a random ID.
      * - Created document is guaranteed to have a unique ID.
@@ -29,7 +29,7 @@ export declare abstract class Provider {
      *
      * @return String ID for the created document (possibly promised).
      */
-    abstract add<T extends Data>(ref: DataQuery<T>, data: T): string | PromiseLike<string>;
+    abstract add<T extends Data>(ref: DatabaseQuery<T>, data: T): string | PromiseLike<string>;
     /**
      * Set the data a document.
      * - If the document exists, set the value of it.
@@ -40,7 +40,7 @@ export declare abstract class Provider {
      *
      * @throws Error If a `Update` was provided but the document does not exist (ideally a `RequiredError` but may be provider-specific).
      */
-    abstract set<T extends Data>(ref: DataDocument<T>, value: T): void | PromiseLike<void>;
+    abstract set<T extends Data>(ref: DatabaseDocument<T>, value: T): void | PromiseLike<void>;
     /**
      * Update the data an existing document.
      *
@@ -49,19 +49,19 @@ export declare abstract class Provider {
      *
      * @throws Error If the document does not exist (ideally a `RequiredError` but may be provider-specific).
      */
-    abstract update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): void | PromiseLike<void>;
+    abstract update<T extends Data>(ref: DatabaseDocument<T>, updates: Update<T>): void | PromiseLike<void>;
     /**
      * Delete a specified document.
      * @param ref Document reference specifying which document to delete.
      */
-    abstract delete<T extends Data>(ref: DataDocument<T>): void | PromiseLike<void>;
+    abstract delete<T extends Data>(ref: DatabaseDocument<T>): void | PromiseLike<void>;
     /**
      * Get all matching documents.
      *
      * @param ref Documents reference specifying which collection to get documents from.
      * @return Set of results in `id: data` format.
      */
-    abstract getQuery<T extends Data>(ref: DataQuery<T>): Entries<T> | PromiseLike<Entries<T>>;
+    abstract getQuery<T extends Data>(ref: DatabaseQuery<T>): Entries<T> | PromiseLike<Entries<T>>;
     /**
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
@@ -71,7 +71,7 @@ export declare abstract class Provider {
      *
      * @return Function that ends the subscription.
      */
-    abstract subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
+    abstract subscribeQuery<T extends Data>(ref: DatabaseQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
     /**
      * Set the data of all matching documents.
      *
@@ -79,7 +79,7 @@ export declare abstract class Provider {
      * @param value Value to set the document to.
      * @return Number of documents that were set.
      */
-    abstract setQuery<T extends Data>(ref: DataQuery<T>, data: T): number | PromiseLike<number>;
+    abstract setQuery<T extends Data>(ref: DatabaseQuery<T>, data: T): number | PromiseLike<number>;
     /**
      * Update the data of all matching documents.
      *
@@ -87,35 +87,35 @@ export declare abstract class Provider {
      * @param updates Update instance to set the document to.
      * @return Number of documents that were updated.
      */
-    abstract updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number | PromiseLike<number>;
+    abstract updateQuery<T extends Data>(ref: DatabaseQuery<T>, updates: Update<T>): number | PromiseLike<number>;
     /**
      * Delete all matching documents.
      * @param ref Document reference specifying which document to delete.
      * @return Number of documents that were deleted.
      */
-    abstract deleteQuery<T extends Data>(ref: DataQuery<T>): number | PromiseLike<number>;
+    abstract deleteQuery<T extends Data>(ref: DatabaseQuery<T>): number | PromiseLike<number>;
 }
 /** Provider with a fully synchronous interface */
 export interface SynchronousProvider extends Provider {
-    get<T extends Data>(ref: DataDocument<T>): Result<T>;
-    add<T extends Data>(ref: DataQuery<T>, data: T): string;
-    set<T extends Data>(ref: DataDocument<T>, value: T): void;
-    update<T extends Data>(ref: DataDocument<T>, value: Update<T>): void;
-    delete<T extends Data>(ref: DataDocument<T>): void;
-    getQuery<T extends Data>(ref: DataQuery<T>): Entries<T>;
-    setQuery<T extends Data>(ref: DataQuery<T>, value: T): number;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): number;
+    get<T extends Data>(ref: DatabaseDocument<T>): Result<T>;
+    add<T extends Data>(ref: DatabaseQuery<T>, data: T): string;
+    set<T extends Data>(ref: DatabaseDocument<T>, value: T): void;
+    update<T extends Data>(ref: DatabaseDocument<T>, value: Update<T>): void;
+    delete<T extends Data>(ref: DatabaseDocument<T>): void;
+    getQuery<T extends Data>(ref: DatabaseQuery<T>): Entries<T>;
+    setQuery<T extends Data>(ref: DatabaseQuery<T>, value: T): number;
+    updateQuery<T extends Data>(ref: DatabaseQuery<T>, updates: Update<T>): number;
+    deleteQuery<T extends Data>(ref: DatabaseQuery<T>): number;
 }
 /** Provider with a fully asynchronous interface */
 export interface AsynchronousProvider extends Provider {
-    get<T extends Data>(ref: DataDocument<T>): PromiseLike<Result<T>>;
-    add<T extends Data>(ref: DataQuery<T>, data: T): PromiseLike<string>;
-    set<T extends Data>(ref: DataDocument<T>, value: T): PromiseLike<void>;
-    update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): PromiseLike<void>;
-    delete<T extends Data>(ref: DataDocument<T>): PromiseLike<void>;
-    getQuery<T extends Data>(ref: DataQuery<T>): PromiseLike<Entries<T>>;
-    setQuery<T extends Data>(ref: DataQuery<T>, value: T): PromiseLike<number>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): PromiseLike<number>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): PromiseLike<number>;
+    get<T extends Data>(ref: DatabaseDocument<T>): PromiseLike<Result<T>>;
+    add<T extends Data>(ref: DatabaseQuery<T>, data: T): PromiseLike<string>;
+    set<T extends Data>(ref: DatabaseDocument<T>, value: T): PromiseLike<void>;
+    update<T extends Data>(ref: DatabaseDocument<T>, updates: Update<T>): PromiseLike<void>;
+    delete<T extends Data>(ref: DatabaseDocument<T>): PromiseLike<void>;
+    getQuery<T extends Data>(ref: DatabaseQuery<T>): PromiseLike<Entries<T>>;
+    setQuery<T extends Data>(ref: DatabaseQuery<T>, value: T): PromiseLike<number>;
+    updateQuery<T extends Data>(ref: DatabaseQuery<T>, updates: Update<T>): PromiseLike<number>;
+    deleteQuery<T extends Data>(ref: DatabaseQuery<T>): PromiseLike<number>;
 }

package/provider/ThroughProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Result, Entries, Unsubscriber, Observer, Class, Data } from "../util/index.js";
-import type { DataDocument, DataQuery } from "../db/index.js";
+import type { DatabaseDocument, DatabaseQuery } from "../db/index.js";
 import type { Update } from "../update/index.js";
 import { Provider } from "./Provider.js";
 /**
@@ -8,17 +8,17 @@ import { Provider } from "./Provider.js";
 export declare class ThroughProvider extends Provider {
     readonly source: Provider;
     constructor(source: Provider);
-    get<T extends Data>(ref: DataDocument<T>): Result<T> | PromiseLike<Result<T>>;
-    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
-    add<T extends Data>(ref: DataQuery<T>, data: T): string | PromiseLike<string>;
-    set<T extends Data>(ref: DataDocument<T>, data: T): void | PromiseLike<void>;
-    update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): void | PromiseLike<void>;
-    delete<T extends Data>(ref: DataDocument<T>): void | PromiseLike<void>;
-    getQuery<T extends Data>(ref: DataQuery<T>): Entries<T> | PromiseLike<Entries<T>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T): number | PromiseLike<number>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number | PromiseLike<number>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): number | PromiseLike<number>;
+    get<T extends Data>(ref: DatabaseDocument<T>): Result<T> | PromiseLike<Result<T>>;
+    subscribe<T extends Data>(ref: DatabaseDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
+    add<T extends Data>(ref: DatabaseQuery<T>, data: T): string | PromiseLike<string>;
+    set<T extends Data>(ref: DatabaseDocument<T>, data: T): void | PromiseLike<void>;
+    update<T extends Data>(ref: DatabaseDocument<T>, updates: Update<T>): void | PromiseLike<void>;
+    delete<T extends Data>(ref: DatabaseDocument<T>): void | PromiseLike<void>;
+    getQuery<T extends Data>(ref: DatabaseQuery<T>): Entries<T> | PromiseLike<Entries<T>>;
+    subscribeQuery<T extends Data>(ref: DatabaseQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
+    setQuery<T extends Data>(ref: DatabaseQuery<T>, data: T): number | PromiseLike<number>;
+    updateQuery<T extends Data>(ref: DatabaseQuery<T>, updates: Update<T>): number | PromiseLike<number>;
+    deleteQuery<T extends Data>(ref: DatabaseQuery<T>): number | PromiseLike<number>;
 }
 /** Find a specific source provider in a database's provider stack. */
 export declare function findSourceProvider<P extends Provider>(provider: Provider, type: Class<P>): P;

package/provider/ValidationProvider.d.ts

@@ -1,16 +1,16 @@
-import type { DataDocument, DataQuery } from "../db/index.js";
+import type { DatabaseDocument, DatabaseQuery } from "../db/index.js";
 import { Data, Result, Unsubscriber, Observer, Entries } from "../util/index.js";
 import { Update } from "../update/index.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** Validates any values that are read from or written to a source provider. */
 export declare class ValidationProvider extends ThroughProvider {
-    get<T extends Data>(ref: DataDocument<T>): Result<T> | PromiseLike<Result<T>>;
-    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result>): Unsubscriber;
-    add<T extends Data>(ref: DataQuery<T>, data: T): string | PromiseLike<string>;
-    set<T extends Data>(ref: DataDocument<T>, value: T): void | PromiseLike<void>;
-    update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): void | PromiseLike<void>;
-    getQuery<T extends Data>(ref: DataQuery<T>): Entries<T> | PromiseLike<Entries<T>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, value: T): number | PromiseLike<number>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number | PromiseLike<number>;
+    get<T extends Data>(ref: DatabaseDocument<T>): Result<T> | PromiseLike<Result<T>>;
+    subscribe<T extends Data>(ref: DatabaseDocument<T>, observer: Observer<Result>): Unsubscriber;
+    add<T extends Data>(ref: DatabaseQuery<T>, data: T): string | PromiseLike<string>;
+    set<T extends Data>(ref: DatabaseDocument<T>, value: T): void | PromiseLike<void>;
+    update<T extends Data>(ref: DatabaseDocument<T>, updates: Update<T>): void | PromiseLike<void>;
+    getQuery<T extends Data>(ref: DatabaseQuery<T>): Entries<T> | PromiseLike<Entries<T>>;
+    subscribeQuery<T extends Data>(ref: DatabaseQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
+    setQuery<T extends Data>(ref: DatabaseQuery<T>, value: T): number | PromiseLike<number>;
+    updateQuery<T extends Data>(ref: DatabaseQuery<T>, updates: Update<T>): number | PromiseLike<number>;
 }

package/react/useDocument.d.ts

@@ -1,4 +1,4 @@
-import { DataDocument, Result, Data } from "../index.js";
+import { DatabaseDocument, Result, Data } from "../index.js";
 /**
  * Use the cached result of a document in a React component (or a `Promise` to indicate the result is still loading).
  * - Requires database to use `CacheProvider` and will error if this does not exist.
@@ -13,8 +13,8 @@ import { DataDocument, Result, Data } from "../index.js";
  * @trhows `Error` if a `CacheProvider` is not part of the database's provider chain.
  * @throws `Error` if there was a problem retrieving the result.
  */
-export declare function useAsyncDocument<T extends Data>(ref: DataDocument<T>, maxAge?: number | true): Result<T> | PromiseLike<Result<T>>;
-export declare function useAsyncDocument<T extends Data>(ref: DataDocument<T> | undefined, maxAge?: number | true): Result<T> | PromiseLike<Result<T>> | undefined;
+export declare function useAsyncDocument<T extends Data>(ref: DatabaseDocument<T>, maxAge?: number | true): Result<T> | PromiseLike<Result<T>>;
+export declare function useAsyncDocument<T extends Data>(ref: DatabaseDocument<T> | undefined, maxAge?: number | true): Result<T> | PromiseLike<Result<T>> | undefined;
 /**
  * Use the cached data of a document in a React component.
  * - Requires database to use `CacheProvider` and will error if this does not exist.
@@ -30,11 +30,11 @@ export declare function useAsyncDocument<T extends Data>(ref: DataDocument<T> |
  * @trhows `Error` if a `CacheProvider` is not part of the database's provider chain.
  * @throws `Error` if there was a problem retrieving the result.
  */
-export declare function useDocument<T extends Data>(ref: DataDocument<T>, maxAge?: number | true): Result<T>;
-export declare function useDocument<T extends Data>(ref: DataDocument<T> | undefined, maxAge?: number | true): Result<T> | undefined;
+export declare function useDocument<T extends Data>(ref: DatabaseDocument<T>, maxAge?: number | true): Result<T>;
+export declare function useDocument<T extends Data>(ref: DatabaseDocument<T> | undefined, maxAge?: number | true): Result<T> | undefined;
 /** Use the data of a document or `undefined` if the query has no matching results (or a promise indicating the result is loading). */
-export declare function useAsyncDocumentData<T extends Data>(ref: DataDocument<T>, maxAge?: number | true): T | PromiseLike<T>;
-export declare function useAsyncDocumentData<T extends Data>(ref: DataDocument<T> | undefined, maxAge?: number | true): T | PromiseLike<T> | undefined;
+export declare function useAsyncDocumentData<T extends Data>(ref: DatabaseDocument<T>, maxAge?: number | true): T | PromiseLike<T>;
+export declare function useAsyncDocumentData<T extends Data>(ref: DatabaseDocument<T> | undefined, maxAge?: number | true): T | PromiseLike<T> | undefined;
 /** Use the data of a document or `undefined` if the query has no matching results. */
-export declare function useDocumentData<T extends Data>(ref: DataDocument<T>, maxAge?: number | true): T;
-export declare function useDocumentData<T extends Data>(ref: DataDocument<T> | undefined, maxAge?: number | true): T | undefined;
+export declare function useDocumentData<T extends Data>(ref: DatabaseDocument<T>, maxAge?: number | true): T;
+export declare function useDocumentData<T extends Data>(ref: DatabaseDocument<T> | undefined, maxAge?: number | true): T | undefined;

package/react/usePagination.d.ts

@@ -1,6 +1,6 @@
-import { DataQuery, Results, Pagination, Data } from "../index.js";
+import { DatabaseQuery, Results, Pagination, Data } from "../index.js";
 /**
  * Use a `Pagination` for a collection.
  * - Doesn't persist the state, so if the component or anything beneath it throws the currently paginated results will be lost.
  */
-export declare function usePagination<T extends Data>(ref: DataQuery<T>, initial?: Results<T>): Pagination<T>;
+export declare function usePagination<T extends Data>(ref: DatabaseQuery<T>, initial?: Results<T>): Pagination<T>;

package/react/useQuery.d.ts

@@ -1,4 +1,4 @@
-import { Results, DataQuery, Data, Entry } from "../index.js";
+import { Results, DatabaseQuery, Data, Entry } from "../index.js";
 /**
  * Use the cached result of a document in a React component (or a `Promise` to indicate the result is still loading).
  * - Requires database to use `CacheProvider` and will error if this does not exist.
@@ -14,8 +14,8 @@ import { Results, DataQuery, Data, Entry } from "../index.js";
  * @trhows `Error` if a `CacheProvider` is not part of the database's provider chain.
  * @throws `Error` if there was a problem retrieving the results.
  */
-export declare function useAsyncQuery<T extends Data>(ref: DataQuery<T>, maxAge?: number | true): Results<T> | PromiseLike<Results<T>>;
-export declare function useAsyncQuery<T extends Data>(ref: DataQuery<T> | undefined, maxAge?: number | true): Results<T> | PromiseLike<Results<T>> | undefined;
+export declare function useAsyncQuery<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): Results<T> | PromiseLike<Results<T>>;
+export declare function useAsyncQuery<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): Results<T> | PromiseLike<Results<T>> | undefined;
 /**
  * Use the cached results of a set of documents in a React component.
  * - Requires database to use `CacheProvider` and will error if this does not exist.
@@ -31,17 +31,17 @@ export declare function useAsyncQuery<T extends Data>(ref: DataQuery<T> | undefi
  * @trhows `Error` if a `CacheProvider` is not part of the database's provider chain.
  * @throws `Error` if there was a problem retrieving the results.
  */
-export declare function useQuery<T extends Data>(ref: DataQuery<T>, maxAge?: number | true): Results<T>;
-export declare function useQuery<T extends Data>(ref: DataQuery<T> | undefined, maxAge?: number | true): Results<T> | undefined;
+export declare function useQuery<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): Results<T>;
+export declare function useQuery<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): Results<T> | undefined;
 /** Use the first result of a query or `undefined` if the query has no matching results (or a promise indicating the result is loading). */
-export declare function useAsyncQueryResult<T extends Data>(ref: DataQuery<T>, maxAge?: number | true): Entry<T> | undefined | PromiseLike<Entry<T> | undefined>;
-export declare function useAsyncQueryResult<T extends Data>(ref: DataQuery<T> | undefined, maxAge?: number | true): Entry<T> | undefined | PromiseLike<Entry<T> | undefined>;
+export declare function useAsyncQueryResult<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): Entry<T> | undefined | PromiseLike<Entry<T> | undefined>;
+export declare function useAsyncQueryResult<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): Entry<T> | undefined | PromiseLike<Entry<T> | undefined>;
 /** Use the first result of a query or `undefined` if the query has no matching results */
-export declare function useQueryResult<T extends Data>(ref: DataQuery<T>, maxAge?: number | true): Entry<T> | undefined;
-export declare function useQueryResult<T extends Data>(ref: DataQuery<T> | undefined, maxAge?: number | true): Entry<T> | undefined;
+export declare function useQueryResult<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): Entry<T> | undefined;
+export declare function useQueryResult<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): Entry<T> | undefined;
 /** Use the first result of a query (or a promise indicating the result is loading). */
-export declare function useAsyncQueryData<T extends Data>(ref: DataQuery<T>, maxAge?: number | true): Entry<T> | PromiseLike<Entry<T>>;
-export declare function useAsyncQueryData<T extends Data>(ref: DataQuery<T> | undefined, maxAge?: number | true): Entry<T> | PromiseLike<Entry<T>> | undefined;
+export declare function useAsyncQueryData<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): Entry<T> | PromiseLike<Entry<T>>;
+export declare function useAsyncQueryData<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): Entry<T> | PromiseLike<Entry<T>> | undefined;
 /** Use the first result of a query. */
-export declare function useQueryData<T extends Data>(ref: DataQuery<T>, maxAge?: number | true): Entry<T>;
-export declare function useQueryData<T extends Data>(ref: DataQuery<T> | undefined, maxAge?: number | true): Entry<T> | undefined;
+export declare function useQueryData<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): Entry<T>;
+export declare function useQueryData<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): Entry<T> | undefined;

package/update/DataUpdate.d.ts

@@ -1,4 +1,4 @@
-import { Data, Prop, Key, Transformable } from "../util/index.js";
+import { Data, Prop, Key, Transformable, Nullish } from "../util/index.js";
 import { Update } from "./Update.js";
 /**
  * Set of named transforms for the props of a data object.
@@ -12,11 +12,11 @@ export declare type PropUpdates<T extends Data> = {
 };
 /** Update that can be applied to a data object to update its props. */
 export declare class DataUpdate<T extends Data> extends Update<T> implements Iterable<Prop<PropUpdates<T>>>, Transformable<T, T> {
-    readonly props: PropUpdates<T>;
+    readonly updates: PropUpdates<T>;
     constructor(props: PropUpdates<T>);
     transform(existing: T): T;
     /** Return a new object with the specified additional transform for a prop. */
-    prop<K extends Key<T>>(key: K | undefined | null | false, value: T[K] | Update<T[K]>): this;
+    update<K extends Key<T>>(key: Nullish<K>, value: T[K] | Update<T[K]>): this;
     /** Iterate over the transforms in this object. */
     [Symbol.iterator](): Iterator<Prop<PropUpdates<T>>, void>;
 }

package/update/DataUpdate.js

@@ -1,22 +1,22 @@
-import { transformProps } from "../util/index.js";
+import { transformProps, isNullish } from "../util/index.js";
 import { Update } from "./Update.js";
 /** Update that can be applied to a data object to update its props. */
 export class DataUpdate extends Update {
     constructor(props) {
         super();
-        this.props = props;
+        this.updates = props;
     }
     transform(existing) {
-        return transformProps(existing, this.props);
+        return transformProps(existing, this.updates);
     }
     /** Return a new object with the specified additional transform for a prop. */
-    prop(key, value) {
-        if (key === undefined || key === null || key === false)
+    update(key, value) {
+        if (isNullish(key))
             return this;
-        return { __proto__: Object.getPrototypeOf(this), ...this, props: { ...this.props, [key]: value } };
+        return { __proto__: Object.getPrototypeOf(this), ...this, updates: { ...this.updates, [key]: value } };
     }
     /** Iterate over the transforms in this object. */
     [Symbol.iterator]() {
-        return Object.entries(this.props).values();
+        return Object.entries(this.updates).values();
     }
 }

package/update/ObjectUpdate.d.ts

@@ -1,4 +1,4 @@
-import { Entry, ImmutableArray, ImmutableObject } from "../util/index.js";
+import { Entry, ImmutableArray, ImmutableObject, Nullish } from "../util/index.js";
 import { Update } from "./Update.js";
 /** Set of named transforms for the entries of a map-like object. */
 export declare type EntryUpdates<T> = ImmutableObject<T | Update<T>>;
@@ -13,9 +13,9 @@ export declare class ObjectUpdate<T> extends Update<ImmutableObject<T>> implemen
     constructor(updates?: EntryUpdates<T>, deletes?: ImmutableArray<string>);
     transform(existing: unknown): ImmutableObject<T>;
     /** Return an object update with a specific entry marked for update. */
-    update(key: string | undefined | null, value: T | Update<T>): this;
+    update(key: Nullish<string>, value: T | Update<T>): this;
     /** Return an object update with a specific entry marked for deletion. */
-    delete(key: string | undefined | null): this;
+    delete(key: Nullish<string>): this;
     /**
      * Iterate over the changes in this object.
      * - Updates are yielded first, then deletes.

package/update/ObjectUpdate.js

@@ -21,13 +21,13 @@ export class ObjectUpdate extends Update {
     }
     /** Return an object update with a specific entry marked for update. */
     update(key, value) {
-        if (key === undefined || key === null)
+        if (isNullish(key))
             return this;
         return { __proto__: Object.getPrototypeOf(this), ...this, sets: { ...this.updates, [key]: value } };
     }
     /** Return an object update with a specific entry marked for deletion. */
     delete(key) {
-        if (key === undefined || key === null)
+        if (isNullish(key))
             return this;
         return { __proto__: Object.getPrototypeOf(this), ...this, deletes: [...this.deletes, key] };
     }

package/update/Update.d.ts

@@ -1,6 +1,6 @@
 import { Transformable } from "../util/index.js";
 /**
- * An object that represents an update of an existing value value.
+ * An object that represents an update of an existing value.
  * - Implements `Transformable` for applying that update with its `transform()` method.
  */
 export declare abstract class Update<T> implements Transformable<T, T> {

package/update/Update.js

@@ -1,5 +1,5 @@
 /**
- * An object that represents an update of an existing value value.
+ * An object that represents an update of an existing value.
  * - Implements `Transformable` for applying that update with its `transform()` method.
  */
 export class Update {

package/update/util.d.ts

@@ -1,7 +1,5 @@
 import { DataSchema } from "../schema/DataSchema.js";
-import { Validator, Validators, Data } from "../util/index.js";
-import { DataUpdate, Update, PropUpdates } from "./index.js";
+import { Validator, Data } from "../util/index.js";
+import { DataUpdate, Update } from "./index.js";
 /** Validate an update against a validator. */
 export declare function validateUpdate<T>(unsafeUpdate: Update<T> | DataUpdate<T & Data>, validator: Validator<T> | DataSchema<T & Data>): Update<T>;
-/** Validate a set of transforms against a set of validators. */
-export declare function validateUpdates<T extends Data>(unsafeUpdates: PropUpdates<T>, validators: Validators<T>): PropUpdates<T>;

package/update/util.js

@@ -6,8 +6,8 @@ import { DataUpdate, Update } from "./index.js";
 /** Validate an update against a validator. */
 export function validateUpdate(unsafeUpdate, validator) {
     if (validator instanceof DataSchema && unsafeUpdate instanceof DataUpdate) {
-        const unsafeUpdates = unsafeUpdate.props;
-        const safeUpdates = validateUpdates(unsafeUpdates, validator.props);
+        const unsafeUpdates = unsafeUpdate.updates;
+        const safeUpdates = validatePropUpdates(unsafeUpdates, validator.props);
         return safeUpdates === unsafeUpdates ? unsafeUpdate : new DataUpdate(safeUpdates);
     }
     else {
@@ -16,7 +16,7 @@ export function validateUpdate(unsafeUpdate, validator) {
     }
 }
 /** Validate a set of transforms against a set of validators. */
-export function validateUpdates(unsafeUpdates, validators) {
+function validatePropUpdates(unsafeUpdates, validators) {
     let invalid = false;
     const safeUpdates = {};
     const details = {};