shelving 1.20.0 → 1.20.1

package/db/Change.d.ts

@@ -1,36 +1,34 @@
 import { Transforms, Transform } from "../transform/index.js";
-import { Datas, ImmutableArray, Key } from "../util/index.js";
-import type { Database, DatabaseDocument } from "./Database.js";
+import { ImmutableArray, Data } from "../util/index.js";
+import type { Database, DataDocument } from "./Database.js";
 /** A single change that can be made to a database. */
-export declare abstract class Change<T extends Datas> {
+export declare abstract class Change {
     /** Apply this change to a database. */
-    abstract apply(db: Database<T>): void | PromiseLike<void>;
+    abstract apply(db: Database): void | PromiseLike<void>;
 }
 /** A change that writes a document in a database. */
-export declare class Write<C extends Key<D>, D extends Datas> extends Change<D> {
-    static on<Y extends Key<X>, X extends Datas>({ collection, id }: DatabaseDocument<Y, X>, value: X[Y] | Transform<X[Y]> | undefined): Write<Y, X>;
-    readonly collection: C;
+export declare class Write<T extends Data> extends Change {
+    readonly collection: string;
     readonly id: string;
-    readonly value: D[C] | Transform<D[C]> | undefined;
-    constructor(collection: C, id: string, value: D[C] | Transform<D[C]> | undefined);
-    apply(db: Database<D>): void | PromiseLike<void>;
+    readonly value: Data | Transform<Data> | undefined;
+    constructor({ collection, id }: DataDocument<T>, value: T | Transform<T> | undefined);
+    apply(db: Database): void | PromiseLike<void>;
 }
 /**
  * Set of writes that can be applied to documents in a database.
  * - Sets of changes are predictable and repeatable, so unpredictable operations like `create()` and query operations are not supported.
  * - Every change must be applied to a specific database document in a specific collection.
  */
-export declare class Writes<D extends Datas> extends Change<D> {
-    static on<X extends Datas>(db: Database<X>, ...changes: ImmutableArray<Change<X>>): Writes<X>;
-    readonly changes: ImmutableArray<Change<D>>;
-    constructor(...changes: ImmutableArray<Change<D>>);
+export declare class Writes extends Change {
+    readonly changes: ImmutableArray<Change>;
+    constructor(...changes: Change[]);
     /** Return a new `Changes` instance with an additional `Write` instance in its changes list. */
-    set<C extends Key<D>>({ collection, id }: DatabaseDocument<C, D>, data: D[C]): this;
+    set<T extends Data>(ref: DataDocument<T>, data: T): this;
     /** Return a new `Changes` instance with an additional `Write` instance in its changes list. */
-    delete<C extends Key<D>>({ collection, id }: DatabaseDocument<C, D>): this;
+    delete<T extends Data>(ref: DataDocument<T>): this;
     /** Return a new `Changes` instance with an additional `Write` instance in its changes list. */
-    update<C extends Key<D>>({ collection, id }: DatabaseDocument<C, D>, transforms: Transforms<D[C]> | Transform<D[C]>): this;
-    apply(db: Database<D>): Promise<void> | undefined;
+    update<T extends Data>(ref: DataDocument<T>, transforms: Transforms<T> | Transform<T>): this;
+    apply(db: Database): Promise<void> | undefined;
 }
 /** Set of hydrations for all change classes. */
 export declare const CHANGE_HYDRATIONS: {

package/db/Change.js

@@ -5,15 +5,12 @@ export class Change {
 }
 /** A change that writes a document in a database. */
 export class Write extends Change {
-    constructor(collection, id, value) {
+    constructor({ collection, id }, value) {
         super();
         this.collection = collection;
         this.id = id;
         this.value = value;
     }
-    static on({ collection, id }, value) {
-        return new Write(collection, id, value);
-    }
     apply(db) {
         return db.doc(this.collection, this.id).write(this.value);
     }
@@ -28,23 +25,20 @@ export class Writes extends Change {
         super();
         this.changes = changes;
     }
-    static on(db, ...changes) {
-        return new Writes(...changes);
-    }
     /** Return a new `Changes` instance with an additional `Write` instance in its changes list. */
-    set({ collection, id }, data) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, changes: [...this.changes, new Write(collection, id, data)] };
+    set(ref, data) {
+        return { __proto__: Object.getPrototypeOf(this), ...this, changes: [...this.changes, new Write(ref, data)] };
     }
     /** Return a new `Changes` instance with an additional `Write` instance in its changes list. */
-    delete({ collection, id }) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, changes: [...this.changes, new Write(collection, id, undefined)] };
+    delete(ref) {
+        return { __proto__: Object.getPrototypeOf(this), ...this, changes: [...this.changes, new Write(ref, undefined)] };
     }
     /** Return a new `Changes` instance with an additional `Write` instance in its changes list. */
-    update({ collection, id }, transforms) {
+    update(ref, transforms) {
         return {
             __proto__: Object.getPrototypeOf(this),
             ...this,
-            changes: [...this.changes, new Write(collection, id, transforms instanceof Transform ? transforms : new DataTransform(transforms))],
+            changes: [...this.changes, new Write(ref, transforms instanceof Transform ? transforms : new DataTransform(transforms))],
         };
     }
     apply(db) {

package/db/Database.d.ts

@@ -1,4 +1,4 @@
-import { Dispatcher, Entry, Observable, Observer, Result, Unsubscriber, Datas, ResultsMap, Validatable, Validator, Validators, Key, Data, Results } from "../util/index.js";
+import { Dispatcher, Entry, Observable, Observer, Result, Unsubscriber, ResultsMap, Validatable, Validator, Key, Data, Results, Datas, Validators, ValidatorType } from "../util/index.js";
 import { Transform, Transforms } from "../transform/index.js";
 import type { Provider } from "../provider/Provider.js";
 import { Filters, Sorts, Query } from "../query/index.js";
@@ -9,23 +9,23 @@ import { Filters, Sorts, Query } from "../query/index.js";
  * @param collections Set of loci describing collections at the root level of the database.
  * @param provider Provider that allows data to be read/written.
  */
-export declare class Database<D extends Datas> {
-    readonly validators: Validators<D>;
-    readonly provider: Provider<D>;
-    constructor(validators: Validators<D>, provider: Provider<D>);
+export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
+    readonly validators: V;
+    readonly provider: Provider;
+    constructor(validators: V, provider: Provider);
     /** Create a query on a collection in this model. */
-    query<C extends Key<D>>(collection: C, filters?: Filters<D[C]>, sorts?: Sorts<D[C]>, limit?: number | null): DatabaseQuery<C, D>;
+    query<K extends Key<V>>(collection: K, filters?: Filters<ValidatorType<V[K]>>, sorts?: Sorts<ValidatorType<V[K]>>, limit?: number | null): DataQuery<ValidatorType<V[K]>>;
     /** Reference a document in a collection in this model. */
-    doc<C extends Key<D>>(collection: C, id: string): DatabaseDocument<C, D>;
+    doc<K extends Key<V>>(collection: K, id: string): DataDocument<ValidatorType<V[K]>>;
 }
 /** A documents reference within a specific database. */
-export declare class DatabaseQuery<C extends Key<D>, D extends Datas> extends Query<D[C]> implements Observable<Results<D[C]>>, Validatable<Results<D[C]>>, Iterable<Entry<D[C]>> {
-    readonly db: Database<D>;
-    readonly validator: Validator<D[C]>;
-    readonly collection: C;
-    constructor(db: Database<D>, collection: C, filters?: Filters<D[C]>, sorts?: Sorts<D[C]>, limit?: number | null);
+export declare class DataQuery<T extends Data = Data> extends Query<T> implements Observable<Results<T>>, Validatable<Results<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): DatabaseDocument<C, D>;
+    doc(id: string): DataDocument<T>;
     /**
      * Create a new document with a random ID.
      * - Created document is guaranteed to have a unique ID.
@@ -33,17 +33,17 @@ export declare class DatabaseQuery<C extends Key<D>, D extends Datas> extends Qu
      * @param data Complete data to set the document to.
      * @return String ID for the created document (possibly promised).
      */
-    add(data: D[C]): string | PromiseLike<string>;
+    add(data: T): string | PromiseLike<string>;
     /**
      * Get an iterable that yields the results of this entry.
      * @return Map containing the results.
      */
-    get results(): Results<D[C]> | PromiseLike<Results<D[C]>>;
+    get results(): Results<T> | PromiseLike<Results<T>>;
     /**
      * Get an iterable that yields the results of this entry.
      * @return Map containing the results.
      */
-    get resultsMap(): ResultsMap<D[C]> | PromiseLike<ResultsMap<D[C]>>;
+    get resultsMap(): ResultsMap<T> | PromiseLike<ResultsMap<T>>;
     /**
      * Count the number of results of this set of documents.
      * @return Number of documents in the collection (possibly promised).
@@ -53,7 +53,7 @@ export declare class DatabaseQuery<C extends Key<D>, D extends Datas> extends Qu
      * Get an entry for the first document matching this query.
      * @return Entry in `[id, data]` format for the first document, or `undefined` if there are no matching documents (possibly promised).
      */
-    get first(): Entry<D[C]> | undefined | PromiseLike<Entry<D[C]> | undefined>;
+    get first(): Entry<T> | undefined | PromiseLike<Entry<T> | undefined>;
     /**
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
@@ -65,7 +65,7 @@ export declare class DatabaseQuery<C extends Key<D>, D extends Datas> extends Qu
      *
      * @return Function that ends the subscription.
      */
-    subscribe(next: Observer<Results<D[C]>> | Dispatcher<Results<D[C]>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
+    subscribe(next: Observer<Results<T>> | Dispatcher<Results<T>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
     /**
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
@@ -77,14 +77,14 @@ export declare class DatabaseQuery<C extends Key<D>, D extends Datas> extends Qu
      *
      * @return Function that ends the subscription.
      */
-    subscribeMap(next: Observer<ResultsMap<D[C]>> | Dispatcher<ResultsMap<D[C]>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
+    subscribeMap(next: Observer<ResultsMap<T>> | Dispatcher<ResultsMap<T>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
     /**
      * Set all matching documents to the same exact value.
      *
      * @param data Complete data to set the document to.
      * @return Nothing (possibly promised).
      */
-    set(data: D[C]): void | PromiseLike<void>;
+    set(data: T): void | PromiseLike<void>;
     /**
      * Update all matching documents with the same partial value.
      *
@@ -93,7 +93,7 @@ export declare class DatabaseQuery<C extends Key<D>, D extends Datas> extends Qu
      *
      * @return Nothing (possibly promised).
      */
-    update(transform: Transform<D[C]> | Transforms<D[C]>): void | PromiseLike<void>;
+    update(transform: Transform<T> | Transforms<T>): void | PromiseLike<void>;
     /**
      * Delete all matching documents.
      * @return Nothing (possibly promised).
@@ -103,24 +103,24 @@ export declare class DatabaseQuery<C extends Key<D>, D extends Datas> extends Qu
      * Combine `set()`, `update()`, `delete()` into a single method.
      * @return Nothing (possibly promised).
      */
-    write(value: Result<D[C]> | Transform<D[C]>): void | PromiseLike<void>;
+    write(value: Result<T> | Transform<T>): void | PromiseLike<void>;
     /** Iterate over the resuls (will throw `Promise` if the results are asynchronous). */
-    [Symbol.iterator](): Iterator<Entry<D[C]>, void>;
+    [Symbol.iterator](): Iterator<Entry<T>, void>;
     /** Validate a set of results for this query reference. */
-    validate(unsafeEntries: Results): Results<D[C]>;
+    validate(unsafeEntries: Results): Results<T>;
     toString(): string;
 }
 /** A document reference within a specific database. */
-export declare class DatabaseDocument<C extends Key<D>, D extends Datas> implements Observable<Result<D[C]>>, Validatable<D[C]> {
-    readonly db: Database<D>;
-    readonly validator: Validator<D[C]>;
-    readonly collection: C;
+export declare class DataDocument<T extends Data = Data> implements Observable<Result<T>>, Validatable<T> {
+    readonly provider: Provider;
+    readonly validator: Validator<T>;
+    readonly collection: string;
     readonly id: string;
-    constructor(db: Database<D>, collection: C, id: string);
+    constructor(provider: Provider, validator: Validator<T>, collection: string, id: string);
     /** Create a query on this document's collection. */
-    query(filters?: Filters<D[C]>, sorts?: Sorts<D[C]>, limit?: number | null): DatabaseQuery<C, D>;
+    query(filters?: Filters<T>, sorts?: Sorts<T>, limit?: number | null): DataQuery<T>;
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
-    get optional(): DatabaseQuery<C, D>;
+    get optional(): DataQuery<T>;
     /**
      * Does this document exist?
      *
@@ -132,7 +132,7 @@ export declare class DatabaseDocument<C extends Key<D>, D extends Datas> impleme
      *
      * @return Document's data, or `undefined` if the document doesn't exist (possibly promised).
      */
-    get result(): Result<D[C]> | PromiseLike<Result<D[C]>>;
+    get result(): Result<T> | PromiseLike<Result<T>>;
     /**
      * Get the data of this document.
      * - Useful for destructuring, e.g. `{ name, title } = await documentThatMustExist.asyncData`
@@ -140,7 +140,7 @@ export declare class DatabaseDocument<C extends Key<D>, D extends Datas> impleme
      * @return Document's data (possibly promised).
      * @throws RequiredError if the document's result was undefined.
      */
-    get data(): D[C] | PromiseLike<D[C]>;
+    get data(): T | PromiseLike<T>;
     /**
      * Subscribe to the result of this document (indefinitely).
      * - `next()` is called once with the initial result, and again any time the result changes.
@@ -152,7 +152,7 @@ export declare class DatabaseDocument<C extends Key<D>, D extends Datas> impleme
      *
      * @return Function that ends the subscription.
      */
-    subscribe(next: Observer<Result<D[C]>> | Dispatcher<Result<D[C]>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
+    subscribe(next: Observer<Result<T>> | Dispatcher<Result<T>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
     /**
      * Set the complete data of this document.
      *
@@ -160,7 +160,7 @@ export declare class DatabaseDocument<C extends Key<D>, D extends Datas> impleme
      *
      * @return Nothing (possibly promised).
      */
-    set(data: D[C]): void | PromiseLike<void>;
+    set(data: T): void | PromiseLike<void>;
     /**
      * Update this document with partial data.
      * - If the document exists, merge the partial data into it.
@@ -172,7 +172,7 @@ export declare class DatabaseDocument<C extends Key<D>, D extends Datas> impleme
      * @return Nothing (possibly promised).
      * @throws Error If the document does not exist (ideally a `RequiredError` but may be provider-specific).
      */
-    update(transforms: Transform<D[C]> | Transforms<D[C]>): void | PromiseLike<void>;
+    update(transforms: Transform<T> | Transforms<T>): void | PromiseLike<void>;
     /**
      * Delete this document.
      * - Will not throw an error if the document doesn't exist.
@@ -183,18 +183,10 @@ export declare class DatabaseDocument<C extends Key<D>, D extends Datas> impleme
     /**
      * Combine `set()`, `update()`, `delete()` into a single method.
      */
-    write(value: Result<D[C]> | Transform<D[C]>): void | PromiseLike<void>;
+    write(value: Result<T> | Transform<T>): void | PromiseLike<void>;
     /** Validate data for this query reference. */
-    validate(unsafeData: Data): D[C];
+    validate(unsafeData: Data): T;
     toString(): string;
 }
 /** Get the data for a document from a result for that document. */
-export declare function getDocumentData<C extends Key<D>, D extends Datas>(result: Result<D[C]>, ref: DatabaseDocument<C, D>): D[C];
-/** Database query with a collection name. */
-export declare type CollectionQuery<C extends string, T extends Data> = DatabaseQuery<C, {
-    [K in C]: T;
-}>;
-/** Database document with a collection name. */
-export declare type CollectionDocument<C extends string, T extends Data> = DatabaseDocument<C, {
-    [K in C]: T;
-}>;
+export declare function getDocumentData<T extends Data>(result: Result<T>, ref: DataDocument<T>): T;

package/db/Database.js

@@ -10,6 +10,7 @@ import { DocumentRequiredError, DocumentValidationError, QueryValidationError }
  * @param collections Set of loci describing collections at the root level of the database.
  * @param provider Provider that allows data to be read/written.
  */
+// Note: typing this with `Validators` rather than raw `Datas` works better for inference — type for props in each collection tends to get lost.
 export class Database {
     constructor(validators, provider) {
         this.validators = validators;
@@ -17,24 +18,24 @@ export class Database {
     }
     /** Create a query on a collection in this model. */
     query(collection, filters, sorts, limit) {
-        return new DatabaseQuery(this, collection, filters, sorts, limit);
+        return new DataQuery(this.provider, this.validators[collection], collection, filters, sorts, limit);
     }
     /** Reference a document in a collection in this model. */
     doc(collection, id) {
-        return new DatabaseDocument(this, collection, id);
+        return new DataDocument(this.provider, this.validators[collection], collection, id);
     }
 }
 /** A documents reference within a specific database. */
-export class DatabaseQuery extends Query {
-    constructor(db, collection, filters, sorts, limit) {
+export class DataQuery extends Query {
+    constructor(provider, validator, collection, filters, sorts, limit) {
         super(filters, sorts, limit);
-        this.db = db;
-        this.validator = db.validators[collection];
+        this.provider = provider;
+        this.validator = validator;
         this.collection = collection;
     }
     /** Reference a document in this query's collection. */
     doc(id) {
-        return new DatabaseDocument(this.db, this.collection, id);
+        return new DataDocument(this.provider, this.validator, this.collection, id);
     }
     /**
      * Create a new document with a random ID.
@@ -44,21 +45,21 @@ export class DatabaseQuery extends Query {
      * @return String ID for the created document (possibly promised).
      */
     add(data) {
-        return this.db.provider.add(this, data);
+        return this.provider.add(this, data);
     }
     /**
      * Get an iterable that yields the results of this entry.
      * @return Map containing the results.
      */
     get results() {
-        return this.db.provider.getQuery(this);
+        return this.provider.getQuery(this);
     }
     /**
      * Get an iterable that yields the results of this entry.
      * @return Map containing the results.
      */
     get resultsMap() {
-        return callAsync(toMap, this.db.provider.getQuery(this));
+        return callAsync(toMap, this.provider.getQuery(this));
     }
     /**
      * Count the number of results of this set of documents.
@@ -86,7 +87,7 @@ export class DatabaseQuery extends Query {
      * @return Function that ends the subscription.
      */
     subscribe(next, error, complete) {
-        return this.db.provider.subscribeQuery(this, createObserver(next, error, complete));
+        return this.provider.subscribeQuery(this, createObserver(next, error, complete));
     }
     /**
      * Subscribe to all matching documents.
@@ -100,7 +101,7 @@ export class DatabaseQuery extends Query {
      * @return Function that ends the subscription.
      */
     subscribeMap(next, error, complete) {
-        return this.db.provider.subscribeQuery(this, new DeriveObserver(toMap, createObserver(next, error, complete)));
+        return this.provider.subscribeQuery(this, new DeriveObserver(toMap, createObserver(next, error, complete)));
     }
     /**
      * Set all matching documents to the same exact value.
@@ -134,7 +135,7 @@ export class DatabaseQuery extends Query {
      * @return Nothing (possibly promised).
      */
     write(value) {
-        return this.db.provider.writeQuery(this, value);
+        return this.provider.writeQuery(this, value);
     }
     /** Iterate over the resuls (will throw `Promise` if the results are asynchronous). */
     [Symbol.iterator]() {
@@ -164,20 +165,20 @@ export class DatabaseQuery extends Query {
     }
 }
 /** A document reference within a specific database. */
-export class DatabaseDocument {
-    constructor(db, collection, id) {
-        this.db = db;
-        this.validator = db.validators[collection];
+export class DataDocument {
+    constructor(provider, validator, collection, id) {
+        this.provider = provider;
+        this.validator = validator;
         this.collection = collection;
         this.id = id;
     }
     /** Create a query on this document's collection. */
     query(filters, sorts, limit) {
-        return new DatabaseQuery(this.db, this.collection, filters, sorts, limit);
+        return new DataQuery(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 DatabaseQuery(this.db, this.collection, new Filters(new EqualFilter("id", this.id)));
+        return new DataQuery(this.provider, this.validator, this.collection, new Filters(new EqualFilter("id", this.id)));
     }
     /**
      * Does this document exist?
@@ -185,7 +186,7 @@ export class DatabaseDocument {
      * @return Document's data, or `undefined` if the document doesn't exist (possibly promised).
      */
     get exists() {
-        return callAsync(Boolean, this.db.provider.get(this));
+        return callAsync(Boolean, this.provider.get(this));
     }
     /**
      * Get the result of this document.
@@ -193,7 +194,7 @@ export class DatabaseDocument {
      * @return Document's data, or `undefined` if the document doesn't exist (possibly promised).
      */
     get result() {
-        return this.db.provider.get(this);
+        return this.provider.get(this);
     }
     /**
      * Get the data of this document.
@@ -203,7 +204,7 @@ export class DatabaseDocument {
      * @throws RequiredError if the document's result was undefined.
      */
     get data() {
-        return callAsync(getDocumentData, this.db.provider.get(this), this);
+        return callAsync(getDocumentData, this.provider.get(this), this);
     }
     /**
      * Subscribe to the result of this document (indefinitely).
@@ -217,7 +218,7 @@ export class DatabaseDocument {
      * @return Function that ends the subscription.
      */
     subscribe(next, error, complete) {
-        return this.db.provider.subscribe(this, createObserver(next, error, complete));
+        return this.provider.subscribe(this, createObserver(next, error, complete));
     }
     /**
      * Set the complete data of this document.
@@ -256,7 +257,7 @@ export class DatabaseDocument {
      * Combine `set()`, `update()`, `delete()` into a single method.
      */
     write(value) {
-        return this.db.provider.write(this, value);
+        return this.provider.write(this, value);
     }
     /** Validate data for this query reference. */
     validate(unsafeData) {

package/db/Pagination.d.ts

@@ -1,19 +1,19 @@
-import { Datas, Key, ResultsMap, Entry, Results } from "../util/index.js";
+import { ResultsMap, Entry, Results, Data } from "../util/index.js";
 import { State } from "../stream/index.js";
-import { DatabaseQuery } from "./Database.js";
+import { DataQuery } 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.
  * - If you don't pass in initial values, it will autoload the first page.
  */
-export declare class Pagination<C extends Key<D>, D extends Datas> extends State<ResultsMap<D[C]>> implements Iterable<Entry<D[C]>> {
-    readonly ref: DatabaseQuery<C, D>;
+export declare class Pagination<T extends Data> extends State<ResultsMap<T>> implements Iterable<Entry<T>> {
+    readonly ref: DataQuery<T>;
     readonly limit: number;
     readonly startLoading: boolean;
     readonly startDone: boolean;
     readonly endLoading: boolean;
     readonly endDone: boolean;
-    constructor(ref: DatabaseQuery<C, D>);
+    constructor(ref: DataQuery<T>);
     /**
      * Load more results before the start.
      * - Promise that needs to be handled.
@@ -28,7 +28,7 @@ export declare class Pagination<C extends Key<D>, D extends Datas> extends State
      * Merge more results into this pagination.
      * @return The change in the number of results.
      */
-    merge(more: Results<D[C]>): void;
+    merge(more: Results<T>): void;
     /** Iterate over the entries of the values currently in the pagination. */
-    [Symbol.iterator](): Iterator<Entry<D[C]>>;
+    [Symbol.iterator](): Iterator<Entry<T>>;
 }

package/db/errors.d.ts

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

package/firestore/client/FirestoreClientProvider.d.ts

@@ -1,19 +1,19 @@
 import type { Firestore } from "firebase/firestore";
-import { Results, Provider, DatabaseDocument, DatabaseQuery, Result, Observer, Transform, AsynchronousProvider, Datas, Key } from "../../index.js";
+import { Results, Provider, DataDocument, DataQuery, Result, Observer, Transform, AsynchronousProvider, Data } from "../../index.js";
 /**
  * Firestore client database provider.
  * - Works with the Firebase JS SDK.
  * - Supports offline mode.
  * - Supports realtime subscriptions.
  */
-export declare class FirestoreClientProvider<D extends Datas> extends Provider<D> implements AsynchronousProvider<D> {
+export declare class FirestoreClientProvider extends Provider implements AsynchronousProvider {
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
-    get<C extends Key<D>>(ref: DatabaseDocument<C, D>): Promise<Result<D[C]>>;
-    subscribe<C extends Key<D>>(ref: DatabaseDocument<C, D>, observer: Observer<Result<D[C]>>): () => void;
-    add<C extends Key<D>>(ref: DatabaseQuery<C, D>, data: D[C]): Promise<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>): Promise<Results<D[C]>>;
-    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, observer: Observer<Results<D[C]>>): () => void;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
+    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): () => void;
+    add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
+    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): () => void;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
 }

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -1,19 +1,19 @@
 import type { Firestore } from "firebase/firestore/lite";
-import { Provider, DatabaseDocument, DatabaseQuery, Result, Transform, AsynchronousProvider, Datas, Key, Results } from "../../index.js";
+import { Provider, DataDocument, DataQuery, Result, Transform, AsynchronousProvider, Data, Results } from "../../index.js";
 /**
  * Firestore Lite client database provider.
  * - Works with the Firebase JS SDK.
  * - Does not support offline mode.
  * - Does not support realtime subscriptions.
  */
-export declare class FirestoreClientProvider<D extends Datas> extends Provider<D> implements AsynchronousProvider<D> {
+export declare class FirestoreClientProvider extends Provider implements AsynchronousProvider {
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
-    get<C extends Key<D>>(ref: DatabaseDocument<C, D>): Promise<Result<D[C]>>;
+    get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
     subscribe(): () => void;
-    add<C extends Key<D>>(ref: DatabaseQuery<C, D>, data: D[C]): Promise<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>): Promise<Results<D[C]>>;
+    add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
+    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
     subscribeQuery(): () => void;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
 }

package/firestore/server/FirestoreServerProvider.d.ts

@@ -1,17 +1,17 @@
 import { Firestore } from "@google-cloud/firestore";
-import { Provider, DatabaseDocument, DatabaseQuery, Observer, Result, Transform, AsynchronousProvider, Datas, Key, Entry, Results } from "../../index.js";
+import { Provider, DataDocument, DataQuery, Observer, Result, Transform, Data, AsynchronousProvider, Entry, Results } from "../../index.js";
 /**
  * Firestore server database provider.
  * - Works with the Firebase Admin SDK for Node.JS
  */
-export declare class FirestoreServerProvider<D extends Datas> extends Provider<D> implements AsynchronousProvider<D> {
+export declare class FirestoreServerProvider extends Provider implements AsynchronousProvider {
     readonly firestore: Firestore;
     constructor(firestore?: Firestore);
-    get<C extends Key<D>>(ref: DatabaseDocument<C, D>): Promise<Result<D[C]>>;
-    subscribe<C extends Key<D>>(ref: DatabaseDocument<C, D>, observer: Observer<Result<D[C]>>): () => void;
-    add<C extends Key<D>>(ref: DatabaseQuery<C, D>, data: D[C]): Promise<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>): Promise<Iterable<Entry<D[C]>>>;
-    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, observer: Observer<Results<D[C]>>): () => void;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
+    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): () => void;
+    add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
+    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Iterable<Entry<T>>>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): () => void;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
 }

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.20.0",
+	"version": "1.20.1",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -61,18 +61,18 @@
 		"@types/jest": "^27.0.3",
 		"@types/react": "^17.0.37",
 		"@types/react-dom": "^17.0.11",
-		"@typescript-eslint/eslint-plugin": "^5.4.0",
-		"@typescript-eslint/parser": "^5.4.0",
+		"@typescript-eslint/eslint-plugin": "^5.5.0",
+		"@typescript-eslint/parser": "^5.5.0",
+		"eslint": "^8.4.0",
 		"eslint-config-prettier": "^8.3.0",
 		"eslint-plugin-import": "^2.25.3",
 		"eslint-plugin-prettier": "^4.0.0",
-		"eslint": "^8.3.0",
-		"firebase": "^9.5.0",
+		"firebase": "^9.6.0",
+		"jest": "^27.4.3",
 		"jest-ts-webcompat-resolver": "^1.0.0",
-		"jest": "^27.3.1",
-		"prettier": "^2.5.0",
-		"react-dom": "^17.0.2",
+		"prettier": "^2.5.1",
 		"react": "^17.0.2",
+		"react-dom": "^17.0.2",
 		"ts-jest": "^27.0.7",
 		"typescript": "^4.5.2"
 	},

package/provider/BatchProvider.d.ts

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

package/provider/CacheProvider.d.ts

@@ -1,31 +1,31 @@
-import type { DatabaseDocument, DatabaseQuery } from "../db/index.js";
+import type { DataDocument, DataQuery } from "../db/index.js";
 import { Transform } from "../transform/index.js";
-import { Result, Unsubscriber, Observer, Datas, Key, Results } from "../util/index.js";
+import { Result, Unsubscriber, Observer, Results, Data } from "../util/index.js";
 import type { Provider, AsynchronousProvider } from "./Provider.js";
 import { MemoryProvider } from "./MemoryProvider.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** Keep a copy of received data in a local cache. */
-export declare class CacheProvider<D extends Datas> extends ThroughProvider<D> implements AsynchronousProvider<D> {
+export declare class CacheProvider extends ThroughProvider implements AsynchronousProvider {
     /** The local cache provider. */
-    readonly cache: MemoryProvider<D>;
+    readonly cache: MemoryProvider;
     /** Last-known-correct time for data, indexed by key to power `getCachedAge()` etc. */
     private _times;
-    constructor(source: Provider<D>, cache?: MemoryProvider<D>);
+    constructor(source: Provider, cache?: MemoryProvider);
     /** Is a given document or query in the cache? */
-    isCached<C extends Key<D>>(ref: DatabaseDocument<C, D> | DatabaseQuery<C, D>): boolean;
+    isCached<T extends Data>(ref: DataDocument<T> | DataQuery<T>): boolean;
     /** Get the cache age for a given document or query reference. */
-    getCachedAge<C extends Key<D>>(ref: DatabaseDocument<C, D> | DatabaseQuery<C, D>): number;
+    getCachedAge<T extends Data>(ref: DataDocument<T> | DataQuery<T>): number;
     /** Cache an individual document result. */
     private _cacheResult;
-    get<C extends Key<D>>(ref: DatabaseDocument<C, D>): Promise<Result<D[C]>>;
-    subscribe<C extends Key<D>>(ref: DatabaseDocument<C, D>, observer: Observer<Result<D[C]>>): Unsubscriber;
-    add<C extends Key<D>>(ref: DatabaseQuery<C, D>, data: D[C]): Promise<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    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>;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
     /** Cache a set of document results. */
     private _cacheResults;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>): Promise<Results<D[C]>>;
-    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, observer: Observer<Results<D[C]>>): Unsubscriber;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
     /** Reset this provider and clear all data. */
     reset(): void;
 }

package/provider/MemoryProvider.d.ts

@@ -1,23 +1,23 @@
-import { Result, Results, Unsubscriber, Observer, Datas, Key } from "../util/index.js";
+import { Data, Result, Results, Unsubscriber, Observer } from "../util/index.js";
 import { Transform } from "../transform/index.js";
-import { DatabaseQuery, DatabaseDocument } from "../db/index.js";
+import { DataQuery, DataDocument } from "../db/index.js";
 import { Provider, SynchronousProvider } from "./Provider.js";
 /**
  * Fast in-memory store for data.
  * - Extremely fast (ideal for caching!), but does not persist data after the browser window is closed.
  * - `get()` etc return the exact same instance of an object that's passed into `set()`
  */
-export declare class MemoryProvider<D extends Datas> extends Provider<D> implements SynchronousProvider<D> {
+export declare class MemoryProvider extends Provider implements SynchronousProvider {
     /** List of tables in `{ path: Table }` format. */
     private _tables;
     private _table;
-    get<C extends Key<D>>(ref: DatabaseDocument<C, D>): Result<D[C]>;
-    subscribe<C extends Key<D>>(ref: DatabaseDocument<C, D>, observer: Observer<Result<D[C]>>): Unsubscriber;
-    add<C extends Key<D>>(ref: DatabaseQuery<C, D>, data: D[C]): string;
-    write<C extends Key<D>>(ref: DatabaseDocument<C, D>, value: D[C] | Transform<D[C]> | undefined): void;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>): Results<D[C]>;
-    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, observer: Observer<Results<D[C]>>): Unsubscriber;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, value: D[C] | Transform<D[C]> | undefined): void;
+    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;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): void;
+    getQuery<T extends Data>(ref: DataQuery<T>): Results<T>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): void;
     /** Reset this provider and clear all data. */
     reset(): void;
 }

package/provider/MemoryProvider.js

@@ -11,7 +11,7 @@ export class MemoryProvider extends Provider {
     constructor() {
         super(...arguments);
         /** List of tables in `{ path: Table }` format. */
-        this._tables = {};
+        this._tables = {}; // eslint-disable-line @typescript-eslint/no-explicit-any
     }
     // Get a named collection (or create a new one).
     _table({ collection }) {

package/provider/Provider.d.ts

@@ -1,15 +1,15 @@
-import type { Observer, Unsubscriber, Result, Datas, Key, Results } from "../util/index.js";
-import type { DatabaseDocument, DatabaseQuery } from "../db/Database.js";
+import type { Observer, Unsubscriber, Result, Results, Data } from "../util/index.js";
+import type { DataDocument, DataQuery } from "../db/Database.js";
 import type { Transform } from "../transform/index.js";
 /** Provides access to data (e.g. IndexedDB, Firebase, or in-memory cache providers). */
-export declare abstract class Provider<D extends Datas = Datas> {
+export declare abstract class Provider {
     /**
      * Get the result of a document.
      *
      * @param ref Document reference specifying which document to get.
      * @return The document object, or `undefined` if it doesn't exist.
      */
-    abstract get<C extends Key<D>>(ref: DatabaseDocument<C, D>): Result<D[C]> | PromiseLike<Result<D[C]>>;
+    abstract get<T extends Data>(ref: DataDocument<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<D extends Datas = Datas> {
      *
      * @return Function that ends the subscription.
      */
-    abstract subscribe<C extends Key<D>>(ref: DatabaseDocument<C, D>, observer: Observer<Result<D[C]>>): Unsubscriber;
+    abstract subscribe<T extends Data>(ref: DataDocument<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<D extends Datas = Datas> {
      *
      * @return String ID for the created document (possibly promised).
      */
-    abstract add<C extends Key<D>>(ref: DatabaseQuery<C, D>, data: D[C]): string | PromiseLike<string>;
+    abstract add<T extends Data>(ref: DataQuery<T>, data: T): string | PromiseLike<string>;
     /**
      * Write to a document.
      * - If the document exists, set the value of it.
@@ -44,14 +44,14 @@ export declare abstract class Provider<D extends Datas = Datas> {
      * @return Nothing (possibly promised).
      * @throws Error If a `Transform` was provided but the document does not exist (ideally a `RequiredError` but may be provider-specific).
      */
-    abstract write<C extends Key<D>>(ref: DatabaseDocument<C, D>, value: D[C] | Transform<D[C]> | undefined): void | PromiseLike<void>;
+    abstract write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): 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<C extends Key<D>>(ref: DatabaseQuery<C, D>): Results<D[C]> | PromiseLike<Results<D[C]>>;
+    abstract getQuery<T extends Data>(ref: DataQuery<T>): Results<T> | PromiseLike<Results<T>>;
     /**
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
@@ -61,7 +61,7 @@ export declare abstract class Provider<D extends Datas = Datas> {
      *
      * @return Function that ends the subscription.
      */
-    abstract subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, observer: Observer<Results<D[C]>>): Unsubscriber;
+    abstract subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
     /**
      * Write to all matching documents.
      *
@@ -73,21 +73,21 @@ export declare abstract class Provider<D extends Datas = Datas> {
      *
      * @return Nothing (possibly promised).
      */
-    abstract writeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, value: D[C] | Transform<D[C]> | undefined): void | PromiseLike<void>;
+    abstract writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): void | PromiseLike<void>;
 }
 /** Provider with a fully synchronous interface */
-export interface SynchronousProvider<D extends Datas> extends Provider<D> {
-    get<C extends Key<D>>(ref: DatabaseDocument<C, D>): Result<D[C]>;
-    add<C extends Key<D>>(ref: DatabaseQuery<C, D>, data: D[C]): string;
-    write<C extends Key<D>>(ref: DatabaseDocument<C, D>, value: D[C] | Transform<D[C]> | undefined): void;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>): Results<D[C]>;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, value: D[C] | Transform<D[C]> | undefined): void;
+export interface SynchronousProvider extends Provider {
+    get<T extends Data>(ref: DataDocument<T>): Result<T>;
+    add<T extends Data>(ref: DataQuery<T>, data: T): string;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): void;
+    getQuery<T extends Data>(ref: DataQuery<T>): Results<T>;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): void;
 }
 /** Provider with a fully asynchronous interface */
-export interface AsynchronousProvider<D extends Datas> extends Provider<D> {
-    get<C extends Key<D>>(ref: DatabaseDocument<C, D>): PromiseLike<Result<D[C]>>;
-    add<C extends Key<D>>(ref: DatabaseQuery<C, D>, data: D[C]): PromiseLike<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<C, D>, value: D[C] | Transform<D[C]> | undefined): PromiseLike<void>;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>): PromiseLike<Results<D[C]>>;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, value: D[C] | Transform<D[C]> | undefined): PromiseLike<void>;
+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>;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): PromiseLike<void>;
+    getQuery<T extends Data>(ref: DataQuery<T>): PromiseLike<Results<T>>;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): PromiseLike<void>;
 }

package/provider/ThroughProvider.d.ts

@@ -1,20 +1,20 @@
-import type { Result, Results, Unsubscriber, Observer, Class, Datas, Key } from "../util/index.js";
-import type { DatabaseDocument, DatabaseQuery } from "../db/index.js";
+import type { Result, Results, Unsubscriber, Observer, Class, Data } from "../util/index.js";
+import type { DataDocument, DataQuery } from "../db/index.js";
 import type { Transform } from "../transform/index.js";
 import { Provider } from "./Provider.js";
 /**
  * Pass all reads and writes through to a source provider.
  */
-export declare class ThroughProvider<D extends Datas> extends Provider<D> {
-    readonly source: Provider<D>;
-    constructor(source: Provider<D>);
-    get<C extends Key<D>>(ref: DatabaseDocument<C, D>): Result<D[C]> | PromiseLike<Result<D[C]>>;
-    subscribe<C extends Key<D>>(ref: DatabaseDocument<C, D>, observer: Observer<Result<D[C]>>): Unsubscriber;
-    add<C extends Key<D>>(ref: DatabaseQuery<C, D>, data: D[C]): string | PromiseLike<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<C, D>, value: D[C] | Transform<D[C]> | undefined): void | PromiseLike<void>;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>): Results<D[C]> | PromiseLike<Results<D[C]>>;
-    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, observer: Observer<Results<D[C]>>): Unsubscriber;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, value: D[C] | Transform<D[C]> | undefined): void | PromiseLike<void>;
+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>;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): void | PromiseLike<void>;
+    getQuery<T extends Data>(ref: DataQuery<T>): Results<T> | PromiseLike<Results<T>>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): void | PromiseLike<void>;
 }
 /** Find a specific source provider in a database's provider stack. */
-export declare function findSourceProvider<D extends Datas, P extends Provider<D>>(provider: Provider<D>, type: Class<P>): P;
+export declare function findSourceProvider<P extends Provider>(provider: Provider, type: Class<P>): P;

package/provider/ValidationProvider.d.ts

@@ -1,14 +1,14 @@
-import type { DatabaseDocument, DatabaseQuery } from "../db/index.js";
-import { Result, Unsubscriber, Observer, Datas, Key, Results } from "../util/index.js";
+import type { DataDocument, DataQuery } from "../db/index.js";
+import { Data, Result, Unsubscriber, Observer, Results } from "../util/index.js";
 import { Transform } from "../transform/index.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** Validates any values that are read from or written to a source provider. */
-export declare class ValidationProvider<D extends Datas> extends ThroughProvider<D> {
-    get<C extends Key<D>>(ref: DatabaseDocument<C, D>): Result<D[C]> | PromiseLike<Result<D[C]>>;
-    subscribe<C extends Key<D>>(ref: DatabaseDocument<C, D>, observer: Observer<Result>): Unsubscriber;
-    add<C extends Key<D>>(ref: DatabaseQuery<C, D>, data: D[C]): string | PromiseLike<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<C, D>, value: D[C] | Transform<D[C]> | undefined): void | PromiseLike<void>;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>): Results<D[C]> | PromiseLike<Results<D[C]>>;
-    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, observer: Observer<Results<D[C]>>): Unsubscriber;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, value: D[C] | Transform<D[C]> | undefined): void | PromiseLike<void>;
+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>;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): void | PromiseLike<void>;
+    getQuery<T extends Data>(ref: DataQuery<T>): Results<T> | PromiseLike<Results<T>>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): void | PromiseLike<void>;
 }

package/react/useDocument.d.ts

@@ -1,4 +1,4 @@
-import { DatabaseDocument, Result, Datas, Key } from "../index.js";
+import { DataDocument, 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 { DatabaseDocument, Result, Datas, Key } 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<D extends Datas, C extends Key<D>>(ref: DatabaseDocument<C, D>, maxAge?: number | true): Result<D[C]> | PromiseLike<Result<D[C]>>;
-export declare function useAsyncDocument<D extends Datas, C extends Key<D>>(ref: DatabaseDocument<C, D> | undefined, maxAge?: number | true): Result<D[C]> | PromiseLike<Result<D[C]>> | undefined;
+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;
 /**
  * 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,5 +30,5 @@ export declare function useAsyncDocument<D extends Datas, C extends Key<D>>(ref:
  * @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 useResult<D extends Datas, C extends Key<D>>(ref: DatabaseDocument<C, D>, maxAge?: number | true): Result<D[C]>;
-export declare function useResult<D extends Datas, C extends Key<D>>(ref: DatabaseDocument<C, D> | undefined, maxAge?: number | true): Result<D[C]> | undefined;
+export declare function useResult<T extends Data>(ref: DataDocument<T>, maxAge?: number | true): Result<T>;
+export declare function useResult<T extends Data>(ref: DataDocument<T> | undefined, maxAge?: number | true): Result<T> | undefined;

package/react/useDocument.js

@@ -30,13 +30,13 @@ export function useAsyncDocument(ref, maxAge = 1000) {
 function getCachedResult(ref) {
     if (!ref)
         return undefined;
-    const provider = findSourceProvider(ref.db.provider, CacheProvider);
+    const provider = findSourceProvider(ref.provider, CacheProvider);
     return provider.isCached(ref) ? provider.cache.get(ref) : NOVALUE;
 }
 /** Effect that subscribes a component to the cache for a reference. */
 function subscribeEffect(ref, maxAge, next, error) {
     if (ref) {
-        const provider = findSourceProvider(ref.db.provider, CacheProvider);
+        const provider = findSourceProvider(ref.provider, CacheProvider);
         const stopCache = provider.cache.subscribe(ref, { next, error });
         if (maxAge === true) {
             // If `maxAge` is true subscribe to the source for as long as this component is attached.

package/react/useDocumentData.d.ts

@@ -1,4 +1,4 @@
-import { DatabaseDocument, Datas, Key } from "../index.js";
+import { DataDocument, Data } from "../index.js";
 /**
  * Use the cached data of a document in a React component (or a `Promise` to indicate the data is still loading).
  * - Requires database to use `CacheProvider` and will error if this does not exist.
@@ -14,8 +14,8 @@ import { DatabaseDocument, Datas, Key } 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 data.
  */
-export declare function useAsyncDocumentData<D extends Datas, C extends Key<D>>(ref: DatabaseDocument<C, D>, maxAge?: number | true): D[C] | Promise<D[C]>;
-export declare function useAsyncDocumentData<D extends Datas, C extends Key<D>>(ref: DatabaseDocument<C, D> | undefined, maxAge?: number | true): D[C] | PromiseLike<D[C]> | undefined;
+export declare function useAsyncDocumentData<T extends Data>(ref: DataDocument<T>, maxAge?: number | true): T | Promise<T>;
+export declare function useAsyncDocumentData<T extends Data>(ref: DataDocument<T> | undefined, maxAge?: number | true): T | PromiseLike<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.
@@ -32,5 +32,5 @@ export declare function useAsyncDocumentData<D extends Datas, C extends Key<D>>(
  * @trhows `Error` if a `CacheProvider` is not part of the database's provider chain.
  * @throws `Error` if there was a problem retrieving the data.
  */
-export declare function useDocumentData<D extends Datas, C extends Key<D>>(ref: DatabaseDocument<C, D>, maxAge?: number | true): D[C];
-export declare function useDocumentData<D extends Datas, C extends Key<D>>(ref: DatabaseDocument<C, D> | undefined, maxAge?: number | true): D[C] | undefined;
+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;

package/react/usePagination.d.ts

@@ -1,6 +1,6 @@
-import { DatabaseQuery, ResultsMap, Pagination, Datas, Key } from "../index.js";
+import { DataQuery, ResultsMap, 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<D extends Datas, C extends Key<D>>(ref: DatabaseQuery<C, D>, initial?: ResultsMap<D[C]>): Pagination<C, D>;
+export declare function usePagination<T extends Data>(ref: DataQuery<T>, initial?: ResultsMap<T>): Pagination<T>;

package/react/useQuery.d.ts

@@ -1,4 +1,4 @@
-import { DatabaseQuery, Datas, Key, ResultsMap } from "../index.js";
+import { DataQuery, ResultsMap, 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.
@@ -14,8 +14,8 @@ import { DatabaseQuery, Datas, Key, ResultsMap } 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<D extends Datas, C extends Key<D>>(ref: DatabaseQuery<C, D>, maxAge?: number | true): ResultsMap<D[C]> | PromiseLike<ResultsMap<D[C]>>;
-export declare function useAsyncQuery<D extends Datas, C extends Key<D>>(ref: DatabaseQuery<C, D> | undefined, maxAge?: number | true): ResultsMap<D[C]> | PromiseLike<ResultsMap<D[C]>> | undefined;
+export declare function useAsyncQuery<T extends Data>(ref: DataQuery<T>, maxAge?: number | true): ResultsMap<T> | PromiseLike<ResultsMap<T>>;
+export declare function useAsyncQuery<T extends Data>(ref: DataQuery<T> | undefined, maxAge?: number | true): ResultsMap<T> | PromiseLike<ResultsMap<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,5 +31,5 @@ export declare function useAsyncQuery<D extends Datas, C extends Key<D>>(ref: Da
  * @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 useResults<D extends Datas, C extends Key<D>>(ref: DatabaseQuery<C, D>, maxAge?: number | true): ResultsMap<D[C]>;
-export declare function useResults<D extends Datas, C extends Key<D>>(ref: DatabaseQuery<C, D> | undefined, maxAge?: number | true): ResultsMap<D[C]> | undefined;
+export declare function useResults<T extends Data>(ref: DataQuery<T>, maxAge?: number | true): ResultsMap<T>;
+export declare function useResults<T extends Data>(ref: DataQuery<T> | undefined, maxAge?: number | true): ResultsMap<T> | undefined;

package/react/useQuery.js

@@ -30,13 +30,13 @@ export function useAsyncQuery(ref, maxAge = 1000) {
 function getCachedResults(ref) {
     if (!ref)
         return undefined;
-    const provider = findSourceProvider(ref.db.provider, CacheProvider);
+    const provider = findSourceProvider(ref.provider, CacheProvider);
     return provider.isCached(ref) ? toMap(provider.cache.getQuery(ref)) : NOVALUE;
 }
 /** Effect that subscribes a component to the cache for a reference. */
 function subscribeEffect(ref, maxAge, next, error) {
     if (ref) {
-        const provider = findSourceProvider(ref.db.provider, CacheProvider);
+        const provider = findSourceProvider(ref.provider, CacheProvider);
         const observer = new DeriveObserver(toMap, { next, error });
         const stopCache = provider.cache.subscribeQuery(ref, observer);
         if (maxAge === true) {

package/util/validate.d.ts

@@ -24,12 +24,14 @@ export declare type ValidatorType<X extends AnyValidator> = X extends Validator<
 export declare const isValidator: <T extends AnyValidator>(v: unknown) => v is T;
 /** A set of named validators in `{ name: Validator }` format. */
 export declare type Validators<T extends Data> = {
-    readonly [K in keyof T]: Validator<T[K]>;
+    [K in keyof T]: Validator<T[K]>;
 };
 /** Any observer (useful for `extends AnyValidators` clauses). */
 export declare type AnyValidators = Validators<any>;
 /** Extract the type from a set of validators. */
-export declare type ValidatorsType<O extends AnyValidators> = O extends Validators<infer T> ? T : never;
+export declare type ValidatorsType<T extends AnyValidators> = {
+    [K in keyof T]: ValidatorType<T[K]>;
+};
 /** Validate an unknown value with a validator. */
 export declare function validate<T>(unsafeValue: unknown, validator: Validator<T>): T;
 /**