quetch 0.18.3 → 0.19.1

package/dist/types/KeyFromUnion.js

@@ -0,0 +1 @@
+//# sourceMappingURL=KeyFromUnion.js.map

package/dist/types/KeyFromUnion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyFromUnion.js","sourceRoot":"","sources":["../../lib/types/KeyFromUnion.ts"],"names":[],"mappings":""}

package/dist/types/Order.d.ts

@@ -2,7 +2,7 @@ import type { Field } from "./Field";
 /**
  * Order item.
  */
-export type Order<T extends object> = Field<T> | {
+export type Order<T> = Field<T> | {
     field: Field<T>;
     descending?: boolean;
 };

package/dist/types/Path.d.ts

@@ -1,4 +1,6 @@
 import type { Increment } from "./Increment";
-export type Path<T, D = 0> = D extends 2 ? never : T extends Array<infer P> ? readonly [number] | readonly [number, ...Path<P, Increment<D>>] : T extends object ? {
-    [K in keyof T]-?: [K] | [K, ...Path<T[K], Increment<D>>];
+import type { Key } from "./Key";
+import type { Primitive } from "./Primitive";
+export type Path<T, D = 7> = [0] extends [1 & T] ? readonly (Key | never)[] : D extends -1 ? never : T extends Array<infer P> ? readonly [number] | readonly [number, ...Path<P, Increment<D>>] : T extends object ? T extends Primitive ? readonly never[] : {
+    [K in keyof T]: [K] | [K, ...Path<T[K], Increment<D>>];
 }[keyof T] : never;

package/dist/types/PathFiltered.d.ts

@@ -1,4 +1,5 @@
 import type { Increment } from "./Increment";
-export type PathFiltered<T, P, D = 0> = D extends 4 ? never : T extends ReadonlyArray<infer I> ? I extends P ? readonly [number] : readonly [number, ...PathFiltered<I, P, Increment<D>>] : T extends object ? {
-    [K in keyof T]-?: T[K] extends P ? readonly [K] : readonly [K, ...PathFiltered<T[K], P, Increment<D>>];
+import type { Key } from "./Key";
+export type PathFiltered<T, P, D = 7> = [0] extends [1 & T] ? readonly (Key | never)[] : D extends -1 ? never : T extends ReadonlyArray<infer I> ? Extract<I, P> extends never ? readonly [number, ...PathFiltered<I, P, Increment<D>>] : readonly [number] : T extends object ? {
+    [K in keyof T]: Extract<T[K], P> extends never ? readonly [K, ...PathFiltered<T[K], P, Increment<D>>] : readonly [K];
 }[keyof T] : never;

package/dist/types/Primitive.d.ts

@@ -0,0 +1 @@
+export type Primitive = String | Number | Boolean | BigInt;

package/dist/types/Primitive.js

@@ -0,0 +1 @@
+//# sourceMappingURL=Primitive.js.map

package/dist/types/Primitive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Primitive.js","sourceRoot":"","sources":["../../lib/types/Primitive.ts"],"names":[],"mappings":""}

package/dist/types/Query.d.ts

@@ -12,6 +12,6 @@ import type { QueryUpdateMultiple } from "./QueryUpdateMultiple";
  */
 export type Query<
 /**
- * Type of the object item to be queried.
+ * Type of the item to be queried.
  */
-T extends object> = QueryRead<T> | QueryReadMultiple<T> | QueryCreate<T> | QueryCreateMultiple<T> | QueryUpdate<T> | QueryUpdateMultiple<T> | QueryDelete<T> | QueryDeleteMultiple<T> | QueryAggregate<T>;
+T> = QueryRead<T> | QueryReadMultiple<T> | QueryCreate<T> | QueryCreateMultiple<T> | QueryUpdate<T> | QueryUpdateMultiple<T> | QueryDelete<T> | QueryDeleteMultiple<T> | QueryAggregate<T>;

package/dist/types/QueryAggregate.d.ts

@@ -7,7 +7,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for computing an aggregated value.
  */
-export type QueryAggregate<T extends object> = {
+export type QueryAggregate<T> = {
     method: "aggregate";
     /**
      * Common item properties to use for identifying the item.

package/dist/types/QueryCreate.d.ts

@@ -4,7 +4,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for creating an item.
  */
-export type QueryCreate<T extends object> = {
+export type QueryCreate<T> = {
     method: "create";
     multiple?: false;
     /**

package/dist/types/QueryCreateMultiple.d.ts

@@ -4,7 +4,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for creating multiple items.
  */
-export type QueryCreateMultiple<T extends object> = {
+export type QueryCreateMultiple<T> = {
     method: "create";
     multiple: true;
     /**

package/dist/types/QueryDelete.d.ts

@@ -5,7 +5,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for deleting an item.
  */
-export type QueryDelete<T extends object> = {
+export type QueryDelete<T> = {
     method: "delete";
     multiple?: false;
     /**

package/dist/types/QueryDeleteMultiple.d.ts

@@ -5,7 +5,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for deleting multiple items.
  */
-export type QueryDeleteMultiple<T extends object> = {
+export type QueryDeleteMultiple<T> = {
     method: "delete";
     multiple: true;
     /**

package/dist/types/QueryRead.d.ts

@@ -6,7 +6,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for reading a single item.
  */
-export type QueryRead<T extends object> = {
+export type QueryRead<T> = {
     method?: "read";
     multiple?: false;
     /**

package/dist/types/QueryReadMultiple.d.ts

@@ -7,7 +7,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for getting a list of items.
  */
-export type QueryReadMultiple<T extends object> = {
+export type QueryReadMultiple<T> = {
     method?: "read";
     multiple: true;
     /**

package/dist/types/QuerySettings.d.ts

@@ -4,7 +4,7 @@ import type { FilterChildren } from "./FilterChildren";
 /**
  * Settings to use when doing a query.
  */
-export type QuerySettings<T extends object> = {
+export type QuerySettings<T> = {
     /**
      * String used to separate the path nodes of an item.
      */

package/dist/types/QueryUpdate.d.ts

@@ -5,7 +5,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for updating an item.
  */
-export type QueryUpdate<T extends object> = {
+export type QueryUpdate<T> = {
     method: "update";
     multiple?: false;
     /**

package/dist/types/QueryUpdateMultiple.d.ts

@@ -6,7 +6,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for updating multiple items.
  */
-export type QueryUpdateMultiple<T extends object> = {
+export type QueryUpdateMultiple<T> = {
     method: "update";
     multiple: true;
     /**

package/dist/types/Result.d.ts

@@ -3,21 +3,21 @@ import type { Query } from "./Query";
 /**
  * Picks fields `F` from object `T`.
  */
-export type PickFields<T extends object | undefined, F extends string | number | symbol> = [F] extends [keyof T] ? {
+export type PickFields<T, F extends string | number | symbol> = [F] extends [
+    keyof T
+] ? {
     readonly [K in F]: T[K];
 } : {
     readonly [K in keyof T]: T[K];
 };
-export type ResultRead<T extends object, Q extends Query<T>> = [Q] extends [
+export type ResultRead<T, Q extends Query<T>> = [Q] extends [
     {
         fields: (keyof T)[];
     }
 ] ? PickFields<T, Item<Q["fields"]>> : T;
-export type Result<T extends object, Q extends Query<T>> = [Q] extends [
-    {
-        method: "read";
-    }
-] ? [Q] extends [{
+export type Result<T, Q extends Query<T>> = [Q] extends [{
+    method: "read";
+}] ? [Q] extends [{
     multiple: true;
 }] ? readonly ResultRead<T, Q>[] : ResultRead<T, Q> : [Q] extends [{
     method: "aggregate";

package/dist/types/Value.d.ts

@@ -2,7 +2,7 @@ import type { FieldFiltered } from "./FieldFiltered";
 /**
  * Actual `value` or `valueField` leading to the value.
  */
-export type Value<T extends object, V> = {
+export type Value<T, V> = {
     /**
      * Value to use.
      */

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 export type { AggregateFunction } from "./types/AggregateFunction";
 export type { AggregateFunctionOperator } from "./types/AggregateFunctionOperator";
-export type { Any } from "./types/Any";
+export type { CombineUnion } from "./types/CombineUnion";
 export type { Context } from "./types/Context";
 export type { CustomFetch } from "./types/CustomFetch";
 export type { CustomFieldAggregateMap } from "./types/CustomFieldAggregateMap";
@@ -34,14 +34,14 @@ export type { Item } from "./types/Item";
 export type { Join } from "./types/Join";
 export type { Key } from "./types/Key";
 export type { KeyFiltered } from "./types/KeyFiltered";
+export type { KeyFromUnion } from "./types/KeyFromUnion";
 export type { Locale } from "./types/Locale";
-export type { Mutable } from "./types/Mutable";
 export type { NextHandler } from "./types/NextHandler";
-export type { Normalized } from "./types/Normalized";
 export type { Order } from "./types/Order";
 export type { Parameters } from "./types/Parameters";
 export type { Path } from "./types/Path";
 export type { PathFiltered } from "./types/PathFiltered";
+export type { Primitive } from "./types/Primitive";
 export type { Query } from "./types/Query";
 export type { QueryAggregate } from "./types/QueryAggregate";
 export type { QueryCreate } from "./types/QueryCreate";

package/lib/constants/CACHE.ts

@@ -0,0 +1 @@
+export const CACHE = Symbol("cache");

package/lib/constants/SELF.ts

@@ -0,0 +1 @@
+export const SELF = Symbol("self");

package/lib/constants.ts

@@ -1,2 +1,3 @@
 // File automatically generated by `vite-plugin-module-list`
-export { SymbolCache } from "./constants/SymbolCache.js";
+export { CACHE } from "./constants/CACHE.js";
+export { SELF } from "./constants/SELF.js";

package/lib/middlewares/fetchLocal.ts

@@ -6,7 +6,7 @@ import type { Handler, Query } from "../types";
  *
  * @returns Promise that resolves to the response.
  */
-export function fetchLocal<T extends object>(): Handler<
+export function fetchLocal<T>(): Handler<
   Query<T> & { type: T[] },
   any,
   never,

package/lib/tools/defineCheckQuery.ts

@@ -6,7 +6,7 @@ import type { Query } from "../types";
  * @returns Function that checks queries.
  */
 export function defineCheckQuery<M extends Record<string, object>>() {
-  function checkQuery<T extends object, const Q extends Query<T>>(
+  function checkQuery<T, const Q extends Query<T>>(
     query: Q & { type: T[] },
   ): typeof query;
   function checkQuery<

package/lib/tools/defineCustomFetch.ts

@@ -16,7 +16,7 @@ export function defineCustomFetch<M extends Record<string, object>>(
     T extends M[K],
     const Q extends Query<T>,
   >(query: Q & { type: K }): Promise<Result<T, Q>>;
-  async function customFetch<T extends object, const Q extends Query<T>>(
+  async function customFetch<T, const Q extends Query<T>>(
     type: T[],
     query: Q,
   ): Promise<Result<T, Q>>;

package/lib/tools/defineGenericFetch.ts

@@ -15,7 +15,7 @@ export function defineGenericFetch<K extends string>(
   handler: Handler<Query<any> & { type: Key | any[] }, any, never, never>,
 ) {
   // FIXME: Until https://github.com/microsoft/TypeScript/issues/26242 gets resolved, the fetcher needs to be curried
-  function genericFetch<T extends object>() {
+  function genericFetch<T>() {
     async function customFetch<const Q extends Query<T>>(
       query: Q & { type: K | T[] },
     ): Promise<Result<T, Q>> {

package/lib/tools/fieldListFromFilter.ts

@@ -8,7 +8,7 @@ import type { Field, Filter } from "../types";
  * @param filter The filter to extract the fields from.
  * @returns A list of fields.
  */
-export function fieldListFromFilter<T extends object>(
+export function fieldListFromFilter<T>(
   filter?: Filter<T>,
 ): readonly Field<T>[] {
   if (filter === undefined) {

package/lib/tools/filterChildren.ts

@@ -2,7 +2,7 @@ import type { FieldFiltered, Filter } from "../types.ts";
 
 import { escapeRegex } from "./escapeRegex.js";
 
-export function filterChildren<T extends object>(
+export function filterChildren<T>(
   parentPath: string,
   pathFieldKey: FieldFiltered<T, string>,
   deep = false,

package/lib/tools/filterFromContext.test.ts

@@ -43,6 +43,16 @@ test("returns filter from context", () => {
       },
     ],
   });
+  expect(filterFromContext({ a: null })).toEqual({
+    operator: "all",
+    value: [
+      {
+        field: "a",
+        operator: "equal",
+        value: null,
+      },
+    ],
+  });
   expect(filterFromContext({ a: { b: 1 }, c: 2 })).toEqual({
     operator: "all",
     value: [

package/lib/tools/filterFromContext.ts

@@ -4,16 +4,14 @@ import type { Context, Filter } from "../types";
 
 const { entries } = Object;
 
-export function filterFromContext<T extends object>(
-  context: Context<T>,
-): Filter<T> {
+export function filterFromContext<T>(context: Context<T>): Filter<T> {
   return {
     operator: "all",
     value: criteria(context),
   };
 }
 
-function criteria<T extends object>(
+function criteria<T>(
   context: object,
   path: readonly string[] = EMPTY_ARRAY,
 ): readonly Filter<T>[] {

package/lib/tools/get.test.ts

@@ -14,6 +14,7 @@ test("gets properties", () => {
   expect(result2).toBe(value.a.d.e[2].f);
 
   const result3 = get(value, ["a"]);
+  expect(result3.b).toBe(value.a.b);
   expect(result3).toBe(value.a);
 
   const result4 = get(value, "a");

package/lib/tools/get.ts

@@ -1,4 +1,5 @@
-import type { Field, Get } from "../types";
+import { SELF } from "../constants/SELF.js";
+import type { Get, Path } from "../types";
 
 /**
  * Gets the property value of the given `value` at the specified `path` (an array of object property names or array indexes).
@@ -10,8 +11,11 @@ import type { Field, Get } from "../types";
  * @param path The path leading to the property value or a property name or `undefined`.
  * @returns The property value found at the given path, or `undefined` if it cannot be found.
  */
-export function get<T, P extends Field<T>>(value: T, path?: P): Get<T, P> {
-  if (path === undefined) {
+export function get<const T, const P extends Path<T> | keyof T>(
+  value: T,
+  path?: P,
+): Get<T, P> {
+  if (path === undefined || path === SELF) {
     return value as any;
   }
   switch (typeof path) {
@@ -20,19 +24,21 @@ export function get<T, P extends Field<T>>(value: T, path?: P): Get<T, P> {
     case "symbol":
       return (value as any)?.[path];
     default: {
-      switch (path.length) {
+      switch (path.length as number) {
+        case 0:
+          return value as any;
         case 1:
           return (value as any)?.[path[0] as any];
         case 2:
-          return (value as any)?.[path[0] as any]?.[path[1] as any];
+          return (value as any)?.[path[0] as any]?.[(path as any)[1] as any];
         case 3:
-          return (value as any)?.[path[0] as any]?.[path[1] as any]?.[
-            path[2] as any
+          return (value as any)?.[path[0] as any]?.[(path as any)[1] as any]?.[
+            (path as any)[2] as any
           ];
         case 4:
-          return (value as any)?.[path[0] as any]?.[path[1] as any]?.[
-            path[2] as any
-          ]?.[path[3] as any];
+          return (value as any)?.[path[0] as any]?.[(path as any)[1] as any]?.[
+            (path as any)[2] as any
+          ]?.[(path as any)[3] as any];
         default:
           return path.reduce(
             (value, key) => (value as any)?.[key],

package/lib/tools/isFilterGroup.ts

@@ -6,7 +6,7 @@ import type { Filter, FilterGroup } from "../types";
  * @param value The filter to test.
  * @returns Whether the provided filter is a group filter or not.
  */
-export function isFilterGroup<T extends object>(
+export function isFilterGroup<T>(
   value: Filter<T> | undefined,
 ): value is FilterGroup<T> {
   switch (value?.operator) {

package/lib/tools/normalizeOrder.ts

@@ -8,9 +8,7 @@ const isArray = Array.isArray as (value: any) => value is readonly any[];
  * @param order The string or order object.
  * @returns The normalized order object.
  */
-export function normalizeOrder<T extends object>(
-  order: Order<T>,
-): {
+export function normalizeOrder<T>(order: Order<T>): {
   field: Field<T>;
   descending?: boolean | undefined;
 } {

package/lib/tools/queryItemList.test.ts

@@ -5,7 +5,7 @@ import { queryItemList } from "./queryItemList.js";
 test("queries a single item", () => {
   expect(
     queryItemList({
-      type: [{ a: 1 }, { a: 2 }, { a: 3 }] as { a: number }[],
+      type: [{ a: 1 }, { a: 2 }, { a: 3 }],
     }),
   ).toEqual({ a: 1 });
   expect(() =>
@@ -13,7 +13,7 @@ test("queries a single item", () => {
       context: {
         a: 4,
       },
-      type: [{ a: 1 }, { a: 2 }, { a: 3 }] as { a: number }[],
+      type: [{ a: 1 }, { a: 2 }, { a: 3 }] as readonly { a: number }[],
     }),
   ).toThrow("Not found");
   expect(

package/lib/tools/queryItemList.ts

@@ -11,7 +11,7 @@ import { filterFromContext } from "./filterFromContext.js";
 import { sortItemList } from "./sortItemList.js";
 import { testFilter } from "./testFilter.js";
 
-function mergeContextAndFilter<T extends object>(
+function mergeContextAndFilter<T>(
   context?: Context<T>,
   filter?: Filter<T>,
 ): Filter<T> | undefined {
@@ -30,7 +30,7 @@ function mergeContextAndFilter<T extends object>(
   };
 }
 
-function normalizeAggregator<T extends object>(
+function normalizeAggregator<T>(
   aggregator: AggregateFunction<T>,
 ): Exclude<AggregateFunction<T>, string> {
   if (typeof aggregator === "string") {
@@ -45,7 +45,7 @@ function normalizeAggregator<T extends object>(
  * @param query The query to perform.
  * @returns The result of the query.
  */
-export function queryItemList<T extends object, const Q extends Query<T>>(
+export function queryItemList<T, const Q extends Query<T>>(
   query: Q & { type: readonly T[] },
 ): Result<T, Q> {
   const data = query.type;

package/lib/tools/reverseOrder.ts

@@ -8,9 +8,7 @@ import { normalizeOrder } from "./normalizeOrder.js";
  * @param order The order to reverse.
  * @returns The reversed order.
  */
-export function reverseOrder<T extends object>(
-  order: Order<T>,
-): {
+export function reverseOrder<T>(order: Order<T>): {
   field: Field<T>;
   descending?: boolean | undefined;
 } {

package/lib/tools/sortItemList.ts

@@ -10,7 +10,7 @@ import { normalizeOrder } from "./normalizeOrder.js";
  * @param value The array to sort.
  * @returns A new sorted array.
  */
-export function sortItemList<T extends object>(
+export function sortItemList<T>(
   orderList: readonly Order<T>[] | undefined,
   value: readonly T[],
 ) {
@@ -21,8 +21,8 @@ export function sortItemList<T extends object>(
   return [...value].sort((a, b) => {
     for (let index = 0; index < normalizedOrder.length; index++) {
       const { field, descending } = normalizedOrder[index]!;
-      const valueA = get(a, field);
-      const valueB = get(b, field);
+      const valueA = get(a, field as any);
+      const valueB = get(b, field as any);
       if (valueA === valueB) {
         continue;
       }

package/lib/tools/testFilter.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from "vitest";
 
-import { SymbolCache } from "../constants.js";
+import { CACHE } from "../constants/CACHE.js";
 import type { FilterChildren } from "../types.js";
 
 import { filterFromContext } from "./filterFromContext.js";
@@ -290,7 +290,7 @@ test("tests filter with children predicates", () => {
       },
     ),
   ).toBe(true);
-  const filterChildren: FilterChildren<any> = {
+  const filterChildren: FilterChildren<{ path: string }> = {
     operator: "children",
     value: "a",
   };
@@ -309,7 +309,7 @@ test("tests filter with children predicates", () => {
       },
     ),
   ).toBe(true);
-  expect(filterChildren[SymbolCache]).toBeDefined();
+  expect(filterChildren[CACHE]).toBeDefined();
   expect(testFilter({ operator: "children", value: "b" }, { id: "a/b" })).toBe(
     false,
   );

package/lib/tools/testFilter.ts

@@ -1,16 +1,13 @@
-import { SymbolCache } from "../constants/SymbolCache.js";
+import { CACHE } from "../constants/CACHE.js";
 import type { QuerySettings } from "../types/QuerySettings.js";
-import type { Any, FieldFiltered, Filter, FilterString } from "../types.js";
+import type { FieldFiltered, Filter, FilterString } from "../types.js";
 
 import { filterChildren } from "./filterChildren.js";
 import { get } from "./get.js";
 
 const { isArray } = Array;
 
-function valueFromFilter<T extends object, F extends Filter<T>>(
-  value: T,
-  filter: F,
-): F extends { value: infer V } ? V : never {
+function valueFromFilter<T>(value: T, filter: Filter<T>): any {
   if ("valueField" in filter) {
     filter.valueField;
     return get<T, any>(value, filter.valueField) as any;
@@ -26,7 +23,7 @@ function valueFromFilter<T extends object, F extends Filter<T>>(
  * @param settings Optional query settings.
  * @returns `true` if the `value` matches the `filter` and `false` otherwise.
  */
-export function testFilter<T extends object>(
+export function testFilter<T>(
   filter: Filter<T> | undefined,
   value: T | undefined,
   settings?: QuerySettings<T>,
@@ -53,12 +50,12 @@ export function testFilter<T extends object>(
       return filter.value.every((filter) => !testFilter(filter, value));
     }
     case "exist":
-      return get(value, filter.field) !== undefined;
+      return get(value, filter.field as any) !== undefined;
     case "equal": {
-      const rightValue = valueFromFilter(value, filter);
+      const rightValue = valueFromFilter(value, filter as Filter<any>);
       if (isArray(rightValue)) {
         filter.field;
-        const leftValue = get<T, any>(value, filter.field) as Any[] | undefined;
+        const leftValue = get<T, any>(value, filter.field);
         if (!isArray(leftValue)) {
           return false;
         }
@@ -107,17 +104,17 @@ export function testFilter<T extends object>(
       return true;
     }
     case "children": {
-      if (filter[SymbolCache] === undefined) {
+      if (filter[CACHE] === undefined) {
         switch (true) {
           case settings?.transformFilterChildren !== undefined:
-            filter[SymbolCache] = settings.transformFilterChildren(filter);
+            filter[CACHE] = settings.transformFilterChildren(filter);
             break;
           default: {
             const {
               pathFieldKey = "id" as FieldFiltered<T, string>,
               pathFieldSeparator = "/",
             } = settings || {};
-            filter[SymbolCache] = filterChildren(
+            filter[CACHE] = filterChildren(
               filter.value as string,
               pathFieldKey,
               filter.deep,
@@ -126,7 +123,7 @@ export function testFilter<T extends object>(
           }
         }
       }
-      return testFilter(filter[SymbolCache], value);
+      return testFilter(filter[CACHE], value);
     }
     case "custom": {
       return filter.value(value);
@@ -276,15 +273,15 @@ export function testFilter<T extends object>(
       if (leftValue === undefined) {
         return false;
       }
-      if (filter[SymbolCache] === undefined) {
-        filter[SymbolCache] = new RegExp(
+      if (filter[CACHE] === undefined) {
+        filter[CACHE] = new RegExp(
           rightValue,
           `${filter.options?.ignoreCase ? "i" : ""}${
             filter.options?.dotAll ? "s" : ""
           }`,
         );
       }
-      return filter[SymbolCache].test(leftValue);
+      return filter[CACHE].test(leftValue);
     }
     case "intersect": {
       const rightValue = valueFromFilter(value, filter);

package/lib/types/AggregateFunction.ts

@@ -1,9 +1,10 @@
+import type { Field } from "./Field";
 import type { Filter } from "./Filter";
 
 /**
  * Aggregation function.
  */
-export type AggregateFunction<T extends object> =
+export type AggregateFunction<T> =
   | "length"
   | { operator: "length" }
   | { operator: "index"; filter?: Filter<T>; last?: boolean }
@@ -16,5 +17,5 @@ export type AggregateFunction<T extends object> =
         | "maximum"
         | "variance"
         | "mode";
-      field: keyof T;
+      field: Field<T>;
     };