tsense 0.0.17 → 0.2.0-next.0

package/dist/filters/url.js

@@ -0,0 +1,93 @@
+const ARRAY_OPERATORS = new Set(["notIn"]);
+function serializeValue(value) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    return String(value);
+}
+function coerceValue(raw, columnType) {
+    if (columnType === "number") {
+        return Number(raw);
+    }
+    if (columnType === "boolean") {
+        return raw === "true";
+    }
+    if (columnType === "date") {
+        return new Date(raw);
+    }
+    return raw;
+}
+export function serializeFilter(filter, descriptor) {
+    const params = new URLSearchParams();
+    const columnMap = new Map(descriptor.columns.map((c) => [c.key, c]));
+    for (const [key, value] of Object.entries(filter)) {
+        const column = columnMap.get(key);
+        if (!column || value == null) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 1) {
+                params.set(key, serializeValue(value[0]));
+            }
+            else if (value.length > 1) {
+                params.set(key, value.map((v) => serializeValue(v)).join(","));
+            }
+            continue;
+        }
+        if (typeof value === "object" && !(value instanceof Date)) {
+            for (const [op, opValue] of Object.entries(value)) {
+                if (opValue == null) {
+                    continue;
+                }
+                if (Array.isArray(opValue)) {
+                    params.set(`${key}.${op}`, opValue.map((v) => serializeValue(v)).join(","));
+                }
+                else {
+                    params.set(`${key}.${op}`, serializeValue(opValue));
+                }
+            }
+            continue;
+        }
+        params.set(key, serializeValue(value));
+    }
+    return params;
+}
+export function deserializeFilter(params, descriptor) {
+    const result = {};
+    const columnMap = new Map(descriptor.columns.map((c) => [c.key, c]));
+    for (const [paramKey, rawValue] of params.entries()) {
+        const dotIndex = paramKey.indexOf(".");
+        if (dotIndex !== -1) {
+            const field = paramKey.slice(0, dotIndex);
+            const operator = paramKey.slice(dotIndex + 1);
+            const column = columnMap.get(field);
+            if (!column) {
+                continue;
+            }
+            const existing = (result[field] ?? {});
+            if (ARRAY_OPERATORS.has(operator)) {
+                existing[operator] = rawValue
+                    .split(",")
+                    .map((v) => coerceValue(v, column.type));
+            }
+            else {
+                existing[operator] = coerceValue(rawValue, column.type);
+            }
+            result[field] = existing;
+            continue;
+        }
+        const column = columnMap.get(paramKey);
+        if (!column) {
+            continue;
+        }
+        if (rawValue.includes(",")) {
+            result[paramKey] = rawValue
+                .split(",")
+                .map((v) => coerceValue(v, column.type));
+        }
+        else {
+            result[paramKey] = coerceValue(rawValue, column.type);
+        }
+    }
+    return result;
+}

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export type { TsenseFieldMeta, TsenseFieldType } from "./env.js";
+export { rank } from "./rank.js";
 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, ProjectSearch, SearchListOptions, SearchListResult, SearchOptions, SearchOptionsPlain, SearchOptionsWithOmit, SearchOptionsWithPick, SearchResult, SyncConfig, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult, } from "./types.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";

package/dist/index.js

@@ -1,3 +1,4 @@
+export { rank } from "./rank.js";
 export { DateTransformer } from "./transformers/date.js";
 export { defaultTransformers } from "./transformers/defaults.js";
 export { TSense } from "./tsense.js";

package/dist/migrator.d.ts

@@ -5,7 +5,7 @@ export declare class TSenseMigrator {
     private localFields;
     private defaultSortingField;
     private axios;
-    constructor(collectionName: string, localFields: FieldSchema[], defaultSortingField: string | undefined, axios: AxiosInstance);
+    constructor(collectionName: string, localFields: readonly FieldSchema[], defaultSortingField: string | undefined, axios: AxiosInstance);
     sync(): Promise<void>;
     private exists;
     private getRemoteFields;

package/dist/migrator.js

@@ -1,61 +1,50 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 const COMPARABLE_KEYS = ["type", "facet", "sort", "index", "optional"];
-const NESTED_TYPES = ["object", "object[]"];
+const NESTED_TYPES = new Set(["object", "object[]"]);
 export class TSenseMigrator {
+    collectionName;
+    localFields;
+    defaultSortingField;
+    axios;
     constructor(collectionName, localFields, defaultSortingField, axios) {
         this.collectionName = collectionName;
         this.localFields = localFields;
         this.defaultSortingField = defaultSortingField;
         this.axios = axios;
     }
-    sync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const exists = yield this.exists();
-            if (!exists) {
-                return yield this.create();
-            }
-            const remoteFields = yield this.getRemoteFields();
-            const diff = this.diff(remoteFields);
-            if (!diff.toAdd.length && !diff.toRemove.length && !diff.toModify.length) {
-                return;
-            }
-            const patched = yield this.patch(diff);
-            if (patched)
-                return;
-            yield this.drop();
-            yield this.create();
-        });
+    async sync() {
+        const exists = await this.exists();
+        if (!exists) {
+            return await this.create();
+        }
+        const remoteFields = await this.getRemoteFields();
+        const diff = this.diff(remoteFields);
+        if (!diff.toAdd.length && !diff.toRemove.length && !diff.toModify.length) {
+            return;
+        }
+        const patched = await this.patch(diff);
+        if (patched)
+            return;
+        await this.drop();
+        await this.create();
     }
-    exists() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.axios({
-                method: "GET",
-                url: `/collections/${this.collectionName}`,
-            })
-                .then(() => true)
-                .catch((e) => {
-                if (e.status === 404)
-                    return false;
-                throw e;
-            });
+    async exists() {
+        return await this.axios({
+            method: "GET",
+            url: `/collections/${this.collectionName}`,
+        })
+            .then(() => true)
+            .catch((e) => {
+            if (e.status === 404)
+                return false;
+            throw e;
         });
     }
-    getRemoteFields() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield this.axios({
-                method: "GET",
-                url: `/collections/${this.collectionName}`,
-            });
-            return data.fields;
+    async getRemoteFields() {
+        const { data } = await this.axios({
+            method: "GET",
+            url: `/collections/${this.collectionName}`,
         });
+        return data.fields;
     }
     diff(remote) {
         const remoteByName = new Map(remote.map((f) => [f.name, f]));
@@ -85,57 +74,50 @@ export class TSenseMigrator {
         return { toAdd, toRemove, toModify };
     }
     fieldsMatch(local, remote) {
-        var _a, _b;
         for (const key of COMPARABLE_KEYS) {
-            if (((_a = local[key]) !== null && _a !== void 0 ? _a : undefined) !== ((_b = remote[key]) !== null && _b !== void 0 ? _b : undefined)) {
+            if ((local[key] ?? undefined) !== (remote[key] ?? undefined)) {
                 return false;
             }
         }
         return true;
     }
-    patch(diff) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fields = [];
-            for (const field of diff.toRemove) {
-                fields.push({ name: field.name, drop: true });
-            }
-            for (const field of diff.toModify) {
-                fields.push({ name: field.name, drop: true });
-                fields.push(field);
-            }
-            for (const field of diff.toAdd) {
-                fields.push(field);
-            }
-            return yield this.axios({
-                method: "PATCH",
-                url: `/collections/${this.collectionName}`,
-                data: { fields },
-            })
-                .then(() => true)
-                .catch(() => false);
-        });
+    async patch(diff) {
+        const fields = [];
+        for (const field of diff.toRemove) {
+            fields.push({ name: field.name, drop: true });
+        }
+        for (const field of diff.toModify) {
+            fields.push({ name: field.name, drop: true });
+            fields.push(field);
+        }
+        for (const field of diff.toAdd) {
+            fields.push(field);
+        }
+        return await this.axios({
+            method: "PATCH",
+            url: `/collections/${this.collectionName}`,
+            data: { fields },
+        })
+            .then(() => true)
+            .catch(() => false);
     }
-    create() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const enable_nested_fields = this.localFields.some((f) => NESTED_TYPES.includes(f.type));
-            yield this.axios({
-                method: "POST",
-                url: "/collections",
-                data: {
-                    name: this.collectionName,
-                    fields: this.localFields,
-                    default_sorting_field: this.defaultSortingField,
-                    enable_nested_fields,
-                },
-            });
+    async create() {
+        const enable_nested_fields = this.localFields.some((f) => NESTED_TYPES.has(f.type));
+        await this.axios({
+            method: "POST",
+            url: "/collections",
+            data: {
+                name: this.collectionName,
+                fields: this.localFields,
+                default_sorting_field: this.defaultSortingField,
+                enable_nested_fields,
+            },
         });
     }
-    drop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.axios({
-                method: "DELETE",
-                url: `/collections/${this.collectionName}`,
-            });
+    async drop() {
+        await this.axios({
+            method: "DELETE",
+            url: `/collections/${this.collectionName}`,
         });
     }
 }

package/dist/rank.d.ts

@@ -0,0 +1,7 @@
+export declare function rank<T>({ db, id_key, ts }: {
+    db: T[];
+    id_key: keyof T;
+    ts: {
+        id: string;
+    }[];
+}): T[];

package/dist/rank.js

@@ -0,0 +1,12 @@
+export function rank({ db, id_key, ts, }) {
+    const mapped = new Map(ts.map((t, i) => [t.id, i]));
+    const result = [];
+    for (const item of db) {
+        const position = mapped.get(String(item[id_key]));
+        if (position == null) {
+            continue;
+        }
+        result[position] = item;
+    }
+    return result.filter(Boolean);
+}

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

@@ -0,0 +1,60 @@
+import { type ReactNode } from "react";
+import type { FilterValue } from "../filters/filter-state.js";
+import type { FilterDescriptor } from "../filters/index.js";
+import type { FilterFor } from "../types.js";
+export type FieldSelectSlotProps = {
+    columns: FilterDescriptor["columns"];
+    value: string | undefined;
+    onChange: (field: string) => void;
+};
+export type ConditionSelectSlotProps = {
+    conditions: FilterDescriptor["columns"][number]["conditions"];
+    value: string | undefined;
+    onChange: (condition: string) => void;
+    disabled: boolean;
+};
+export type ValueInputSlotProps = {
+    column: FilterDescriptor["columns"][number];
+    condition: string;
+    value: FilterValue;
+    onChange: (value: FilterValue) => void;
+};
+export type RemoveButtonSlotProps = {
+    onClick: () => void;
+};
+export type AddButtonSlotProps = {
+    onClick: () => void;
+};
+export type PresetButtonSlotProps = {
+    preset: {
+        field: string;
+        name: string;
+    };
+    onClick: () => void;
+};
+export type RowSlotProps = {
+    index: number;
+    fieldSelect: ReactNode;
+    conditionSelect: ReactNode;
+    valueInput: ReactNode | null;
+    removeButton: ReactNode;
+};
+export type RootSlotProps = {
+    rows: ReactNode;
+    addButton: ReactNode;
+    presets: ReactNode | null;
+};
+type FilterBuilderProps<T> = {
+    descriptor: FilterDescriptor<T>;
+    onChange?: (filter: FilterFor<T>) => void;
+    renderRoot?: (props: RootSlotProps) => ReactNode;
+    renderRow?: (props: RowSlotProps) => ReactNode;
+    renderFieldSelect?: (props: FieldSelectSlotProps) => ReactNode;
+    renderConditionSelect?: (props: ConditionSelectSlotProps) => ReactNode;
+    renderValueInput?: (props: ValueInputSlotProps) => ReactNode;
+    renderAddButton?: (props: AddButtonSlotProps) => ReactNode;
+    renderRemoveButton?: (props: RemoveButtonSlotProps) => ReactNode;
+    renderPresetButton?: (props: PresetButtonSlotProps) => ReactNode;
+};
+export declare function FilterBuilder<T>({ descriptor, onChange, renderRoot, renderRow, renderFieldSelect, renderConditionSelect, renderValueInput, renderAddButton, renderRemoveButton, renderPresetButton }: FilterBuilderProps<T>): ReactNode;
+export {};

package/dist/react/filter-builder.js

@@ -0,0 +1,102 @@
+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";
+function defaultFieldSelect({ columns, value, onChange, }) {
+    return (_jsxs("select", { className: "rounded border px-2 py-1", value: value ?? "", onChange: (e) => onChange(e.target.value), children: [_jsx("option", { value: "", children: "Column" }), columns.map((col) => (_jsx("option", { value: col.key, children: col.label }, col.key)))] }));
+}
+function defaultConditionSelect({ conditions, value, onChange, disabled, }) {
+    return (_jsxs("select", { className: "rounded border px-2 py-1", value: value ?? "", onChange: (e) => onChange(e.target.value), disabled: disabled, children: [_jsx("option", { value: "", children: "Condition" }), conditions.map((c) => (_jsx("option", { value: c.key, children: c.label }, c.key)))] }));
+}
+function formatDateForInput(date) {
+    if (!(date instanceof Date))
+        return "";
+    return date.toISOString().slice(0, 10);
+}
+function parseDateInput(str) {
+    if (!str)
+        return undefined;
+    return new Date(str + "T00:00:00Z");
+}
+function asTuple(value) {
+    if (Array.isArray(value)) {
+        return [value[0], value[1]];
+    }
+    return [undefined, undefined];
+}
+function defaultValueInput({ column, condition, value, onChange, }) {
+    if (condition === "between" && column.type === "date") {
+        const tuple = asTuple(value);
+        return (_jsxs("div", { className: "flex items-center gap-1", children: [_jsx("input", { className: "rounded border px-2 py-1", type: "date", value: formatDateForInput(tuple[0]), onChange: (e) => onChange([parseDateInput(e.target.value), tuple[1]]) }), _jsx("span", { className: "text-sm text-gray-500", children: "and" }), _jsx("input", { className: "rounded border px-2 py-1", type: "date", value: formatDateForInput(tuple[1]), onChange: (e) => onChange([tuple[0], parseDateInput(e.target.value)]) })] }));
+    }
+    if (condition === "between") {
+        const tuple = asTuple(value);
+        return (_jsxs("div", { className: "flex items-center gap-1", children: [_jsx("input", { className: "w-24 rounded border px-2 py-1", type: "number", value: String(tuple[0] ?? ""), onChange: (e) => onChange([Number(e.target.value), tuple[1]]) }), _jsx("span", { className: "text-sm text-gray-500", children: "and" }), _jsx("input", { className: "w-24 rounded border px-2 py-1", type: "number", value: String(tuple[1] ?? ""), onChange: (e) => onChange([tuple[0], Number(e.target.value)]) })] }));
+    }
+    if (column.values) {
+        const selected = Array.isArray(value) ? value : [];
+        return (_jsx("div", { className: "flex flex-wrap gap-2", children: column.values.map((v) => {
+                const checked = selected.includes(v.value);
+                return (_jsxs("label", { className: "flex items-center gap-1 text-sm", children: [_jsx("input", { type: "checkbox", checked: checked, onChange: () => onChange(checked
+                                ? selected.filter((s) => s !== v.value)
+                                : [...selected, v.value]) }), v.label] }, v.value));
+            }) }));
+    }
+    if (column.type === "date") {
+        return (_jsx("input", { className: "rounded border px-2 py-1", type: "date", value: formatDateForInput(value), onChange: (e) => onChange(parseDateInput(e.target.value)) }));
+    }
+    if (column.type === "number") {
+        return (_jsx("input", { className: "rounded border px-2 py-1", type: "number", value: String(value ?? ""), onChange: (e) => onChange(Number(e.target.value)) }));
+    }
+    if (column.type === "boolean") {
+        return (_jsxs("select", { className: "rounded border px-2 py-1", value: value == null ? "" : String(value), onChange: (e) => onChange(e.target.value === "true"), children: [_jsx("option", { value: "", children: "Value" }), _jsx("option", { value: "true", children: "true" }), _jsx("option", { value: "false", children: "false" })] }));
+    }
+    return (_jsx("input", { className: "rounded border px-2 py-1", type: "text", value: typeof value === "string" ? value : "", onChange: (e) => onChange(e.target.value) }));
+}
+function defaultRemoveButton({ onClick }) {
+    return (_jsx("button", { className: "text-red-500 hover:text-red-700", onClick: onClick, children: "\u00D7" }));
+}
+function defaultAddButton({ onClick }) {
+    return (_jsx("button", { className: "text-blue-500 hover:text-blue-700", onClick: onClick, children: "+ Add filter" }));
+}
+function defaultPresetButton({ preset, onClick }) {
+    return (_jsx("button", { className: "rounded bg-gray-100 px-2 py-1 text-sm hover:bg-gray-200", onClick: onClick, children: preset.name }));
+}
+export function FilterBuilder({ descriptor, onChange, renderRoot, renderRow, renderFieldSelect, renderConditionSelect, renderValueInput, renderAddButton, renderRemoveButton, renderPresetButton, }) {
+    const filters = useFilterBuilder(descriptor);
+    const onChangeRef = useRef(onChange);
+    onChangeRef.current = onChange;
+    useEffect(() => {
+        onChangeRef.current?.(filters.result);
+    }, [filters.result]);
+    const FieldSelect = renderFieldSelect ?? defaultFieldSelect;
+    const ConditionSelect = renderConditionSelect ?? defaultConditionSelect;
+    const ValueInput = renderValueInput ?? defaultValueInput;
+    const RemoveButton = renderRemoveButton ?? defaultRemoveButton;
+    const AddButton = renderAddButton ?? defaultAddButton;
+    const PresetButton = renderPresetButton ?? defaultPresetButton;
+    const rows = filters.rows.map((row, i) => {
+        const fieldSelect = (_jsx(FieldSelect, { columns: filters.columns, value: row.field, onChange: (field) => filters.setField(i, field) }));
+        const conditionSelect = (_jsx(ConditionSelect, { conditions: row.field ? filters.conditionsFor(row.field) : [], value: row.condition, onChange: (condition) => filters.setCondition(i, condition), disabled: !row.field }));
+        const column = row.field
+            ? filters.columns.find((c) => c.key === row.field)
+            : undefined;
+        const valueInput = row.field && row.condition && column ? (_jsx(ValueInput, { column: column, condition: row.condition, value: row.value, onChange: (v) => filters.setValue(i, v) })) : null;
+        const removeButton = _jsx(RemoveButton, { onClick: () => filters.remove(i) });
+        if (renderRow) {
+            return (_jsx(Fragment, { children: renderRow({
+                    index: i,
+                    fieldSelect,
+                    conditionSelect,
+                    valueInput,
+                    removeButton,
+                }) }, row.id));
+        }
+        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 (_jsxs("div", { className: "flex flex-col gap-2", children: [rows, addButton, presets] }));
+}

package/dist/react/index.d.ts

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

package/dist/react/index.js

@@ -0,0 +1,2 @@
+export { FilterBuilder } from "./filter-builder.js";
+export { useFilterBuilder } from "./use-filter-builder.js";

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

@@ -0,0 +1,23 @@
+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[];
+    add: () => void;
+    remove: (index: number) => void;
+    setField: (index: number, field: string) => void;
+    setCondition: (index: number, condition: string) => void;
+    setValue: (index: number, value: FilterValue) => void;
+    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;
+export {};

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

@@ -0,0 +1,22 @@
+import { useMemo, useState } from "react";
+import { addRow, applyPreset as applyPresetState, buildResult, clearState, columnFor, conditionsFor, createInitialState, 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,
+        add: () => setState(addRow),
+        remove: (index) => setState((s) => removeRow(s, index)),
+        setField: (index, field) => setState((s) => setRowField(s, index, field)),
+        setCondition: (index, condition) => setState((s) => setRowCondition(s, index, condition)),
+        setValue: (index, value) => setState((s) => setRowValue(s, index, value)),
+        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

@@ -1,6 +1,6 @@
 import type { Type } from "arktype";
 import redaxios from "redaxios";
-import type { DeleteResult, FieldSchema, FilterFor, ProjectSearch, SearchListOptions, SearchListResult, SearchOptions, SearchOptionsPlain, SearchResult, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult } from "./types.js";
+import type { DeleteResult, FieldSchema, FilterFor, ProjectSearch, ScopedCollection, SearchListOptions, SearchListResult, SearchOptions, SearchOptionsPlain, SearchResult, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult } from "./types.js";
 declare const redaxiosInstance: {
     <T>(urlOrConfig: string | redaxios.Options, config?: redaxios.Options | undefined, _method?: any, data?: any, _undefined?: undefined): Promise<redaxios.Response<T>>;
     request: (<T_1 = any>(config?: redaxios.Options | undefined) => Promise<redaxios.Response<T_1>>) | (<T_2 = any>(url: string, config?: redaxios.Options | undefined) => Promise<redaxios.Response<T_2>>);
@@ -53,19 +53,18 @@ declare const redaxiosInstance: {
         spread<Args, R>(fn: (...args: Args[]) => R): (array: Args[]) => R;
         CancelToken: AbortController;
         defaults: redaxios.Options;
-        create: any;
+        create: /*elided*/ any;
     };
 };
 export type AxiosInstance = ReturnType<typeof redaxiosInstance.create>;
 export declare class TSense<T extends Type> {
     private options;
-    fields: FieldSchema[];
+    readonly fields: readonly FieldSchema[];
     private axios;
     private synced;
     private fieldTransformers;
     private dataSyncConfig?;
     infer: T["infer"];
-    getFields(): FieldSchema[];
     constructor(options: TsenseOptions<T>);
     private getBaseType;
     private inferType;
@@ -77,6 +76,7 @@ export declare class TSense<T extends Type> {
     syncSchema(): Promise<void>;
     private buildObjectFilter;
     private buildFilter;
+    private validateFields;
     private buildSort;
     create(): Promise<this>;
     drop(): Promise<void>;
@@ -92,5 +92,6 @@ export declare class TSense<T extends Type> {
     syncData(options?: SyncOptions): Promise<SyncResult>;
     private purgeOrphans;
     exportIds(): Promise<string[]>;
+    scoped(baseFilter: FilterFor<T["infer"]>): ScopedCollection<T["infer"]>;
 }
 export {};