tsense 0.2.0-next.4 → 0.2.0-next.6

package/dist/filters/filter-state.d.ts

@@ -1,5 +1,6 @@
+import type { RelativeDate } from "../types.js";
 import type { FilterDescriptor } from "./index.js";
-export type FilterValue = string | string[] | number | boolean | Date | [FilterValue | undefined, FilterValue | undefined] | undefined;
+export type FilterValue = string | string[] | number | boolean | Date | RelativeDate | [FilterValue | undefined, FilterValue | undefined] | undefined;
 export type FilterRow = {
     id: number;
     field?: string;
@@ -8,6 +9,7 @@ export type FilterRow = {
 };
 export type FilterState = {
     rows: FilterRow[];
+    manualRowIds: Set<number>;
 };
 export declare function createInitialState(): FilterState;
 export declare function addRow(state: FilterState): FilterState;
@@ -17,7 +19,7 @@ export declare function setRowField(state: FilterState, index: number, field: st
 export declare function setRowCondition(state: FilterState, index: number, condition: string): FilterState;
 export declare function setRowValue(state: FilterState, index: number, value: FilterValue): FilterState;
 export declare function clearState(): FilterState;
-export declare function applyPreset<T>(state: FilterState, descriptor: FilterDescriptor<T>, field: string, name: string): FilterState;
+export declare function hasManualRows(state: FilterState): boolean;
 export declare function conditionsFor<T>(descriptor: FilterDescriptor<T>, field: string): FilterDescriptor<T>["columns"][number]["conditions"];
 export declare function columnFor<T>(descriptor: FilterDescriptor<T>, field: string): FilterDescriptor<T>["columns"][number];
 export declare function buildResult(state: FilterState): Record<string, unknown>;

package/dist/filters/filter-state.js

@@ -11,94 +11,59 @@ const conditionToOperator = {
 };
 let nextRowId = 0;
 export function createInitialState() {
-    return { rows: [] };
+    return { rows: [], manualRowIds: new Set() };
 }
 export function addRow(state) {
-    return { rows: [...state.rows, { id: ++nextRowId }] };
+    const id = ++nextRowId;
+    return {
+        rows: [...state.rows, { id }],
+        manualRowIds: new Set([...state.manualRowIds, id]),
+    };
 }
 export function addRowWithField(state, field) {
-    return { rows: [...state.rows, { id: ++nextRowId, field }] };
+    const id = ++nextRowId;
+    return {
+        rows: [...state.rows, { id, field }],
+        manualRowIds: new Set([...state.manualRowIds, id]),
+    };
 }
 export function removeRow(state, index) {
-    return { rows: state.rows.filter((_, i) => i !== index) };
+    const removed = state.rows[index];
+    const manualRowIds = new Set(state.manualRowIds);
+    if (removed) {
+        manualRowIds.delete(removed.id);
+    }
+    return {
+        rows: state.rows.filter((_, i) => i !== index),
+        manualRowIds,
+    };
 }
 export function setRowField(state, index, field) {
     return {
         rows: state.rows.map((row, i) => i === index ? { id: row.id, field } : row),
+        manualRowIds: state.manualRowIds,
     };
 }
 export function setRowCondition(state, index, condition) {
     return {
         rows: state.rows.map((row, i) => i === index ? { ...row, condition, value: undefined } : row),
+        manualRowIds: state.manualRowIds,
     };
 }
 export function setRowValue(state, index, value) {
     return {
         rows: state.rows.map((row, i) => (i === index ? { ...row, value } : row)),
+        manualRowIds: state.manualRowIds,
     };
 }
 export function clearState() {
-    return { rows: [] };
-}
-function filterValueToRow(field, filterValue) {
-    if (filterValue == null) {
-        return null;
-    }
-    if (Array.isArray(filterValue)) {
-        return {
-            id: ++nextRowId,
-            field,
-            condition: "is_in",
-            value: filterValue,
-        };
-    }
-    if (typeof filterValue !== "object" || filterValue instanceof Date) {
-        return {
-            id: ++nextRowId,
-            field,
-            condition: "equals",
-            value: filterValue,
-        };
-    }
-    const operators = filterValue;
-    const keys = Object.keys(operators);
-    if (keys.includes("gte") && keys.includes("lte")) {
-        return {
-            id: ++nextRowId,
-            field,
-            condition: "between",
-            value: [operators.gte, operators.lte],
-        };
-    }
-    if (!keys[0]) {
-        return null;
-    }
-    return {
-        id: ++nextRowId,
-        field,
-        condition: keys[0],
-        value: operators[keys[0]],
-    };
+    return { rows: [], manualRowIds: new Set() };
 }
-export function applyPreset(state, descriptor, field, name) {
-    const column = descriptor.columns.find((c) => c.key === field);
-    const preset = column?.presets?.find((p) => p.name === name);
-    if (!preset) {
-        return state;
-    }
-    const presetRows = [];
-    for (const [key, value] of Object.entries(preset.filter)) {
-        const row = filterValueToRow(key, value);
-        if (row) {
-            presetRows.push(row);
-        }
-    }
-    if (!presetRows.length) {
-        return state;
-    }
-    const presetFields = new Set(presetRows.map((r) => r.field));
-    const preserved = state.rows.filter((r) => !r.field || !presetFields.has(r.field));
-    return { rows: [...preserved, ...presetRows] };
+export function hasManualRows(state) {
+    return state.rows.some((r) => state.manualRowIds.has(r.id) &&
+        r.field != null &&
+        r.condition != null &&
+        r.value != null);
 }
 export function conditionsFor(descriptor, field) {
     const column = descriptor.columns.find((c) => c.key === field);

package/dist/filters/index.d.ts

@@ -1,3 +1,4 @@
+export { isRelativeDate, resolveRelativeDate } from "./relative-dates.js";
 export { deserializeFilter, serializeFilter } from "./url.js";
 import type { Type } from "arktype";
 import type { TSense } from "../tsense.js";
@@ -16,16 +17,11 @@ export type FilterDescriptor<T = Record<string, unknown>> = {
             value: string;
             label: string;
         }[];
-        presets?: {
-            name: string;
-            filter: Record<string, unknown>;
-        }[];
     }[];
 };
-type FilterBuilderFieldConfig<T> = {
+type FilterBuilderFieldConfig = {
     label: string;
     labels?: Record<string, string>;
-    presets?: Record<string, FilterFor<T> | (() => FilterFor<T>)>;
 };
 type FilterBuilderReturn<T> = {
     describe(): FilterDescriptor<T>;
@@ -36,5 +32,5 @@ type FilterBuilderOptions = {
     conditionLabels?: Partial<Record<ColumnType | "enum", Partial<Record<string, string>>>>;
 };
 export declare function createFilterBuilder<T extends Type>(collection: TSense<T>, config: {
-    [K in keyof T["infer"]]?: FilterBuilderFieldConfig<T["infer"]>;
+    [K in keyof T["infer"]]?: FilterBuilderFieldConfig;
 }, options?: FilterBuilderOptions): FilterBuilderReturn<T["infer"]>;

package/dist/filters/index.js

@@ -1,3 +1,4 @@
+export { isRelativeDate, resolveRelativeDate } from "./relative-dates.js";
 export { deserializeFilter, serializeFilter } from "./url.js";
 import { type } from "arktype";
 const tsenseTypeMap = {
@@ -58,23 +59,26 @@ export function createFilterBuilder(collection, config, options) {
                 "not?": "string",
                 "notIn?": "string[]",
             });
-            const dateInput = "number | string | Date";
+            const relativeDateUnit = "'day' | 'week' | 'month'";
+            const relativeDate = type
+                .raw({ startOf: relativeDateUnit })
+                .or(type.raw({ endOf: relativeDateUnit }));
+            const concreteDateInput = type.raw("number | string | Date");
+            const dateInput = concreteDateInput.or(relativeDate);
+            const dateArrayInput = dateInput.array();
             const dateOps = type.raw({
                 "not?": dateInput,
                 "gt?": dateInput,
                 "gte?": dateInput,
                 "lt?": dateInput,
                 "lte?": dateInput,
-                "notIn?": `(${dateInput})[]`,
+                "notIn?": dateArrayInput,
             });
             const fieldSchemas = {
                 number: type.raw("number").or(type.raw("number[]")).or(numberOps),
                 string: type.raw("string").or(type.raw("string[]")).or(stringOps),
                 boolean: type.raw("boolean"),
-                date: type
-                    .raw(dateInput)
-                    .or(type.raw(`(${dateInput})[]`))
-                    .or(dateOps),
+                date: dateInput.or(dateArrayInput).or(dateOps),
             };
             const descriptor = this.describe();
             const filterDef = {};
@@ -124,14 +128,6 @@ export function createFilterBuilder(collection, config, options) {
                     }));
                     column.conditions = withLabels(enumConditions, "enum");
                 }
-                if (fieldConfig.presets) {
-                    column.presets = Object.entries(fieldConfig.presets).map(([name, filterOrFn]) => ({
-                        name,
-                        filter: (typeof filterOrFn === "function"
-                            ? filterOrFn()
-                            : filterOrFn),
-                    }));
-                }
                 columns.push(column);
             }
             return { infer: undefined, columns };

package/dist/filters/relative-dates.d.ts

@@ -0,0 +1,3 @@
+import type { RelativeDate } from "../types.js";
+export declare function isRelativeDate(value: unknown): value is RelativeDate;
+export declare function resolveRelativeDate(expr: RelativeDate, tz: string, now?: Date): Date;

package/dist/filters/relative-dates.js

@@ -0,0 +1,20 @@
+import dayjs from "dayjs";
+import timezone from "dayjs/plugin/timezone.js";
+import utc from "dayjs/plugin/utc.js";
+dayjs.extend(utc);
+dayjs.extend(timezone);
+export function isRelativeDate(value) {
+    if (typeof value !== "object" || value === null || value instanceof Date) {
+        return false;
+    }
+    const obj = value;
+    return (("startOf" in obj && typeof obj.startOf === "string") ||
+        ("endOf" in obj && typeof obj.endOf === "string"));
+}
+export function resolveRelativeDate(expr, tz, now) {
+    const base = now ? dayjs(now).tz(tz) : dayjs().tz(tz);
+    if ("startOf" in expr) {
+        return base.startOf(expr.startOf).toDate();
+    }
+    return base.endOf(expr.endOf).toDate();
+}

package/dist/index.d.ts

@@ -4,4 +4,5 @@ export { DateTransformer } from "./transformers/date.js";
 export { defaultTransformers } from "./transformers/defaults.js";
 export type { FieldTransformer } from "./transformers/types.js";
 export { TSense } from "./tsense.js";
-export type { ConnectionConfig, DeleteResult, FilterFor, HighlightOptions, NumberFilter, ProjectSearch, SearchListOptions, SearchListResult, SearchInput, SearchOptions, ScopedCollection, SearchOptionsPlain, SearchOptionsWithOmit, SearchOptionsWithPick, SearchResult, StringFilter, SyncConfig, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult, } from "./types.js";
+export { isRelativeDate, resolveRelativeDate, } from "./filters/relative-dates.js";
+export type { ConnectionConfig, DeleteResult, FilterFor, HighlightOptions, NumberFilter, ProjectSearch, RelativeDate, RelativeDateUnit, SearchListOptions, SearchListResult, SearchInput, SearchOptions, ScopedCollection, SearchOptionsPlain, SearchOptionsWithOmit, SearchOptionsWithPick, SearchResult, StringFilter, SyncConfig, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult, } from "./types.js";

package/dist/index.js

@@ -2,3 +2,4 @@ export { rank } from "./rank.js";
 export { DateTransformer } from "./transformers/date.js";
 export { defaultTransformers } from "./transformers/defaults.js";
 export { TSense } from "./tsense.js";
+export { isRelativeDate, resolveRelativeDate, } from "./filters/relative-dates.js";

package/dist/react/filter-builder/filter-builder-defaults.d.ts

@@ -1,7 +1,6 @@
-import type { AddButtonSlotProps, ConditionSelectSlotProps, FieldSelectSlotProps, PresetButtonSlotProps, RemoveButtonSlotProps, ValueInputSlotProps } from "./filter-builder-types.js";
+import type { AddButtonSlotProps, ConditionSelectSlotProps, FieldSelectSlotProps, RemoveButtonSlotProps, ValueInputSlotProps } from "./filter-builder-types.js";
 export declare function defaultFieldSelect({ columns, value, onChange }: FieldSelectSlotProps): import("react/jsx-runtime").JSX.Element;
 export declare function defaultConditionSelect({ conditions, value, onChange, disabled }: ConditionSelectSlotProps): import("react/jsx-runtime").JSX.Element;
 export declare function defaultValueInput({ column, condition, value, onChange }: ValueInputSlotProps): import("react/jsx-runtime").JSX.Element;
 export declare function defaultRemoveButton({ onClick }: RemoveButtonSlotProps): import("react/jsx-runtime").JSX.Element;
 export declare function defaultAddButton({ onClick }: AddButtonSlotProps): import("react/jsx-runtime").JSX.Element;
-export declare function defaultPresetButton({ preset, onClick }: PresetButtonSlotProps): import("react/jsx-runtime").JSX.Element;

package/dist/react/filter-builder/filter-builder-defaults.js

@@ -81,6 +81,3 @@ export function defaultRemoveButton({ onClick }) {
 export function defaultAddButton({ onClick }) {
     return (_jsx("button", { type: "button", className: "text-blue-500 hover:text-blue-700", onClick: onClick, children: "+ Add filter" }));
 }
-export function defaultPresetButton({ preset, onClick, }) {
-    return (_jsx("button", { type: "button", className: "rounded bg-gray-100 px-2 py-1 text-sm hover:bg-gray-200", onClick: onClick, children: preset.name }));
-}

package/dist/react/filter-builder/filter-builder-types.d.ts

@@ -25,13 +25,6 @@ export type RemoveButtonSlotProps = {
 export type AddButtonSlotProps = {
     onClick: () => void;
 };
-export type PresetButtonSlotProps = {
-    preset: {
-        field: string;
-        name: string;
-    };
-    onClick: () => void;
-};
 export type RowSlotProps = {
     index: number;
     fieldSelect: ReactNode;
@@ -42,7 +35,6 @@ export type RowSlotProps = {
 export type RootSlotProps = {
     rows: ReactNode;
     addButton: ReactNode;
-    presets: ReactNode | null;
 };
 export type FilterBuilderProps<T> = {
     descriptor: FilterDescriptor<T>;
@@ -54,5 +46,4 @@ export type FilterBuilderProps<T> = {
     renderValueInput?: (props: ValueInputSlotProps) => ReactNode;
     renderAddButton?: (props: AddButtonSlotProps) => ReactNode;
     renderRemoveButton?: (props: RemoveButtonSlotProps) => ReactNode;
-    renderPresetButton?: (props: PresetButtonSlotProps) => ReactNode;
 };

package/dist/react/filter-builder/filter-builder.d.ts

@@ -1,3 +1,3 @@
 import { type ReactNode } from "react";
 import type { FilterBuilderProps } from "./filter-builder-types.js";
-export declare function FilterBuilder<T>({ descriptor, onChange, renderRoot, renderRow, renderFieldSelect, renderConditionSelect, renderValueInput, renderAddButton, renderRemoveButton, renderPresetButton }: FilterBuilderProps<T>): ReactNode;
+export declare function FilterBuilder<T>({ descriptor, onChange, renderRoot, renderRow, renderFieldSelect, renderConditionSelect, renderValueInput, renderAddButton, renderRemoveButton }: FilterBuilderProps<T>): ReactNode;

package/dist/react/filter-builder/filter-builder.js

@@ -1,8 +1,8 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Fragment, useEffect, useRef } from "react";
 import { useFilterBuilder } from "../use-filter-builder.js";
-import { defaultAddButton, defaultConditionSelect, defaultFieldSelect, defaultPresetButton, defaultRemoveButton, defaultValueInput, } from "./filter-builder-defaults.js";
-export function FilterBuilder({ descriptor, onChange, renderRoot, renderRow, renderFieldSelect, renderConditionSelect, renderValueInput, renderAddButton, renderRemoveButton, renderPresetButton, }) {
+import { defaultAddButton, defaultConditionSelect, defaultFieldSelect, defaultRemoveButton, defaultValueInput, } from "./filter-builder-defaults.js";
+export function FilterBuilder({ descriptor, onChange, renderRoot, renderRow, renderFieldSelect, renderConditionSelect, renderValueInput, renderAddButton, renderRemoveButton, }) {
     const filters = useFilterBuilder(descriptor);
     const onChangeRef = useRef(onChange);
     onChangeRef.current = onChange;
@@ -14,7 +14,6 @@ export function FilterBuilder({ descriptor, onChange, renderRoot, renderRow, ren
     const ValueInput = renderValueInput ?? defaultValueInput;
     const RemoveButton = renderRemoveButton ?? defaultRemoveButton;
     const AddButton = renderAddButton ?? defaultAddButton;
-    const PresetButton = renderPresetButton ?? defaultPresetButton;
     const rows = filters.rows.map((row, index) => {
         const fieldSelect = (_jsx(FieldSelect, { columns: filters.columns, value: row.field, onChange: (field) => filters.setField(index, field) }));
         const conditionSelect = (_jsx(ConditionSelect, { conditions: row.field ? filters.conditionsFor(row.field) : [], value: row.condition, onChange: (condition) => filters.setCondition(index, condition), disabled: !row.field }));
@@ -32,9 +31,8 @@ export function FilterBuilder({ descriptor, onChange, renderRoot, renderRow, ren
         return (_jsxs("div", { className: "flex items-center gap-2", children: [fieldSelect, conditionSelect, valueInput, removeButton] }, row.id));
     });
     const addButton = _jsx(AddButton, { onClick: filters.add });
-    const presets = filters.presets.length > 0 ? (_jsx("div", { className: "flex flex-wrap gap-1 border-t pt-2", children: filters.presets.map((preset) => (_jsx(Fragment, { children: _jsx(PresetButton, { preset: preset, onClick: () => filters.applyPreset(preset.field, preset.name) }) }, `${preset.field}-${preset.name}`))) })) : null;
     if (renderRoot) {
-        return _jsx(_Fragment, { children: renderRoot({ rows: _jsx(_Fragment, { children: rows }), addButton, presets }) });
+        return _jsx(_Fragment, { children: renderRoot({ rows: _jsx(_Fragment, { children: rows }), addButton }) });
     }
-    return (_jsxs("div", { className: "flex flex-col gap-2", children: [rows, addButton, presets] }));
+    return (_jsxs("div", { className: "flex flex-col gap-2", children: [rows, addButton] }));
 }

package/dist/react/index.d.ts

@@ -1,4 +1,4 @@
 export { FilterBuilder } from "./filter-builder/filter-builder.js";
-export type { AddButtonSlotProps, ConditionSelectSlotProps, FieldSelectSlotProps, PresetButtonSlotProps, RemoveButtonSlotProps, RootSlotProps, RowSlotProps, ValueInputSlotProps, } from "./filter-builder/filter-builder-types.js";
+export type { AddButtonSlotProps, ConditionSelectSlotProps, FieldSelectSlotProps, RemoveButtonSlotProps, RootSlotProps, RowSlotProps, ValueInputSlotProps, } from "./filter-builder/filter-builder-types.js";
 export type { FilterValue } from "../filters/filter-state.js";
 export { useFilterBuilder } from "./use-filter-builder.js";

package/dist/react/use-filter-builder.d.ts

@@ -1,12 +1,9 @@
 import { type FilterRow, type FilterValue } from "../filters/filter-state.js";
 import type { FilterDescriptor } from "../filters/index.js";
-type Preset = {
-    field: string;
-    name: string;
-};
 type UseFilterBuilderReturn = {
     columns: FilterDescriptor["columns"];
     rows: FilterRow[];
+    hasManualRows: boolean;
     add: () => void;
     addWithField: (field: string) => void;
     remove: (index: number) => void;
@@ -16,8 +13,6 @@ type UseFilterBuilderReturn = {
     clear: () => void;
     conditionsFor: (field: string) => FilterDescriptor["columns"][number]["conditions"];
     columnFor: (field: string) => FilterDescriptor["columns"][number];
-    presets: Preset[];
-    applyPreset: (field: string, name: string) => void;
     result: Record<string, unknown>;
 };
 export declare function useFilterBuilder<T>(descriptor: FilterDescriptor<T>): UseFilterBuilderReturn;

package/dist/react/use-filter-builder.js

@@ -1,12 +1,12 @@
 import { useMemo, useState } from "react";
-import { addRow, addRowWithField, applyPreset as applyPresetState, buildResult, clearState, columnFor, conditionsFor, createInitialState, removeRow, setRowCondition, setRowField, setRowValue, } from "../filters/filter-state.js";
+import { addRow, addRowWithField, buildResult, clearState, columnFor, conditionsFor, createInitialState, hasManualRows as hasManualRowsState, removeRow, setRowCondition, setRowField, setRowValue, } from "../filters/filter-state.js";
 export function useFilterBuilder(descriptor) {
     const [state, setState] = useState(createInitialState);
-    const presets = useMemo(() => descriptor.columns.flatMap((col) => (col.presets ?? []).map((p) => ({ field: col.key, name: p.name }))), [descriptor]);
     const result = useMemo(() => buildResult(state), [state]);
     return {
         columns: descriptor.columns,
         rows: state.rows,
+        hasManualRows: hasManualRowsState(state),
         add: () => setState(addRow),
         addWithField: (field) => setState((s) => addRowWithField(s, field)),
         remove: (index) => setState((s) => removeRow(s, index)),
@@ -16,8 +16,6 @@ export function useFilterBuilder(descriptor) {
         clear: () => setState(clearState),
         conditionsFor: (field) => conditionsFor(descriptor, field),
         columnFor: (field) => columnFor(descriptor, field),
-        presets,
-        applyPreset: (field, name) => setState((s) => applyPresetState(s, descriptor, field, name)),
         result,
     };
 }

package/dist/tsense.d.ts

@@ -78,6 +78,8 @@ export declare class TSense<T extends Type> {
     private buildFilter;
     private validateFilterFields;
     private validateFields;
+    private resolveFilterValue;
+    private resolveFilterDates;
     private buildFilterExpression;
     private combineFilterExpressions;
     private buildSort;

package/dist/tsense.js

@@ -1,4 +1,5 @@
 import redaxios from "redaxios";
+import { isRelativeDate, resolveRelativeDate, } from "./filters/relative-dates.js";
 import { TSenseMigrator } from "./migrator.js";
 import { defaultTransformers } from "./transformers/defaults.js";
 function chunkArray(arr, size) {
@@ -268,9 +269,45 @@ export class TSense {
             }
         }
     }
+    resolveFilterValue(value) {
+        if (isRelativeDate(value)) {
+            return resolveRelativeDate(value, this.options.timezone);
+        }
+        if (Array.isArray(value)) {
+            return value.map((v) => isRelativeDate(v) ? resolveRelativeDate(v, this.options.timezone) : v);
+        }
+        if (typeof value === "object" &&
+            value !== null &&
+            !(value instanceof Date)) {
+            const result = {};
+            for (const [k, v] of Object.entries(value)) {
+                result[k] = this.resolveFilterValue(v);
+            }
+            return result;
+        }
+        return value;
+    }
+    resolveFilterDates(filter) {
+        if (!filter || !this.options.timezone) {
+            return filter;
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(filter)) {
+            if (value == null) {
+                continue;
+            }
+            if (key === "OR") {
+                result.OR = value.map((f) => this.resolveFilterDates(f));
+                continue;
+            }
+            result[key] = this.resolveFilterValue(value);
+        }
+        return result;
+    }
     buildFilterExpression(filter) {
-        this.validateFilterFields(filter);
-        const parts = this.buildFilter(filter);
+        const resolved = this.resolveFilterDates(filter);
+        this.validateFilterFields(resolved);
+        const parts = this.buildFilter(resolved);
         if (!parts.length) {
             return;
         }

package/dist/types.d.ts

@@ -45,9 +45,17 @@ export type TsenseOptions<T extends Type> = {
     batchSize?: number;
     validateOnUpsert?: boolean;
     autoSyncSchema?: boolean;
+    timezone?: string;
     transformers?: FieldTransformer[];
     dataSync?: SyncConfig<T["infer"]>;
 };
+export type RelativeDateUnit = "day" | "week" | "month";
+export type RelativeDate = {
+    startOf: RelativeDateUnit;
+} | {
+    endOf: RelativeDateUnit;
+};
+type DateValue = Date | RelativeDate;
 export type StringFilter = {
     not?: string;
     notIn?: string[];
@@ -61,14 +69,14 @@ export type NumberFilter = {
     lte?: number;
 };
 type DateFilter = {
-    not?: Date;
-    notIn?: Date[];
-    gt?: Date;
-    gte?: Date;
-    lt?: Date;
-    lte?: Date;
-};
-type FilterValueFor<T> = [T] extends [boolean] ? boolean : [T] extends [Date] ? Date | Date[] | DateFilter : [T] extends [number] ? number | number[] | NumberFilter : [T] extends [string] ? T | T[] | StringFilter : never;
+    not?: DateValue;
+    notIn?: DateValue[];
+    gt?: DateValue;
+    gte?: DateValue;
+    lt?: DateValue;
+    lte?: DateValue;
+};
+type FilterValueFor<T> = [T] extends [boolean] ? boolean : [T] extends [Date] ? DateValue | DateValue[] | DateFilter : [T] extends [number] ? number | number[] | NumberFilter : [T] extends [string] ? T | T[] | StringFilter : never;
 type SingleFilter<T> = Partial<{
     [K in keyof T]: FilterValueFor<NonNullable<BaseIfArray<T[K]>>>;
 }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsense",
-  "version": "0.2.0-next.4",
+  "version": "0.2.0-next.6",
   "private": false,
   "description": "Opinionated, fully typed typesense client",
   "keywords": [
@@ -43,6 +43,7 @@
     "prepublishOnly": "bun run ci"
   },
   "dependencies": {
+    "dayjs": "^1.11.20",
     "redaxios": "^0.5.1"
   },
   "devDependencies": {