shelving 1.89.2 → 1.89.4

package/db/Item.js

@@ -1,20 +1,30 @@
-import { getData } from "../util/data.js";
-import { runSequence } from "../util/sequence.js";
+import { QueryConstraints } from "../constraint/QueryConstraints.js";
 import { FilterConstraint } from "../constraint/FilterConstraint.js";
 import { FilterConstraints } from "../constraint/FilterConstraints.js";
+import { getData } from "../util/data.js";
+import { runSequence } from "../util/sequence.js";
+/** Get the ID from item data. */
+export const getID = ({ id }) => id;
+/** Get the IDs of an iterable set item data. */
+export function* getIDs(entities) {
+    for (const { id } of entities)
+        yield id;
+}
+/** Get a `FilterConstraints` instance that targets a single item by its ID. */
+export const getItemConstraints = (id) => new QueryConstraints(new FilterConstraints(new FilterConstraint("id", id)), undefined, 1);
 /** Reference to an item in a synchronous or asynchronous database. */
 class BaseItem {
     /** Get a set change for this item. */
     getSet(data) {
-        return this.db.getSet(this.collection, this.id, data);
+        return { action: "SET", collection: this.collection, id: this.id, data };
     }
     /** Get an update change for this item. */
     getUpdate(updates) {
-        return this.db.getUpdate(this.collection, this.id, updates);
+        return { action: "UPDATE", collection: this.collection, id: this.id, updates };
     }
     /** Get a delete change for this item. */
     getDelete() {
-        return this.db.getDelete(this.collection, this.id);
+        return { action: "DELETE", collection: this.collection, id: this.id };
     }
     // Implement toString()
     toString() {
@@ -26,77 +36,60 @@ class BaseItem {
     }
     // Implement AsyncIterable
     [Symbol.asyncIterator]() {
-        return this.db.provider.getItemSequence(this.collection, this.id)[Symbol.asyncIterator]();
+        return this.provider.getItemSequence(this.collection, this.id)[Symbol.asyncIterator]();
     }
 }
 /** Reference to an item in a synchronous database. */
 export class Item extends BaseItem {
-    constructor(db, collection, id) {
+    constructor(provider, collection, id) {
         super();
-        this.db = db;
+        this.provider = provider;
         this.collection = collection;
         this.id = id;
     }
-    get optional() {
-        return this.db.query(this.collection, getItemFilterConstraints(this.id), undefined, 1);
-    }
     get exists() {
-        return !!this.db.get(this.collection, this.id);
+        return !!this.provider.getItem(this.collection, this.id);
     }
     get value() {
-        return this.db.get(this.collection, this.id);
+        return this.provider.getItem(this.collection, this.id);
     }
     get data() {
         return getData(this.value);
     }
     set(data) {
-        return this.db.set(this.collection, this.id, data);
+        return this.provider.setItem(this.collection, this.id, data);
     }
     update(updates) {
-        return this.db.update(this.collection, this.id, updates);
+        return this.provider.updateItem(this.collection, this.id, updates);
     }
     delete() {
-        return this.db.delete(this.collection, this.id);
+        return this.provider.deleteItem(this.collection, this.id);
     }
 }
 /** Reference to an item in an asynchronous database. */
 export class AsyncItem extends BaseItem {
-    constructor(db, collection, id) {
+    constructor(provider, collection, id) {
         super();
-        this.db = db;
+        this.provider = provider;
         this.collection = collection;
         this.id = id;
     }
-    get optional() {
-        return this.db.query(this.collection, { id: this.id }, undefined, 1);
-    }
     get exists() {
-        return this.db.get(this.collection, this.id).then(Boolean);
+        return this.provider.getItem(this.collection, this.id).then(Boolean);
     }
     get value() {
-        return this.db.get(this.collection, this.id);
+        return this.provider.getItem(this.collection, this.id);
     }
     get data() {
         return this.value.then(getData);
     }
     set(data) {
-        return this.db.set(this.collection, this.id, data);
+        return this.provider.setItem(this.collection, this.id, data);
     }
     update(updates) {
-        return this.db.update(this.collection, this.id, updates);
+        return this.provider.updateItem(this.collection, this.id, updates);
     }
     delete() {
-        return this.db.delete(this.collection, this.id);
+        return this.provider.deleteItem(this.collection, this.id);
     }
 }
-/** Get the ID from item data. */
-export const getID = ({ id }) => id;
-/** Get the IDs of an iterable set item data. */
-export function* getIDs(entities) {
-    for (const { id } of entities)
-        yield id;
-}
-/** Get a `FilterConstraints` instance that targets a single item by its ID. */
-export function getItemFilterConstraints(id) {
-    return new FilterConstraints(new FilterConstraint("id", id));
-}

package/db/ItemState.d.ts

@@ -1,17 +1,17 @@
-import { DataKey, Datas } from "../util/data.js";
+import { Data } from "../util/data.js";
 import { Dispatch } from "../util/function.js";
 import { State } from "../state/State.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { ItemValue, Item, AsyncItem, ItemData } from "./Item.js";
 /** Hold the current state of a item. */
-export declare class ItemState<T extends Datas, K extends DataKey<T> = DataKey<T>> extends State<ItemValue<T[K]>> {
-    readonly ref: Item<T, K> | AsyncItem<T, K>;
+export declare class ItemState<T extends Data = Data> extends State<ItemValue<T>> {
+    readonly ref: Item<T> | AsyncItem<T>;
     readonly busy: BooleanState;
     /** Get the data of the item (throws `RequiredError` if item doesn't exist). */
-    get data(): ItemData<T[K]>;
+    get data(): ItemData<T>;
     /** Does the item exist (i.e. its value isn't `null`)? */
     get exists(): boolean;
-    constructor(ref: Item<T, K> | AsyncItem<T, K>);
+    constructor(ref: Item<T> | AsyncItem<T>);
     /** Refresh this state from the source provider. */
     readonly refresh: () => void;
     private _refresh;

package/db/ItemState.js

@@ -15,9 +15,9 @@ export class ItemState extends State {
         return !!this.value;
     }
     constructor(ref) {
-        const { db, collection, id } = ref;
-        const cache = getOptionalSource(CacheProvider, db.provider);
-        const table = cache === null || cache === void 0 ? void 0 : cache.memory.getTable(collection);
+        var _a;
+        const { provider, collection, id } = ref;
+        const table = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(collection);
         const time = table ? table.getItemTime(id) : null;
         const isCached = typeof time === "number";
         super(table && isCached ? table.getItem(id) : State.NOVALUE, table ? new LazyDeferredSequence(() => this.from(table.getCachedItemSequence(id))) : undefined);

package/db/Query.d.ts

@@ -1,20 +1,20 @@
-import type { DataKey, Datas } from "../util/data.js";
+import type { Data } from "../util/data.js";
 import type { Dispatch, Handler, Stop } from "../util/function.js";
 import type { Updates } from "../update/DataUpdate.js";
 import type { FilterList } from "../constraint/FilterConstraint.js";
 import type { SortList } from "../constraint/SortConstraint.js";
+import type { Provider, AsyncProvider } from "../provider/Provider.js";
 import { QueryConstraints } from "../constraint/QueryConstraints.js";
 import type { ItemArray, ItemValue, ItemData } from "./Item.js";
-import type { AsyncDatabase, Database } from "./Database.js";
 /** Reference to a set of items in a sync or async provider. */
-declare abstract class BaseQuery<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends QueryConstraints<ItemData<T[K]>> implements AsyncIterable<ItemArray<T[K]>> {
-    abstract readonly db: Database<T> | AsyncDatabase<T>;
-    abstract readonly collection: K;
+declare abstract class BaseQuery<T extends Data = Data> extends QueryConstraints<ItemData<T>> implements AsyncIterable<ItemArray<T>> {
+    abstract readonly provider: Provider | AsyncProvider;
+    abstract readonly collection: string;
     /**
      * Get array of entities for this query.
      * @return Array of entities.
      */
-    abstract value: ItemArray<T[K]> | PromiseLike<ItemArray<T[K]>>;
+    abstract value: ItemArray<T> | PromiseLike<ItemArray<T>>;
     /**
      * Count the number of results of this set of items.
      * @return Number of items matching the query (possibly promised).
@@ -29,36 +29,36 @@ declare abstract class BaseQuery<T extends Datas = Datas, K extends DataKey<T> =
      * Get the first item matched by this query or `null` if this query has no results.
      * @throws RequiredError if there were no results for this query.
      */
-    abstract firstValue: ItemValue<T[K]> | PromiseLike<ItemValue<T[K]>>;
+    abstract firstValue: ItemValue<T> | PromiseLike<ItemValue<T>>;
     /**
      * Get the first item matched by this query.
      * @throws RequiredError if there were no results for this query.
      */
-    abstract firstData: ItemData<T[K]> | PromiseLike<ItemData<T[K]>>;
+    abstract firstData: ItemData<T> | PromiseLike<ItemData<T>>;
     /**
      * Get the last item matched by this query or `null` if this query has no results.
      * @throws RequiredError if there were no results for this query.
      */
-    abstract lastValue: ItemValue<T[K]> | PromiseLike<ItemValue<T[K]>>;
+    abstract lastValue: ItemValue<T> | PromiseLike<ItemValue<T>>;
     /**
      * Get the last item matched by this query.
      * @throws RequiredError if there were no results for this query.
      */
-    abstract lastData: ItemData<T[K]> | PromiseLike<ItemData<T[K]>>;
+    abstract lastData: ItemData<T> | PromiseLike<ItemData<T>>;
     /**
      * Set all matching items to the same exact value.
      *
      * @param data Complete data to set the item to.
      * @return Nothing (possibly promised).
      */
-    abstract set(data: T[K]): number | PromiseLike<number>;
+    abstract set(data: T): number | PromiseLike<number>;
     /**
      * Update all matching items with the same partial value.
      *
      * @param updates `Update` instance or set of updates to apply to every matching item.
      * @return Nothing (possibly promised).
      */
-    abstract update(updates: Updates<T[K]>): number | PromiseLike<number>;
+    abstract update(updates: Updates<T>): number | PromiseLike<number>;
     /**
      * Delete all matching items.
      * @return Nothing (possibly promised).
@@ -66,39 +66,39 @@ declare abstract class BaseQuery<T extends Datas = Datas, K extends DataKey<T> =
     abstract delete(): number | PromiseLike<number>;
     toString(): string;
     /** Subscribe to this item. */
-    subscribe(onNext?: Dispatch<[ItemArray<T[K]>]>, onError?: Handler): Stop;
-    [Symbol.asyncIterator](): AsyncIterator<ItemArray<T[K]>>;
+    subscribe(onNext?: Dispatch<[ItemArray<T>]>, onError?: Handler): Stop;
+    [Symbol.asyncIterator](): AsyncIterator<ItemArray<T>>;
 }
 /** Reference to a set of items in a provider. */
-export declare class Query<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseQuery<T, K> {
-    readonly db: Database<T>;
-    readonly collection: K;
-    constructor(db: Database<T>, collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null);
-    get value(): ItemArray<T[K]>;
+export declare class Query<T extends Data = Data> extends BaseQuery<T> {
+    readonly provider: Provider;
+    readonly collection: string;
+    constructor(provider: Provider, collection: string, filters?: FilterList<ItemData<T>>, sorts?: SortList<ItemData<T>>, limit?: number | null);
+    get value(): ItemArray<T>;
     get count(): number;
     get exists(): boolean;
-    get firstValue(): ItemValue<T[K]>;
-    get firstData(): ItemData<T[K]>;
-    get lastValue(): ItemValue<T[K]>;
-    get lastData(): ItemData<T[K]>;
-    set(data: T[K]): number;
-    update(updates: Updates<T[K]>): number;
+    get firstValue(): ItemValue<T>;
+    get firstData(): ItemData<T>;
+    get lastValue(): ItemValue<T>;
+    get lastData(): ItemData<T>;
+    set(data: T): number;
+    update(updates: Updates<T>): number;
     delete(): number;
 }
 /** Reference to a set of items in a provider. */
-export declare class AsyncQuery<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseQuery<T, K> {
-    readonly db: AsyncDatabase<T>;
-    readonly collection: K;
-    constructor(db: AsyncDatabase<T>, collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null);
-    get value(): Promise<ItemArray<T[K]>>;
+export declare class AsyncQuery<T extends Data = Data> extends BaseQuery<T> {
+    readonly provider: AsyncProvider;
+    readonly collection: string;
+    constructor(provider: AsyncProvider, collection: string, filters?: FilterList<ItemData<T>>, sorts?: SortList<ItemData<T>>, limit?: number | null);
+    get value(): Promise<ItemArray<T>>;
     get count(): Promise<number>;
     get exists(): Promise<boolean>;
-    get firstValue(): Promise<ItemValue<T[K]>>;
-    get firstData(): Promise<ItemData<T[K]>>;
-    get lastValue(): Promise<ItemValue<T[K]>>;
-    get lastData(): Promise<ItemData<T[K]>>;
-    set(data: T[K]): Promise<number>;
-    update(updates: Updates<T[K]>): PromiseLike<number>;
+    get firstValue(): Promise<ItemValue<T>>;
+    get firstData(): Promise<ItemData<T>>;
+    get lastValue(): Promise<ItemValue<T>>;
+    get lastData(): Promise<ItemData<T>>;
+    set(data: T): Promise<number>;
+    update(updates: Updates<T>): PromiseLike<number>;
     delete(): PromiseLike<number>;
 }
 export {};

package/db/Query.js

@@ -13,18 +13,18 @@ class BaseQuery extends QueryConstraints {
     }
     // Implement AsyncIterable
     [Symbol.asyncIterator]() {
-        return this.db.provider.getQuerySequence(this.collection, this)[Symbol.asyncIterator]();
+        return this.provider.getQuerySequence(this.collection, this)[Symbol.asyncIterator]();
     }
 }
 /** Reference to a set of items in a provider. */
 export class Query extends BaseQuery {
-    constructor(db, collection, filters, sorts, limit) {
+    constructor(provider, collection, filters, sorts, limit) {
         super(filters, sorts, limit);
-        this.db = db;
+        this.provider = provider;
         this.collection = collection;
     }
     get value() {
-        return this.db.provider.getQuery(this.collection, this);
+        return this.provider.getQuery(this.collection, this);
     }
     get count() {
         return this.value.length;
@@ -45,24 +45,24 @@ export class Query extends BaseQuery {
         return getLastItem(this.value);
     }
     set(data) {
-        return this.db.provider.setQuery(this.collection, this, data);
+        return this.provider.setQuery(this.collection, this, data);
     }
     update(updates) {
-        return this.db.provider.updateQuery(this.collection, this, updates);
+        return this.provider.updateQuery(this.collection, this, updates);
     }
     delete() {
-        return this.db.provider.deleteQuery(this.collection, this);
+        return this.provider.deleteQuery(this.collection, this);
     }
 }
 /** Reference to a set of items in a provider. */
 export class AsyncQuery extends BaseQuery {
-    constructor(db, collection, filters, sorts, limit) {
+    constructor(provider, collection, filters, sorts, limit) {
         super(filters, sorts, limit);
-        this.db = db;
+        this.provider = provider;
         this.collection = collection;
     }
     get value() {
-        return this.db.provider.getQuery(this.collection, this);
+        return this.provider.getQuery(this.collection, this);
     }
     get count() {
         return this.value.then(countArray);
@@ -83,12 +83,12 @@ export class AsyncQuery extends BaseQuery {
         return this.value.then(getLastItem);
     }
     set(data) {
-        return this.db.provider.setQuery(this.collection, this, data);
+        return this.provider.setQuery(this.collection, this, data);
     }
     update(updates) {
-        return this.db.provider.updateQuery(this.collection, this, updates);
+        return this.provider.updateQuery(this.collection, this, updates);
     }
     delete() {
-        return this.db.provider.deleteQuery(this.collection, this);
+        return this.provider.deleteQuery(this.collection, this);
     }
 }

package/db/QueryState.d.ts

@@ -1,30 +1,30 @@
-import type { Datas, DataKey } from "../util/data.js";
+import type { Data } from "../util/data.js";
 import type { Stop } from "../util/function.js";
 import type { ItemArray, ItemValue, ItemData } from "../db/Item.js";
 import type { AsyncQuery, Query } from "../db/Query.js";
 import { State } from "../state/State.js";
 import { BooleanState } from "../state/BooleanState.js";
 /** Hold the current state of a query. */
-export declare class QueryState<T extends Datas, K extends DataKey<T> = DataKey<T>> extends State<ItemArray<T[K]>> implements Iterable<ItemData<T[K]>> {
-    readonly ref: Query<T, K> | AsyncQuery<T, K>;
+export declare class QueryState<T extends Data = Data> extends State<ItemArray<T>> implements Iterable<ItemData<T>> {
+    readonly ref: Query<T> | AsyncQuery<T>;
     readonly busy: BooleanState;
     readonly limit: number;
     /** Can more items be loaded after the current result. */
     get hasMore(): boolean;
     private _hasMore;
     /** Get the first document matched by this query or `null` if this query has no items. */
-    get firstValue(): ItemValue<T[K]>;
+    get firstValue(): ItemValue<T>;
     /** Get the first document matched by this query. */
-    get firstData(): ItemData<T[K]>;
+    get firstData(): ItemData<T>;
     /** Get the last document matched by this query or `null` if this query has no items. */
-    get lastValue(): ItemValue<T[K]>;
+    get lastValue(): ItemValue<T>;
     /** Get the last document matched by this query. */
-    get lastData(): ItemData<T[K]>;
+    get lastData(): ItemData<T>;
     /** Does the document have at least one result. */
     get exists(): boolean;
     /** Get the number of items matching this query. */
     get count(): number;
-    constructor(ref: Query<T, K> | AsyncQuery<T, K>);
+    constructor(ref: Query<T> | AsyncQuery<T>);
     /** Refresh this state from the source provider. */
     readonly refresh: () => void;
     private _refresh;
@@ -39,5 +39,5 @@ export declare class QueryState<T extends Datas, K extends DataKey<T> = DataKey<
     readonly loadMore: () => void;
     private _loadMore;
     /** Iterate over the items. */
-    [Symbol.iterator](): Iterator<ItemData<T[K]>>;
+    [Symbol.iterator](): Iterator<ItemData<T>>;
 }

package/db/QueryState.js

@@ -35,9 +35,9 @@ export class QueryState extends State {
         return this.value.length;
     }
     constructor(ref) {
-        const { db, collection, limit } = ref;
-        const cache = getOptionalSource(CacheProvider, db.provider);
-        const table = cache === null || cache === void 0 ? void 0 : cache.memory.getTable(collection);
+        var _a;
+        const { provider, collection, limit } = ref;
+        const table = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(collection);
         const time = table ? table.getQueryTime(ref) : null;
         const isCached = typeof time === "number";
         super(table && isCached ? table.getQuery(ref) : State.NOVALUE, table ? new LazyDeferredSequence(() => this.from(table.getCachedQuerySequence(ref))) : undefined);

package/firestore/client/FirestoreClientProvider.d.ts

@@ -13,13 +13,13 @@ export declare class FirestoreClientProvider implements AsyncProvider {
     private readonly _firestore;
     constructor(firestore: Firestore);
     getItem(collection: string, id: string): Promise<ItemValue>;
-    getItemSequence<K extends string>(collection: K, id: string): AsyncIterable<ItemValue>;
+    getItemSequence(collection: string, id: string): AsyncIterable<ItemValue>;
     addItem(collection: string, data: Data): Promise<string>;
     setItem(collection: string, id: string, data: Data): Promise<void>;
     updateItem(collection: string, id: string, updates: Updates): Promise<void>;
     deleteItem(collection: string, id: string): Promise<void>;
     getQuery(collection: string, constraints: ItemConstraints): Promise<ItemArray>;
-    getQuerySequence<K extends string>(collection: K, constraints: ItemConstraints): AsyncIterable<ItemArray>;
+    getQuerySequence(collection: string, constraints: ItemConstraints): AsyncIterable<ItemArray>;
     setQuery(collection: string, constraints: ItemConstraints, data: Data): Promise<number>;
     updateQuery(collection: string, constraints: ItemConstraints, updates: Updates): Promise<number>;
     deleteQuery(collection: string, constraints: ItemConstraints): Promise<number>;

package/package.json

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

package/provider/CacheProvider.d.ts

@@ -1,23 +1,23 @@
-import type { Datas, DataKey } from "../util/data.js";
+import type { Data } from "../util/data.js";
 import type { ItemArray, ItemValue, ItemConstraints } from "../db/Item.js";
 import type { Updates } from "../update/DataUpdate.js";
 import type { AsyncProvider } from "./Provider.js";
 import type { AsyncThroughProvider } from "./ThroughProvider.js";
 import { MemoryProvider } from "./MemoryProvider.js";
 /** Keep a copy of asynchronous remote data in a local synchronous cache. */
-export declare class CacheProvider<T extends Datas> implements AsyncThroughProvider<T> {
-    readonly source: AsyncProvider<T>;
-    readonly memory: MemoryProvider<T>;
-    constructor(source: AsyncProvider<T>, cache?: MemoryProvider<T>);
-    getItem<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterableIterator<ItemValue<T[K]>>;
-    addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
-    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    deleteItem<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
-    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
-    getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterableIterator<ItemArray<T[K]>>;
-    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
-    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
+export declare class CacheProvider implements AsyncThroughProvider {
+    readonly source: AsyncProvider;
+    readonly memory: MemoryProvider;
+    constructor(source: AsyncProvider, cache?: MemoryProvider);
+    getItem(collection: string, id: string): Promise<ItemValue>;
+    getItemSequence(collection: string, id: string): AsyncIterableIterator<ItemValue>;
+    addItem(collection: string, data: Data): Promise<string>;
+    setItem(collection: string, id: string, data: Data): Promise<void>;
+    updateItem(collection: string, id: string, updates: Updates): Promise<void>;
+    deleteItem(collection: string, id: string): Promise<void>;
+    getQuery(collection: string, constraints: ItemConstraints): Promise<ItemArray>;
+    getQuerySequence(collection: string, constraints: ItemConstraints): AsyncIterableIterator<ItemArray>;
+    setQuery(collection: string, constraints: ItemConstraints, data: Data): Promise<number>;
+    updateQuery(collection: string, constraints: ItemConstraints, updates: Updates): Promise<number>;
+    deleteQuery(collection: string, constraints: ItemConstraints): Promise<number>;
 }

package/provider/DebugProvider.d.ts

@@ -1,40 +1,40 @@
-import type { Datas, DataKey } from "../util/data.js";
+import type { Data } from "../util/data.js";
 import type { ItemArray, ItemConstraints, ItemValue } from "../db/Item.js";
 import type { Updates } from "../update/DataUpdate.js";
 import { Provider, AsyncProvider } from "./Provider.js";
 import type { ThroughProvider, AsyncThroughProvider } from "./ThroughProvider.js";
 /** Provider that logs operations to a source provider to the console. */
-declare abstract class AbstractDebugProvider<T extends Datas> {
-    abstract readonly source: Provider<T> | AsyncProvider<T>;
-    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterableIterator<ItemValue<T[K]>>;
-    getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterableIterator<ItemArray<T[K]>>;
+declare abstract class AbstractDebugProvider {
+    abstract readonly source: Provider | AsyncProvider;
+    getItemSequence(collection: string, id: string): AsyncIterableIterator<ItemValue>;
+    getQuerySequence(collection: string, constraints: ItemConstraints): AsyncIterableIterator<ItemArray>;
 }
 /** Provider that logs operations to a synchronous source provider to the console. */
-export declare class DebugProvider<T extends Datas> extends AbstractDebugProvider<T> implements ThroughProvider<T> {
-    readonly source: Provider<T>;
-    constructor(source: Provider<T>);
-    getItem<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
-    addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
-    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
-    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
-    deleteItem<K extends DataKey<T>>(collection: K, id: string): void;
-    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
-    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
-    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
+export declare class DebugProvider extends AbstractDebugProvider implements ThroughProvider {
+    readonly source: Provider;
+    constructor(source: Provider);
+    getItem(collection: string, id: string): ItemValue;
+    addItem(collection: string, data: Data): string;
+    setItem(collection: string, id: string, data: Data): void;
+    updateItem(collection: string, id: string, updates: Updates): void;
+    deleteItem(collection: string, id: string): void;
+    getQuery(collection: string, constraints: ItemConstraints): ItemArray;
+    setQuery(collection: string, constraints: ItemConstraints, data: Data): number;
+    updateQuery(collection: string, constraints: ItemConstraints, updates: Updates): number;
+    deleteQuery(collection: string, constraints: ItemConstraints): number;
 }
 /** Provider that logs operations to a synchronous source provider to the console. */
-export declare class AsyncDebugProvider<T extends Datas> extends AbstractDebugProvider<T> implements AsyncThroughProvider<T> {
-    readonly source: AsyncProvider<T>;
-    constructor(source: AsyncProvider<T>);
-    getItem<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
-    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    deleteItem<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
-    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
-    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
-    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
+export declare class AsyncDebugProvider extends AbstractDebugProvider implements AsyncThroughProvider {
+    readonly source: AsyncProvider;
+    constructor(source: AsyncProvider);
+    getItem(collection: string, id: string): Promise<ItemValue>;
+    addItem(collection: string, data: Data): Promise<string>;
+    setItem(collection: string, id: string, data: Data): Promise<void>;
+    updateItem(collection: string, id: string, updates: Updates): Promise<void>;
+    deleteItem(collection: string, id: string): Promise<void>;
+    getQuery(collection: string, constraints: ItemConstraints): Promise<ItemArray>;
+    setQuery(collection: string, constraints: ItemConstraints, data: Data): Promise<number>;
+    updateQuery(collection: string, constraints: ItemConstraints, updates: Updates): Promise<number>;
+    deleteQuery(collection: string, constraints: ItemConstraints): Promise<number>;
 }
 export {};