shelving 1.82.0 → 1.82.1

package/constraint/Constraints.js

@@ -1,4 +1,4 @@
-import { withItems, withoutItems } from "../util/array.js";
+import { withArrayItems, withoutArrayItems } from "../util/array.js";
 import { Constraint } from "./Constraint.js";
 /** Type of Rule that is powered by several sub-constraints (e.g. `Filters` and `Sorts` and `Query` itself extend this). */
 export class Constraints extends Constraint {
@@ -20,12 +20,12 @@ export class Constraints extends Constraint {
     }
     /** Clone this set of constraints but add additional constraints. */
     with(...constraints) {
-        const _constraints = withItems(this._constraints, ...constraints);
+        const _constraints = withArrayItems(this._constraints, ...constraints);
         return _constraints !== this._constraints ? { __proto__: Object.getPrototypeOf(this), ...this, _constraints: _constraints } : this;
     }
     /** Clone this set of constraints but remove specific constraints. */
     without(...constraints) {
-        const _constraints = withoutItems(this._constraints, ...constraints);
+        const _constraints = withoutArrayItems(this._constraints, ...constraints);
         return _constraints !== this._constraints ? { __proto__: Object.getPrototypeOf(this), ...this, _constraints: _constraints } : this;
     }
     /** Iterate over the constraints. */

package/constraint/FilterConstraint.d.ts

@@ -1,4 +1,4 @@
-import type { Data, Key } from "../util/data.js";
+import type { Data, DataKey } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
 import { ImmutableArray } from "../util/array.js";
 import { Matchable } from "../util/match.js";
@@ -6,14 +6,14 @@ import type { Constraint } from "./Constraint.js";
 /** Possible operator references. */
 export declare type FilterOperator = "IS" | "NOT" | "IN" | "OUT" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
 /** Format that allows filters to be specified as a string, e.g. `!name` means `name is not` and `age>` means `age is more than` and `tags[]` means `tags array contains` */
-export declare type FilterKey<T extends Data> = Key<T> | `${Key<T>}` | `!${Key<T>}` | `${Key<T>}[]` | `${Key<T>}<` | `${Key<T>}<=` | `${Key<T>}>` | `${Key<T>}>=`;
+export declare type FilterKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}` | `${DataKey<T>}[]` | `${DataKey<T>}<` | `${DataKey<T>}<=` | `${DataKey<T>}>` | `${DataKey<T>}>=`;
 /** Format that allows multiple filters to be specified as a plain object. */
 export declare type FilterProps<T extends Data> = {
-    [K in Key<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
+    [K in DataKey<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
 } & {
-    [K in Key<T> as `${K}[]`]?: Required<T>[K] extends ImmutableArray<infer X> ? X : never;
+    [K in DataKey<T> as `${K}[]`]?: Required<T>[K] extends ImmutableArray<infer X> ? X : never;
 } & {
-    [K in Key<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
+    [K in DataKey<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
 };
 /** List of filters in a flexible format. */
 export declare type FilterList<T extends Data> = Nullish<FilterProps<T> | FilterConstraint<T>> | Iterable<FilterList<T>>;

package/constraint/QueryConstraints.js

@@ -1,4 +1,4 @@
-import { getProp } from "../util/object.js";
+import { getObjectProp } from "../util/object.js";
 import { assert } from "../util/assert.js";
 import { limitItems } from "../util/iterate.js";
 import { FilterConstraints } from "./FilterConstraints.js";
@@ -96,7 +96,7 @@ function* _getAfterFilters(sorts, item) {
     for (const sort of sorts) {
         const { key, direction } = sort;
         const filterKey = direction === "ASC" ? (sort === lastSort ? `${key}>` : `${key}>=`) : sort === lastSort ? `${key}<` : `${key}<=`;
-        yield new FilterConstraint(filterKey, getProp(item, key));
+        yield new FilterConstraint(filterKey, getObjectProp(item, key));
     }
 }
 function* _getBeforeFilters(sorts, item) {
@@ -105,6 +105,6 @@ function* _getBeforeFilters(sorts, item) {
     for (const sort of sorts) {
         const { key, direction } = sort;
         const filterKey = direction === "ASC" ? (sort === lastSort ? `${key}<` : `${key}<=`) : sort === lastSort ? `${key}>` : `${key}>=`;
-        yield new FilterConstraint(filterKey, getProp(item, key));
+        yield new FilterConstraint(filterKey, getObjectProp(item, key));
     }
 }

package/constraint/SortConstraint.d.ts

@@ -1,10 +1,10 @@
 import type { ImmutableArray } from "../util/array.js";
-import type { Data, Key } from "../util/data.js";
+import type { Data, DataKey } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
 import { Rankable } from "../util/sort.js";
 import type { Constraint } from "./Constraint.js";
 /** Format that allows sorts to be set as a plain string, e.g. `name` sorts by name in ascending order and `!date` sorts by date in descending order. */
-export declare type SortKey<T extends Data> = Key<T> | `${Key<T>}` | `!${Key<T>}`;
+export declare type SortKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}`;
 /** One or more sort keys. */
 export declare type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
 /** Possible operator references. */

package/db/Change.d.ts

@@ -1,4 +1,4 @@
-import type { Data, Datas, Key } from "../util/data.js";
+import type { Data, Datas, DataKey } from "../util/data.js";
 import type { ImmutableArray } from "../util/array.js";
 import type { Provider, AsyncProvider } from "../provider/Provider.js";
 import { Updates } from "../update/DataUpdate.js";
@@ -6,42 +6,42 @@ import { Nullish } from "../util/null.js";
 import { DeepIterable } from "../util/iterate.js";
 import type { ItemConstraints, ItemData } from "./Item.js";
 /** Change on a collection. */
-export interface Change<T extends Datas, K extends Key<T> = Key<T>> {
+export interface Change<T extends Datas, K extends DataKey<T> = DataKey<T>> {
     readonly action: string;
     readonly collection: K;
 }
 /** Add on an item. */
-export interface AddChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T, K> {
+export interface AddChange<T extends Datas, K extends DataKey<T> = DataKey<T>> extends Change<T, K> {
     readonly action: "ADD";
     readonly data: T[K];
 }
 /** Set on an item. */
-export interface SetChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T, K> {
+export interface SetChange<T extends Datas, K extends DataKey<T> = DataKey<T>> extends Change<T, K> {
     readonly action: "SET";
     readonly id: string;
     readonly data: T[K];
 }
 /** Update change on an item. */
-export interface UpdateChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T, K> {
+export interface UpdateChange<T extends Datas, K extends DataKey<T> = DataKey<T>> extends Change<T, K> {
     readonly action: "UPDATE";
     readonly id: string;
     readonly updates: Updates<T[K]>;
 }
 /** Delete change on an item. */
-export interface DeleteChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T, K> {
+export interface DeleteChange<T extends Datas, K extends DataKey<T> = DataKey<T>> extends Change<T, K> {
     readonly action: "DELETE";
     readonly id: string;
 }
 /** Set, update, or delete change on an item. */
-export declare type ItemChange<T extends Datas, K extends Key<T> = Key<T>> = SetChange<T, K> | UpdateChange<T, K> | DeleteChange<T, K>;
+export declare type ItemChange<T extends Datas, K extends DataKey<T> = DataKey<T>> = SetChange<T, K> | UpdateChange<T, K> | DeleteChange<T, K>;
 /** Array of item changes. */
-export declare type ItemChanges<T extends Datas, K extends Key<T> = Key<T>> = ImmutableArray<ItemChange<T, K>>;
+export declare type ItemChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = ImmutableArray<ItemChange<T, K>>;
 /** Write change on an item. */
-export declare type WriteChange<T extends Datas, K extends Key<T> = Key<T>> = ItemChange<T, K> | AddChange<T, K>;
+export declare type WriteChange<T extends Datas, K extends DataKey<T> = DataKey<T>> = ItemChange<T, K> | AddChange<T, K>;
 /** Array of write changes. */
-export declare type WriteChanges<T extends Datas, K extends Key<T> = Key<T>> = ImmutableArray<WriteChange<T, K>>;
+export declare type WriteChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = ImmutableArray<WriteChange<T, K>>;
 /** Apply a set of changes to a synchronous provider. */
-export declare function changeProvider<T extends Datas, K extends Key<T>>(provider: Provider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K>;
+export declare function changeProvider<T extends Datas, K extends DataKey<T>>(provider: Provider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K>;
 /** Apply a set of changes to an asynchronous provider. */
-export declare function changeAsyncProvider<T extends Datas, K extends Key<T>>(provider: AsyncProvider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): Promise<ItemChanges<T, K>>;
+export declare function changeAsyncProvider<T extends Datas, K extends DataKey<T>>(provider: AsyncProvider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): Promise<ItemChanges<T, K>>;
 export declare function _getItemConstraint<T extends Data>(id: string): ItemConstraints<ItemData<T>>;

package/db/Collection.d.ts

@@ -1,4 +1,4 @@
-import type { Datas, Key } from "../util/data.js";
+import type { Datas, DataKey } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
 import type { FilterList } from "../constraint/FilterConstraint.js";
 import type { SortList } from "../constraint/SortConstraint.js";
@@ -9,7 +9,7 @@ import { ItemData, AsyncItem, Item, ItemValue } from "./Item.js";
 import { AsyncQuery, Query } from "./Query.js";
 import { AddChange, ItemChanges, WriteChange, UpdateChange, DeleteChange, SetChange } from "./Change.js";
 /** Reference to a collection in a synchronous or asynchronous provider. */
-declare abstract class BaseCollection<T extends Datas = Datas, K extends Key<T> = Key<T>> {
+declare abstract class BaseCollection<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> {
     abstract readonly db: Database<T> | AsyncDatabase<T>;
     abstract readonly collection: K;
     /** Create a query on this item's collection. */
@@ -39,7 +39,7 @@ declare abstract class BaseCollection<T extends Datas = Datas, K extends Key<T>
     toString(): K;
 }
 /** Reference to a collection in a synchronous provider. */
-export declare class Collection<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseCollection<T, K> {
+export declare class Collection<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseCollection<T, K> {
     readonly db: Database<T>;
     readonly collection: K;
     constructor(db: Database<T>, collection: K);
@@ -53,7 +53,7 @@ export declare class Collection<T extends Datas = Datas, K extends Key<T> = Key<
     delete(id: string): void;
 }
 /** Reference to a collection in an asynchronous provider. */
-export declare class AsyncCollection<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseCollection<T, K> {
+export declare class AsyncCollection<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseCollection<T, K> {
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
     constructor(db: AsyncDatabase<T>, collection: K);

package/db/Database.d.ts

@@ -1,4 +1,4 @@
-import type { Key, Datas } from "../util/data.js";
+import type { DataKey, Datas } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
 import type { DeepIterable } from "../util/iterate.js";
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
@@ -14,58 +14,58 @@ import { AddChange, DeleteChange, ItemChanges, SetChange, UpdateChange, WriteCha
 declare abstract class BaseDatabase<T extends Datas> {
     abstract readonly provider: Provider<T> | AsyncProvider<T>;
     /** Create a query on a collection in this database. */
-    abstract collection<K extends Key<T>>(collection: K): Collection<T, K> | AsyncCollection<T, K>;
+    abstract collection<K extends DataKey<T>>(collection: K): Collection<T, K> | AsyncCollection<T, K>;
     /** Create a query on a collection in this database. */
-    abstract query<K extends Key<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K> | AsyncQuery<T, K>;
+    abstract query<K extends DataKey<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K> | AsyncQuery<T, K>;
     /** Reference an item in a collection in this database. */
-    abstract item<K extends Key<T>>(collection: K, id: string): Item<T, K> | AsyncItem<T, K>;
+    abstract item<K extends DataKey<T>>(collection: K, id: string): Item<T, K> | AsyncItem<T, K>;
     /** Run a set of changes in this database. */
     abstract change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): ItemChanges<T> | Promise<ItemChanges<T>>;
     /** Get a document from a collection in this database. */
-    abstract get<K extends Key<T>>(collection: K, id: string): ItemValue<T[K]> | Promise<ItemValue<T[K]>>;
+    abstract get<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]> | Promise<ItemValue<T[K]>>;
     /** Add a document to a collection in this database. */
-    abstract add<K extends Key<T>>(collection: K, data: T[K]): string | Promise<string>;
+    abstract add<K extends DataKey<T>>(collection: K, data: T[K]): string | Promise<string>;
     /** Set a document in a collection in this database. */
-    abstract set<K extends Key<T>>(collection: K, id: string, data: T[K]): void | Promise<void>;
+    abstract set<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void | Promise<void>;
     /** Update a document in a collection in this database. */
-    abstract update<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void | Promise<void>;
+    abstract update<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void | Promise<void>;
     /** Delete a document from a collection in this database. */
-    abstract delete<K extends Key<T>>(collection: K, id: string): void | Promise<void>;
+    abstract delete<K extends DataKey<T>>(collection: K, id: string): void | Promise<void>;
     /** Get an add change for a collection in this database. */
-    getAdd<K extends Key<T>>(collection: K, data: T[K]): AddChange<T, K>;
+    getAdd<K extends DataKey<T>>(collection: K, data: T[K]): AddChange<T, K>;
     /** Get a set change for a collection in this database. */
-    getSet<K extends Key<T>>(collection: K, id: string, data: T[K]): SetChange<T, K>;
+    getSet<K extends DataKey<T>>(collection: K, id: string, data: T[K]): SetChange<T, K>;
     /** Get an update change for a collection in this database. */
-    getUpdate<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): UpdateChange<T, K>;
+    getUpdate<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): UpdateChange<T, K>;
     /** Get a delete change for a collection in this database. */
-    getDelete<K extends Key<T>>(collection: K, id: string): DeleteChange<T, K>;
+    getDelete<K extends DataKey<T>>(collection: K, id: string): DeleteChange<T, K>;
 }
 /** Database with a synchronous provider. */
 export declare class Database<T extends Datas = Datas> extends BaseDatabase<T> {
     readonly provider: Provider<T>;
     constructor(provider: Provider<T>);
-    collection<K extends Key<T>>(collection: K): Collection<T, K>;
-    query<K extends Key<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K>;
-    item<K extends Key<T>>(collection: K, id: string): Item<T, K>;
+    collection<K extends DataKey<T>>(collection: K): Collection<T, K>;
+    query<K extends DataKey<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K>;
+    item<K extends DataKey<T>>(collection: K, id: string): Item<T, K>;
     change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): ItemChanges<T>;
-    get<K extends Key<T>>(collection: K, id: string): ItemValue<T[K]>;
-    add<K extends Key<T>>(collection: K, data: T[K]): string;
-    set<K extends Key<T>>(collection: K, id: string, data: T[K]): void;
-    update<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
-    delete<K extends Key<T>>(collection: K, id: string): void;
+    get<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
+    add<K extends DataKey<T>>(collection: K, data: T[K]): string;
+    set<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
+    update<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
+    delete<K extends DataKey<T>>(collection: K, id: string): void;
 }
 /** Database with a synchronous provider. */
 export declare class AsyncDatabase<T extends Datas = Datas> extends BaseDatabase<T> {
     readonly provider: AsyncProvider<T>;
     constructor(provider: AsyncProvider<T>);
-    collection<K extends Key<T>>(collection: K): AsyncCollection<T, K>;
-    query<K extends Key<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): AsyncQuery<T, K>;
-    item<K extends Key<T>>(collection: K, id: string): AsyncItem<T, K>;
+    collection<K extends DataKey<T>>(collection: K): AsyncCollection<T, K>;
+    query<K extends DataKey<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): AsyncQuery<T, K>;
+    item<K extends DataKey<T>>(collection: K, id: string): AsyncItem<T, K>;
     change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): Promise<ItemChanges<T>>;
-    get<K extends Key<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    add<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
-    set<K extends Key<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    update<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    delete<K extends Key<T>>(collection: K, id: string): Promise<void>;
+    get<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
+    add<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
+    set<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
+    update<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
+    delete<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
 }
 export {};

package/db/Item.d.ts

@@ -1,7 +1,7 @@
 import type { ImmutableArray } from "../util/array.js";
 import type { Stop, Handler, Dispatch } from "../util/function.js";
 import type { QueryConstraints } from "../constraint/QueryConstraints.js";
-import { Data, Datas, Key } from "../util/data.js";
+import { Data, Datas, DataKey } from "../util/data.js";
 import { DataUpdate, Updates } from "../update/DataUpdate.js";
 import type { DeleteChange, SetChange, UpdateChange } from "./Change.js";
 import type { AsyncQuery, Query } from "./Query.js";
@@ -17,7 +17,7 @@ export declare type ItemArray<T extends Data = Data> = ImmutableArray<ItemData<T
 /** A set of query constraints for item data. */
 export declare type ItemConstraints<T extends Data = Data> = QueryConstraints<ItemData<T>>;
 /** Reference to an item in a synchronous or asynchronous database. */
-declare abstract class BaseItem<T extends Datas = Datas, K extends Key<T> = Key<T>> implements AsyncIterable<ItemValue<T[K]>> {
+declare abstract class BaseItem<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> implements AsyncIterable<ItemValue<T[K]>> {
     abstract readonly db: Database<T> | AsyncDatabase<T>;
     abstract readonly collection: K;
     abstract readonly id: string;
@@ -59,7 +59,7 @@ declare abstract class BaseItem<T extends Datas = Datas, K extends Key<T> = Key<
     [Symbol.asyncIterator](): AsyncIterator<ItemValue<T[K]>>;
 }
 /** Reference to an item in a synchronous database. */
-export declare class Item<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseItem<T, K> {
+export declare class Item<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseItem<T, K> {
     readonly db: Database<T>;
     readonly collection: K;
     readonly id: string;
@@ -73,7 +73,7 @@ export declare class Item<T extends Datas = Datas, K extends Key<T> = Key<T>> ex
     delete(): void;
 }
 /** Reference to an item in an asynchronous database. */
-export declare class AsyncItem<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseItem<T, K> {
+export declare class AsyncItem<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseItem<T, K> {
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
     readonly id: string;

package/db/Query.d.ts

@@ -1,4 +1,4 @@
-import type { Key, Datas } from "../util/data.js";
+import type { DataKey, Datas } 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";
@@ -7,7 +7,7 @@ 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 Key<T> = Key<T>> extends QueryConstraints<ItemData<T[K]>> implements AsyncIterable<ItemArray<T[K]>> {
+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;
     /**
@@ -70,7 +70,7 @@ declare abstract class BaseQuery<T extends Datas = Datas, K extends Key<T> = Key
     [Symbol.asyncIterator](): AsyncIterator<ItemArray<T[K]>>;
 }
 /** Reference to a set of items in a provider. */
-export declare class Query<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseQuery<T, K> {
+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<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null);
@@ -86,7 +86,7 @@ export declare class Query<T extends Datas = Datas, K extends Key<T> = Key<T>> e
     delete(): number;
 }
 /** Reference to a set of items in a provider. */
-export declare class AsyncQuery<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseQuery<T, K> {
+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<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null);

package/package.json

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

package/provider/CacheProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Datas, Key } from "../util/data.js";
+import type { Datas, DataKey } 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";
@@ -9,15 +9,15 @@ export declare class CacheProvider<T extends Datas> implements AsyncThroughProvi
     readonly source: AsyncProvider<T>;
     readonly memory: MemoryProvider<T>;
     constructor(source: AsyncProvider<T>, cache?: MemoryProvider<T>);
-    getItem<K extends Key<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    getItemSequence<K extends Key<T>>(collection: K, id: string): AsyncIterableIterator<ItemValue<T[K]>>;
-    addItem<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
-    setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    deleteItem<K extends Key<T>>(collection: K, id: string): Promise<void>;
-    getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
-    getQuerySequence<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterableIterator<ItemArray<T[K]>>;
-    setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
-    deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
+    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>;
 }

package/provider/DebugProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Datas, Key } from "../util/data.js";
+import type { Datas, DataKey } 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";
@@ -6,35 +6,35 @@ 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 Key<T>>(collection: K, id: string): AsyncIterableIterator<ItemValue<T[K]>>;
-    getQuerySequence<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterableIterator<ItemArray<T[K]>>;
+    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]>>;
 }
 /** 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 Key<T>>(collection: K, id: string): ItemValue<T[K]>;
-    addItem<K extends Key<T>>(collection: K, data: T[K]): string;
-    setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): void;
-    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
-    deleteItem<K extends Key<T>>(collection: K, id: string): void;
-    getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
-    setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
-    deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
+    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;
 }
 /** 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 Key<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    addItem<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
-    setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    deleteItem<K extends Key<T>>(collection: K, id: string): Promise<void>;
-    getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
-    setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
-    deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
+    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 {};

package/provider/MemoryProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Data, Datas, Key } from "../util/data.js";
+import type { Data, Datas, DataKey } from "../util/data.js";
 import type { ItemArray, ItemValue, ItemData, ItemConstraints } from "../db/Item.js";
 import type { Updates } from "../update/DataUpdate.js";
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
@@ -12,20 +12,20 @@ export declare class MemoryProvider<T extends Datas> implements Provider<T> {
     /** List of tables in `{ collection: Table }` format. */
     private _tables;
     /** Get a table for a collection. */
-    getTable<K extends Key<T>>(collection: K): MemoryTable<T[K]>;
-    getDocumentTime<K extends Key<T>>(collection: K, id: string): number | null;
-    getItem<K extends Key<T>>(collection: K, id: string): ItemValue<T[K]>;
-    getItemSequence<K extends Key<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
-    addItem<K extends Key<T>>(collection: K, data: T[K]): string;
-    setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): void;
-    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
-    deleteItem<K extends Key<T>>(collection: K, id: string): void;
-    getQueryTime<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number | null;
-    getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
-    getQuerySequence<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<ItemArray<T[K]>>;
-    setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
-    deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
+    getTable<K extends DataKey<T>>(collection: K): MemoryTable<T[K]>;
+    getDocumentTime<K extends DataKey<T>>(collection: K, id: string): number | null;
+    getItem<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<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;
+    getQueryTime<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): number | null;
+    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
+    getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<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;
 }
 /**
  * An individual table of data.