@thingd/sdk 0.72.0 → 0.74.2

package/dist/thingd.js

@@ -0,0 +1,236 @@
+import { HttpThingStore } from "./client/http-thing-store.js";
+import { Scheduler } from "./scheduler.js";
+import { InMemoryThingStore } from "./stores/in-memory-thing-store.js";
+import { NativeThingStore } from "./stores/native-thing-store.js";
+export class ThingD {
+    path;
+    store;
+    static async open(pathOrConfig, options = {}) {
+        const resolvedOptions = resolveOpenOptions(pathOrConfig, options);
+        return new ThingD(resolvedOptions.path, await openStore(resolvedOptions.path, resolvedOptions));
+    }
+    scheduler;
+    constructor(path, store) {
+        this.path = path;
+        this.store = store;
+        this.scheduler = new Scheduler(store);
+    }
+    put(collection, object, options) {
+        return this.store.put(collection, object, options);
+    }
+    get(collection, id) {
+        return this.store.get(collection, id);
+    }
+    delete(collection, id) {
+        return this.store.delete(collection, id);
+    }
+    listObjects(collection, options) {
+        return this.store.listObjects?.(collection, options) ?? Promise.resolve([]);
+    }
+    search(query, options = {}) {
+        return this.store.search(query, options);
+    }
+    async searchObjects(query, options = {}) {
+        const results = await this.search(query, options);
+        return results
+            .filter((r) => r.kind === "object")
+            .map((r) => r.value);
+    }
+    vectorSearch(collection, queryVector, options = {}) {
+        return (this.store.vectorSearch?.(collection, queryVector, options) ??
+            Promise.reject(new Error("Vector search not supported by this driver")));
+    }
+    async putBatch(collection, objects) {
+        return (this.store.putBatch?.(collection, objects) ??
+            Promise.reject(new Error("Batch put not supported by this driver")));
+    }
+    async deleteBatch(collection, ids) {
+        return (this.store.deleteBatch?.(collection, ids) ??
+            Promise.reject(new Error("Batch delete not supported by this driver")));
+    }
+    async getBatch(collection, ids) {
+        return (this.store.getBatch?.(collection, ids) ??
+            Promise.reject(new Error("Batch get not supported by this driver")));
+    }
+    events = {
+        append: (stream, event) => this.store.appendEvent(stream, event),
+        list: (stream, options) => this.store.listEvents(stream, options),
+    };
+    queue(name) {
+        return {
+            push: (payload, options) => this.store.pushJob(name, payload, options),
+            claim: (options) => this.store.claimJob(name, options),
+            ack: (jobId) => this.store.ackJob(name, jobId),
+            nack: (jobId, options) => this.store.nackJob(name, jobId, options),
+            list: () => this.store.listJobs(name),
+            dead: () => this.store.listDeadJobs(name),
+        };
+    }
+    links = {
+        create: (fromRef, linkType, toRef, weight, metadataJson) => this.store.createLink?.(fromRef, linkType, toRef, weight, metadataJson) ??
+            Promise.reject(new Error("Graph links not supported by this driver")),
+        delete: (id) => this.store.deleteLink?.(id) ?? Promise.resolve(false),
+        get: (id) => this.store.getLink?.(id) ?? Promise.resolve(null),
+        neighbors: (reference, direction = "Both", options = {}) => this.store.getNeighbors?.(reference, direction, options) ?? Promise.resolve([]),
+    };
+    aggregate = {
+        count: (collection, options = {}) => this.store.aggregate?.(collection, { ...options, function: "count" }) ??
+            Promise.reject(new Error("Aggregation not supported by this driver")),
+        sum: (collection, field, options = {}) => this.store.aggregate?.(collection, { ...options, function: "sum", field }) ??
+            Promise.reject(new Error("Aggregation not supported by this driver")),
+        avg: (collection, field, options = {}) => this.store.aggregate?.(collection, { ...options, function: "avg", field }) ??
+            Promise.reject(new Error("Aggregation not supported by this driver")),
+        min: (collection, field, options = {}) => this.store.aggregate?.(collection, { ...options, function: "min", field }) ??
+            Promise.reject(new Error("Aggregation not supported by this driver")),
+        max: (collection, field, options = {}) => this.store.aggregate?.(collection, { ...options, function: "max", field }) ??
+            Promise.reject(new Error("Aggregation not supported by this driver")),
+    };
+    timeseries(collection, options) {
+        return (this.store.timeseries?.(collection, options) ??
+            Promise.reject(new Error("Time-series aggregation not supported by this driver")));
+    }
+    async schema(collection, options) {
+        return (this.store.schema?.(collection, options) ??
+            Promise.reject(new Error("schema not supported by this driver")));
+    }
+    nlq = {
+        query: (question, options) => {
+            return (this.store.nlqQuery?.(question, options) ??
+                Promise.reject(new Error("NLQ not supported by this driver")));
+        },
+    };
+    async close() {
+        await this.store.close?.();
+    }
+    backupTo(path) {
+        if (this.store.backupTo) {
+            this.store.backupTo(path);
+        }
+        else {
+            throw new Error("Backup is only supported on the native durable storage driver");
+        }
+    }
+    walCheckpoint() {
+        if (this.store.walCheckpoint) {
+            return this.store.walCheckpoint();
+        }
+        throw new Error("Checkpoint is only supported on the native durable storage driver");
+    }
+    async countObjects() {
+        return this.store.countObjects?.() ?? 0;
+    }
+    async countObjectsInCollection(collection) {
+        return this.store.countObjectsInCollection?.(collection) ?? 0;
+    }
+    async countEvents() {
+        return this.store.countEvents?.() ?? 0;
+    }
+    async countActiveJobs() {
+        return this.store.countActiveJobs?.() ?? 0;
+    }
+    async countDeadJobs() {
+        return this.store.countDeadJobs?.() ?? 0;
+    }
+    async countLinks() {
+        return this.store.countLinks?.() ?? 0;
+    }
+    async listCollections() {
+        return this.store.listCollections?.() ?? [];
+    }
+    async listStreams() {
+        return this.store.listStreams?.() ?? [];
+    }
+    async listQueues() {
+        return this.store.listQueues?.() ?? [];
+    }
+    /** Create a functional index on a JSON body field for a collection. */
+    async createIndex(collection, field) {
+        await this.store.createIndex?.(collection, field);
+    }
+    /** List all custom functional indexes. */
+    async listIndexes() {
+        return this.store.listIndexes?.() ?? [];
+    }
+    /** List available connector types. Requires sidecar/HTTP store (returns [] for in-memory/native). */
+    async listConnectors() {
+        return this.store.listConnectors?.() ?? [];
+    }
+    /**
+     * Discover the schema of an external table or file source.
+     * Requires sidecar/HTTP store — throws on in-memory/native stores.
+     */
+    async discoverConnectorSchema(type, query, auth) {
+        const result = await this.store.discoverConnectorSchema?.(type, query, auth);
+        if (!result) {
+            throw new Error(`Connector '${type}' not supported by this store`);
+        }
+        return result;
+    }
+    /**
+     * Import data from an external source into a thingd collection.
+     * Requires sidecar/HTTP store — throws on in-memory/native stores.
+     */
+    async connectorSync(type, options) {
+        const result = await this.store.connectorSync?.(type, options);
+        if (!result) {
+            throw new Error(`Connector '${type}' not supported by this store`);
+        }
+        return result;
+    }
+}
+function resolveOpenOptions(pathOrConfig, options) {
+    const config = typeof pathOrConfig === "string"
+        ? {
+            path: pathOrConfig,
+        }
+        : (pathOrConfig ?? {});
+    const path = config.url ?? config.path ?? process.env.THINGD_URL ?? ":memory:";
+    const driver = options.driver ?? config.driver ?? inferDriver(path);
+    return {
+        ...config,
+        ...options,
+        path,
+        driver,
+        authToken: options.authToken ??
+            config.authToken ??
+            config.apiKey ??
+            options.apiKey ??
+            process.env.THINGD_AUTH_TOKEN,
+    };
+}
+function inferDriver(path) {
+    if (isCloudPath(path)) {
+        return "cloud";
+    }
+    return undefined;
+}
+function isCloudPath(path) {
+    return path.startsWith("http://") || path.startsWith("https://") || path.startsWith("thingd://");
+}
+async function openStore(path, options) {
+    if (options.store) {
+        return options.store;
+    }
+    if (options.driver === "cloud") {
+        return HttpThingStore.open({
+            url: path,
+            authToken: options.authToken,
+            instanceSlug: options.instanceSlug,
+        });
+    }
+    const hasNative = await NativeThingStore.isAvailable();
+    if (options.driver === "native") {
+        if (!hasNative) {
+            throw new Error(`The native thingd driver is not available. Install @thingd/native with "npm install @thingd/native". For monorepo development: "pnpm --filter thingd-native build".`);
+        }
+        return NativeThingStore.open(path);
+    }
+    // Auto-detect and promote file paths to native store when available, with a warning fallback to memory.
+    if (!options.driver && path !== ":memory:") {
+        if (hasNative) {
+            return NativeThingStore.open(path);
+        }
+        console.warn(`Warning: The native thingd driver is not available. Falling back to the temporary in-memory store. Data will not persist. Run "pnpm --filter @thingd/native build" or install "@thingd/native" to enable native persistence.`);
+    }
+    return new InMemoryThingStore();
+}

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export type { AggregateFunction, AggregateGroupResult, AggregateOptions, AggregateResult, BackupCapableThingStore, CollectionSchema, ConnectorAuth, ConnectorSchema, ConnectorSyncOptions, ConnectorSyncResult, FieldSchema, FilterOperator, Link, LinkDirection, LinkQueryOptions, ListEventsOptions, ListObjectsOptions, LocalThingDConnection, MemoryEvent, MemoryObject, MemoryQueue, MemorySearchOptions, MemorySearchResult, NlqIntent, NlqOptions, NlqResult, PutOptions, QueueClaimOptions, QueueJob, QueueJobOptions, QueueJobPayload, QueueJobResult, QueueJobStatus, QueueNackOptions, ReconnectableThingStore, SchemaOptions, SortBy, SortDirection, StoredMemoryEvent, StoredMemoryObject, ThingDConnection, ThingDeleteResult, ThingStore, TimeBucket, TimeSeriesBucket, TimeSeriesOptions, TimeSeriesResult, VectorSearchHit, VectorSearchOptions, WalCheckpointResult, } from "../types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,uBAAuB,EACvB,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACnB,WAAW,EACX,cAAc,EACd,IAAI,EACJ,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,kBAAkB,EAClB,SAAS,EACT,UAAU,EACV,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,QAAQ,EACR,eAAe,EACf,eAAe,EACf,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,uBAAuB,EACvB,aAAa,EACb,MAAM,EACN,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,aAAa,CAAC"}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -0,0 +1,448 @@
+export type MemoryObject = {
+    id: string;
+    [key: string]: unknown;
+};
+export type StoredMemoryObject = MemoryObject & {
+    collection: string;
+    createdAt: string;
+    updatedAt: string;
+    version: number;
+};
+export type MemoryEvent = {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+};
+export type StoredMemoryEvent = MemoryEvent & {
+    id: string;
+    stream: string;
+    sequence: number;
+    createdAt: string;
+    idempotencyKey?: string;
+};
+export type QueueJobPayload = Record<string, unknown>;
+export type QueueJobStatus = "ready" | "leased" | "completed" | "dead";
+export type QueueJob = {
+    id: string;
+    queue: string;
+    payload: QueueJobPayload;
+    status: QueueJobStatus;
+    attempts: number;
+    maxAttempts: number;
+    createdAt: string;
+    availableAt: string;
+    leasedAt?: string;
+    leaseExpiresAt?: string;
+    completedAt?: string;
+    deadAt?: string;
+    lastError?: string;
+    /** Priority for claim ordering (higher = claimed sooner). Default: 0. */
+    priority?: number;
+};
+export type QueueJobOptions = {
+    idempotencyKey?: string;
+    maxAttempts?: number;
+    delayMs?: number;
+    /** Priority for claim ordering (higher = claimed sooner). Default: 0. */
+    priority?: number;
+};
+export type QueueClaimOptions = {
+    leaseMs?: number;
+};
+export type QueueNackOptions = {
+    delayMs?: number;
+    error?: string;
+};
+export type QueueJobResult = {
+    ok: true;
+    job: QueueJob;
+} | {
+    ok: false;
+    reason: "not_found" | "not_leased" | "terminal";
+};
+export type ThingDeleteResult = {
+    deleted: boolean;
+};
+export type WalCheckpointResult = {
+    framesBefore: number;
+    framesAfter: number;
+};
+export interface ReconnectableThingStore {
+    reconnect(): Promise<void>;
+}
+export interface BackupCapableThingStore {
+    backupTo(path: string): void;
+    walCheckpoint(): WalCheckpointResult;
+}
+export type MemorySearchOptions = {
+    collections?: string[];
+    limit?: number;
+    filter?: Record<string, unknown>;
+};
+export type MemorySearchResult = {
+    kind: "object";
+    id: string;
+    collection: string;
+    score: number;
+    value: StoredMemoryObject;
+} | {
+    kind: "event";
+    id: string;
+    stream: string;
+    score: number;
+    value: StoredMemoryEvent;
+};
+export type VectorSearchOptions = {
+    topK?: number;
+    filter?: Record<string, unknown>;
+};
+export type VectorSearchHit = {
+    id: string;
+    score: number;
+    value: StoredMemoryObject;
+};
+export type LinkDirection = "Outgoing" | "Incoming" | "Both";
+export type LinkQueryOptions = {
+    linkType?: string;
+    limit?: number;
+};
+export type Link = {
+    id: string;
+    fromRef: string;
+    linkType: string;
+    toRef: string;
+    weight?: number;
+    metadataJson: string;
+    createdAt: string;
+};
+export type ConnectorAuth = {
+    host: string;
+    port: number;
+    database: string;
+    username: string;
+    password: string;
+    sslMode?: "disable" | "prefer" | "require";
+};
+export type ConnectorSchema = {
+    name: string;
+    columns: {
+        name: string;
+        dataType: "text" | "integer" | "float" | "boolean" | "timestamp" | "json" | "unknown";
+        nullable: boolean;
+        sampleValues: unknown[];
+    }[];
+    estimatedRows: number | null;
+};
+export type ConnectorSyncResult = {
+    imported: number;
+    collection: string;
+};
+export type ConnectorSyncOptions = {
+    auth?: ConnectorAuth;
+    source?: string;
+    collection: string;
+    query: string;
+    batchSize?: number;
+    columnMapping?: Record<string, string>;
+    syncStrategy?: "full" | "incremental";
+};
+export type MemoryQueue = {
+    push(payload: QueueJobPayload, options?: QueueJobOptions): Promise<QueueJob>;
+    claim(options?: QueueClaimOptions): Promise<QueueJob | null>;
+    ack(jobId: string): Promise<QueueJobResult>;
+    nack(jobId: string, options?: QueueNackOptions): Promise<QueueJobResult>;
+    list(): Promise<QueueJob[]>;
+    dead(): Promise<QueueJob[]>;
+};
+export type ListEventsOptions = {
+    fromSequence?: number;
+    limit?: number;
+    since?: string;
+};
+export type SortDirection = "asc" | "desc";
+export type SortBy = {
+    /** Column name or JSON path like "$.price" for body field sorting */
+    field: string;
+    direction?: SortDirection;
+};
+export type FilterOperator = {
+    $gt?: unknown;
+    $gte?: unknown;
+    $lt?: unknown;
+    $lte?: unknown;
+    $ne?: unknown;
+    $in?: unknown[];
+    $like?: string;
+};
+export type ListObjectsOptions = {
+    limit?: number;
+    offset?: number;
+    filter?: Record<string, unknown | FilterOperator>;
+    sortBy?: SortBy;
+};
+export type PutOptions = {
+    /** Optional expected version for optimistic locking (CAS). */
+    expectedVersion?: number;
+};
+export type AggregateFunction = "count" | "sum" | "avg" | "min" | "max";
+export type AggregateOptions = {
+    function: AggregateFunction;
+    field?: string;
+    groupBy?: string;
+    filter?: Record<string, unknown>;
+};
+export type AggregateGroupResult = {
+    key: string;
+    value: number;
+};
+export type AggregateResult = {
+    total: number;
+    groups: AggregateGroupResult[];
+};
+export type TimeBucket = "hour" | "day" | "week" | "month";
+export type TimeSeriesOptions = {
+    function: AggregateFunction;
+    field?: string;
+    bucket: TimeBucket;
+    from?: string;
+    to?: string;
+    filter?: Record<string, unknown>;
+};
+export type TimeSeriesBucket = {
+    label: string;
+    value: number;
+};
+export type TimeSeriesResult = {
+    buckets: TimeSeriesBucket[];
+};
+export type FieldSchema = {
+    name: string;
+    type: string;
+    nullable: boolean;
+    sampleValues: unknown[];
+};
+export type CollectionSchema = {
+    name: string;
+    objectCount: number;
+    fields: FieldSchema[];
+};
+export type SchemaOptions = {
+    sampleSize?: number;
+};
+export type NlqIntent = {
+    action: string;
+    collection: string;
+    function?: string;
+    field?: string;
+    groupBy?: string;
+    bucket?: string;
+    query?: string;
+    limit?: number;
+};
+export type NlqResult = {
+    answer: string;
+    data: unknown;
+    intent: NlqIntent;
+};
+export type NlqOptions = {
+    collection?: string;
+    model?: string;
+    endpoint?: string;
+    apiKey?: string;
+};
+export type Schedule = {
+    id: string;
+    expression: string;
+    timezone?: string;
+    payload: Record<string, unknown>;
+    enabled: boolean;
+    nextRunAt: string;
+    lastRunAt?: string;
+    lastStatus?: "completed" | "failed" | "running";
+    lastError?: string;
+    lastDurationMs?: number;
+    runCount: number;
+    failCount: number;
+    consecutiveFails: number;
+    maxConsecutiveFails: number;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown>;
+};
+export type ScheduleHandler = (schedule: Schedule, context: ScheduleContext) => Promise<void>;
+export type ScheduleContext = {
+    log: (message: string) => void;
+    fail: (error: string) => void;
+};
+export type ScheduleOptions = {
+    expression?: string;
+    intervalMs?: number;
+    timezone?: string;
+    payload?: Record<string, unknown>;
+    enabled?: boolean;
+    maxConsecutiveFails?: number;
+    metadata?: Record<string, unknown>;
+    handler: ScheduleHandler;
+};
+export type ScheduleOnceOptions = {
+    runAt: string;
+    payload?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    handler: ScheduleHandler;
+};
+export type ScheduleIntervalOptions = {
+    intervalMs: number;
+    payload?: Record<string, unknown>;
+    enabled?: boolean;
+    maxConsecutiveFails?: number;
+    metadata?: Record<string, unknown>;
+    handler: ScheduleHandler;
+};
+export type ScheduleEvent = {
+    scheduleId: string;
+    expression: string;
+    status: "started" | "completed" | "failed" | "disabled";
+    timestamp: string;
+    durationMs?: number;
+    error?: string;
+    runCount: number;
+    failCount: number;
+};
+export type SchedulerStats = {
+    total: number;
+    enabled: number;
+    disabled: number;
+    running: number;
+    nextRun: {
+        id: string;
+        at: string;
+    } | null;
+};
+export type SchedulerEventType = "started" | "completed" | "failed" | "disabled";
+export type SchedulerListener = (event: ScheduleEvent) => void;
+export type SchedulerFacade = {
+    schedule(id: string, options: ScheduleOptions): Promise<Schedule>;
+    scheduleOnce(id: string, options: ScheduleOnceOptions): Promise<Schedule>;
+    scheduleInterval(id: string, options: ScheduleIntervalOptions): Promise<Schedule>;
+    get(id: string): Promise<Schedule | null>;
+    list(): Promise<Schedule[]>;
+    pause(id: string): Promise<Schedule>;
+    resume(id: string): Promise<Schedule>;
+    remove(id: string): Promise<boolean>;
+    run(id: string): Promise<void>;
+    stats(): Promise<SchedulerStats>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    on(event: SchedulerEventType, listener: SchedulerListener): void;
+    off(event: SchedulerEventType, listener: SchedulerListener): void;
+};
+/**
+ * Typed interface for a thingd database connection returned by `ThingD.open()`.
+ * Consumers can use this for type-safe dependency injection instead of `any`:
+ *
+ * ```ts
+ * import type { ThingDConnection } from "@thingd/sdk";
+ * private readonly db: ThingDConnection;
+ * ```
+ */
+export interface ThingDConnection {
+    put(collection: string, object: MemoryObject, options?: PutOptions): Promise<StoredMemoryObject>;
+    get<T = StoredMemoryObject>(collection: string, id: string): Promise<T | null>;
+    delete(collection: string, id: string): Promise<ThingDeleteResult>;
+    listObjects<T = StoredMemoryObject>(collection: string, options?: ListObjectsOptions): Promise<T[]>;
+    search(query: string, options?: MemorySearchOptions): Promise<MemorySearchResult[]>;
+    searchObjects<T = StoredMemoryObject>(query: string, options?: MemorySearchOptions): Promise<T[]>;
+    putBatch(collection: string, objects: MemoryObject[]): Promise<StoredMemoryObject[]>;
+    deleteBatch(collection: string, ids: string[]): Promise<number>;
+    getBatch<T = StoredMemoryObject>(collection: string, ids: string[]): Promise<(T | null)[]>;
+    readonly events: {
+        append(stream: string, event: MemoryEvent): Promise<StoredMemoryEvent>;
+        list<T = StoredMemoryEvent>(stream?: string, options?: ListEventsOptions): Promise<T[]>;
+    };
+    queue(name: string): MemoryQueue;
+    close(): Promise<void>;
+    countObjects(): Promise<number>;
+    countObjectsInCollection(collection: string): Promise<number>;
+    countEvents(): Promise<number>;
+    countActiveJobs(): Promise<number>;
+    countDeadJobs(): Promise<number>;
+    countLinks(): Promise<number>;
+    readonly links: {
+        create(fromRef: string, linkType: string, toRef: string, weight?: number, metadataJson?: string): Promise<Link>;
+        delete(id: string): Promise<boolean>;
+        get(id: string): Promise<Link | null>;
+        neighbors(reference: string, direction?: LinkDirection, options?: LinkQueryOptions): Promise<Link[]>;
+    };
+    listCollections(): Promise<string[]>;
+    listStreams(): Promise<string[]>;
+    listQueues(): Promise<string[]>;
+    createIndex(collection: string, field: string): Promise<void>;
+    listIndexes(): Promise<Array<[string, string]>>;
+    listConnectors(): Promise<string[]>;
+    discoverConnectorSchema(type: string, query: string, auth?: ConnectorAuth): Promise<ConnectorSchema>;
+    connectorSync(type: string, options: ConnectorSyncOptions): Promise<ConnectorSyncResult>;
+    schema(collection?: string, options?: SchemaOptions): Promise<CollectionSchema[]>;
+    readonly nlq: {
+        query(question: string, options?: NlqOptions): Promise<NlqResult>;
+    };
+    readonly scheduler: SchedulerFacade;
+    readonly aggregate: {
+        count(collection: string, options?: Omit<AggregateOptions, "function">): Promise<AggregateResult>;
+        sum(collection: string, field: string, options?: Omit<AggregateOptions, "function" | "field">): Promise<AggregateResult>;
+        avg(collection: string, field: string, options?: Omit<AggregateOptions, "function" | "field">): Promise<AggregateResult>;
+        min(collection: string, field: string, options?: Omit<AggregateOptions, "function" | "field">): Promise<AggregateResult>;
+        max(collection: string, field: string, options?: Omit<AggregateOptions, "function" | "field">): Promise<AggregateResult>;
+    };
+    timeseries(collection: string, options: TimeSeriesOptions): Promise<TimeSeriesResult>;
+    vectorSearch(collection: string, queryVector: number[], options?: VectorSearchOptions): Promise<VectorSearchHit[]>;
+}
+/** Local-driver connection capabilities unavailable on cloud/browser stores. */
+export interface LocalThingDConnection extends ThingDConnection {
+    backupTo(path: string): void;
+    walCheckpoint(): WalCheckpointResult;
+}
+export interface ThingStore {
+    put(collection: string, object: MemoryObject, options?: PutOptions): Promise<StoredMemoryObject>;
+    get<T = StoredMemoryObject>(collection: string, id: string): Promise<T | null>;
+    delete(collection: string, id: string): Promise<ThingDeleteResult>;
+    listObjects<T = StoredMemoryObject>(collection: string, options?: ListObjectsOptions): Promise<T[]>;
+    appendEvent(stream: string, event: MemoryEvent): Promise<StoredMemoryEvent>;
+    listEvents<T = StoredMemoryEvent>(stream?: string, options?: ListEventsOptions): Promise<T[]>;
+    pushJob(queue: string, payload: QueueJobPayload, options?: QueueJobOptions): Promise<QueueJob>;
+    claimJob(queue: string, options?: QueueClaimOptions): Promise<QueueJob | null>;
+    ackJob(queue: string, jobId: string): Promise<QueueJobResult>;
+    nackJob(queue: string, jobId: string, options?: QueueNackOptions): Promise<QueueJobResult>;
+    listJobs(queue: string): Promise<QueueJob[]>;
+    listDeadJobs(queue: string): Promise<QueueJob[]>;
+    search(query: string, options?: MemorySearchOptions): Promise<MemorySearchResult[]>;
+    countObjects?(): Promise<number>;
+    countObjectsInCollection?(collection: string): Promise<number>;
+    countEvents?(): Promise<number>;
+    countActiveJobs?(): Promise<number>;
+    countDeadJobs?(): Promise<number>;
+    countLinks?(): Promise<number>;
+    createLink?(fromRef: string, linkType: string, toRef: string, weight?: number, metadataJson?: string): Promise<Link>;
+    deleteLink?(id: string): Promise<boolean>;
+    getLink?(id: string): Promise<Link | null>;
+    getNeighbors?(reference: string, direction: LinkDirection, options: LinkQueryOptions): Promise<Link[]>;
+    putBatch?(collection: string, objects: MemoryObject[]): Promise<StoredMemoryObject[]>;
+    deleteBatch?(collection: string, ids: string[]): Promise<number>;
+    getBatch?(collection: string, ids: string[]): Promise<(StoredMemoryObject | null)[]>;
+    listCollections?(): Promise<string[]>;
+    listStreams?(): Promise<string[]>;
+    listQueues?(): Promise<string[]>;
+    createIndex?(collection: string, field: string): Promise<void>;
+    listIndexes?(): Promise<Array<[string, string]>>;
+    listConnectors?(): Promise<string[]>;
+    discoverConnectorSchema?(type: string, query: string, auth?: ConnectorAuth): Promise<ConnectorSchema>;
+    connectorSync?(type: string, options: ConnectorSyncOptions): Promise<ConnectorSyncResult>;
+    aggregate?(collection: string, options: AggregateOptions): Promise<AggregateResult>;
+    timeseries?(collection: string, options: TimeSeriesOptions): Promise<TimeSeriesResult>;
+    schema?(collection?: string, options?: SchemaOptions): Promise<CollectionSchema[]>;
+    nlqQuery?(question: string, options?: NlqOptions): Promise<NlqResult>;
+    vectorSearch?(collection: string, queryVector: number[], options?: VectorSearchOptions): Promise<VectorSearchHit[]>;
+    close?(): Promise<void>;
+    backupTo?(path: string): void;
+    walCheckpoint?(): WalCheckpointResult;
+}
+//# sourceMappingURL=types.d.ts.map