@luxdb/sdk 1.2.1 → 1.4.1

package/dist/types/index.d.ts

@@ -0,0 +1,62 @@
+import Redis, { type RedisOptions } from 'ioredis';
+import { LuxAuthClient, type LuxAuthOptions } from './auth';
+import { createProjectClient, LuxProjectClient, type LuxProjectOptions } from './project';
+import { TimeSeriesNamespace, VectorNamespace } from './namespaces';
+import { TableQueryBuilder, type TableQueryBuilderOptions } from './table';
+import type { KSubEvent, TableRow, TSAddOptions, TSMRangeResult, TSRangeOptions, TSSample, VSearchResult } from './types';
+export type { LuxAuthKey, LuxAuthChangeEvent, LuxAuthOptions, LuxAuthSession, LuxAuthStateChangeCallback, LuxAuthStorage, LuxAuthSubscription, LuxAuthUser, LuxOAuthProvider, LuxOAuthUrl, LuxSignInWithOAuthOptions, LuxCreateApiKeyOptions, LuxSignInOptions, LuxSignUpOptions, } from './auth';
+export { createProjectClient, LuxProjectClient, };
+export { createBrowserClient } from './browser';
+export type { LuxBrowserClientOptions } from './browser';
+export { createServerClient } from './ssr';
+export type { LuxCookieMethods, LuxCookieOptions, LuxServerClientOptions } from './ssr';
+export type { LuxProjectOptions, LuxTableColumn, LuxVectorSearchOptions, } from './project';
+export type { KSubEvent, LuxError, LuxResult, TableChangeEvent, TableChangeType, TableErrorEvent, TableRow, TableSchema, TSAddOptions, TSMRangeResult, TSRangeOptions, TSSample, VSearchResult, } from './types';
+export { TableQueryBuilder, TableSubscription } from './table';
+export type { TableQueryBuilderOptions } from './table';
+export type LuxClientOptions = RedisOptions & LuxAuthOptions;
+export type LuxAuthNamespace = Redis['auth'] & LuxAuthClient;
+export declare class Lux extends Redis {
+    vectors: VectorNamespace;
+    timeseries: TimeSeriesNamespace;
+    auth: LuxAuthNamespace;
+    authApi: LuxAuthClient;
+    private realtimeManager?;
+    constructor(options?: LuxClientOptions | RedisOptions | string);
+    table<T extends TableRow = TableRow>(name: string, options?: TableQueryBuilderOptions<T>): TableQueryBuilder<T>;
+    _subscribePattern(pattern: string, handler: (event: KSubEvent) => void): Promise<() => void>;
+    _tselect(args: string[]): Promise<TableRow[]>;
+    vset(key: string, vector: number[], options?: {
+        metadata?: Record<string, unknown>;
+        ex?: number;
+        px?: number;
+    }): Promise<'OK'>;
+    vget(key: string): Promise<{
+        dims: number;
+        vector: number[];
+        metadata?: Record<string, unknown>;
+    } | null>;
+    vsearch(query: number[], options: {
+        k: number;
+        filter?: {
+            key: string;
+            value: string;
+        };
+        meta?: boolean;
+    }): Promise<VSearchResult[]>;
+    vcard(): Promise<number>;
+    tsadd(key: string, timestamp: number | '*', value: number, options?: TSAddOptions): Promise<number>;
+    tsmadd(...entries: [string, number | '*', number][]): Promise<string>;
+    tsget(key: string): Promise<TSSample | null>;
+    tsrange(key: string, from: number | '-', to: number | '+', options?: TSRangeOptions): Promise<TSSample[]>;
+    tsmrange(from: number | '-', to: number | '+', filter: string, options?: TSRangeOptions): Promise<TSMRangeResult[]>;
+    tsinfo(key: string): Promise<Record<string, unknown>>;
+    ksub(patterns: string[], handler: (event: KSubEvent) => void): {
+        unsubscribe: () => void;
+        connection: Redis;
+    };
+}
+export declare function createClient(url: string, key: string, options?: Omit<LuxProjectOptions, 'url' | 'key'>): LuxProjectClient;
+export declare function createClient(options?: LuxClientOptions | RedisOptions | string): Lux;
+export declare function createAuthClient(options: LuxAuthOptions): LuxAuthClient;
+export default Lux;

package/dist/types/namespaces.d.ts

@@ -0,0 +1,56 @@
+import type { TSAddOptions, TSMRangeResult, TSRangeOptions, TSSample, VSearchResult } from './types';
+interface NamespaceClient {
+    call(command: string, ...args: Array<string | number>): Promise<unknown>;
+    vget(key: string): Promise<{
+        dims: number;
+        vector: number[];
+        metadata?: Record<string, unknown>;
+    } | null>;
+    vsearch(query: number[], options: {
+        k: number;
+        filter?: {
+            key: string;
+            value: string;
+        };
+        meta?: boolean;
+    }): Promise<VSearchResult[]>;
+    vcard(): Promise<number>;
+    tsadd(key: string, timestamp: number | '*', value: number, options?: TSAddOptions): Promise<number>;
+    tsget(key: string): Promise<TSSample | null>;
+    tsrange(key: string, from: number | '-', to: number | '+', options?: TSRangeOptions): Promise<TSSample[]>;
+    tsmrange(from: number | '-', to: number | '+', filter: string, options?: TSRangeOptions): Promise<TSMRangeResult[]>;
+    tsinfo(key: string): Promise<Record<string, unknown>>;
+}
+export declare class VectorNamespace {
+    private client;
+    constructor(client: NamespaceClient);
+    set(key: string, vector: number[], metadata?: Record<string, unknown>): Promise<string>;
+    get(key: string): Promise<{
+        dims: number;
+        vector: number[];
+        metadata?: Record<string, unknown>;
+    } | null>;
+    search(query: number[], options: {
+        topK: number;
+        filter?: {
+            key: string;
+            value: string;
+        };
+        meta?: boolean;
+    }): Promise<VSearchResult[]>;
+    count(): Promise<number>;
+}
+export declare class TimeSeriesNamespace {
+    private client;
+    constructor(client: NamespaceClient);
+    add(key: string, value: number, options?: {
+        timestamp?: number | '*';
+        retention?: number;
+        labels?: Record<string, string>;
+    }): Promise<number>;
+    get(key: string): Promise<TSSample | null>;
+    range(key: string, from: number | '-', to: number | '+', options?: TSRangeOptions): Promise<TSSample[]>;
+    mrange(from: number | '-', to: number | '+', filter: string, options?: TSRangeOptions): Promise<TSMRangeResult[]>;
+    info(key: string): Promise<Record<string, unknown>>;
+}
+export {};

package/dist/types/project.d.ts

@@ -0,0 +1,121 @@
+import { LuxAuthClient, type LuxAuthOptions } from './auth';
+import type { LuxResult } from './types';
+export interface LuxProjectOptions {
+    url: string;
+    key: string;
+    fetch?: typeof fetch;
+    auth?: Omit<LuxAuthOptions, 'httpUrl' | 'apiKey' | 'fetch'>;
+}
+export interface LuxTableColumn {
+    name: string;
+    type: 'STR' | 'INT' | 'FLOAT' | 'BOOL' | 'TIMESTAMP' | 'UUID';
+    primaryKey?: boolean;
+    unique?: boolean;
+    notNull?: boolean;
+    references?: string;
+    onDelete?: string;
+}
+export interface LuxVectorSearchOptions {
+    vector: number[];
+    k?: number;
+    filter?: string;
+    filter_value?: string;
+}
+type QueryValue = string | number | boolean | null;
+type FilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'is';
+interface QueryFilter {
+    column: string;
+    operator: FilterOperator;
+    value: QueryValue;
+}
+interface QueryOrder {
+    column: string;
+    ascending: boolean;
+}
+export declare class LuxProjectClient {
+    readonly url: string;
+    readonly key: string;
+    readonly auth: LuxAuthClient;
+    private fetchImpl;
+    constructor(options: LuxProjectOptions);
+    table<T extends Record<string, unknown> = Record<string, unknown>>(name: string): LuxProjectTable<T>;
+    ping(): Promise<LuxResult<unknown>>;
+    createTable(name: string, columns: Array<string | LuxTableColumn>): Promise<LuxResult<unknown>>;
+    exec(command: string | string[]): Promise<LuxResult<unknown>>;
+    vectorSet(key: string, vector: number[], metadata?: Record<string, unknown>): Promise<LuxResult<unknown>>;
+    vectorSearch(options: LuxVectorSearchOptions): Promise<LuxResult<unknown>>;
+    tsAdd(key: string, value: number, options?: {
+        timestamp?: number | '*';
+        labels?: Record<string, string>;
+        retention?: number;
+    }): Promise<LuxResult<unknown>>;
+    tsRange(key: string, options?: {
+        from?: number | '-';
+        to?: number | '+';
+        count?: number;
+    }): Promise<LuxResult<unknown>>;
+    request<T = unknown>(method: string, path: string, body?: unknown): Promise<LuxResult<T>>;
+}
+export declare class LuxProjectTable<T extends Record<string, unknown>> {
+    private client;
+    private name;
+    constructor(client: LuxProjectClient, name: string);
+    select(columns?: string): LuxProjectSelectBuilder<T, T[]>;
+    insert(row: Partial<T> & Record<string, QueryValue>): LuxProjectInsertBuilder<unknown>;
+    insert(rows: Array<Partial<T> & Record<string, QueryValue>>): LuxProjectInsertBuilder<unknown[]>;
+    update(patch: Partial<T> & Record<string, QueryValue>): LuxProjectMutationBuilder<unknown>;
+    delete(): LuxProjectMutationBuilder<unknown>;
+    count(): Promise<LuxResult<number>>;
+}
+declare abstract class LuxProjectThenable<TResult> implements PromiseLike<LuxResult<TResult>> {
+    then<TFulfilled = LuxResult<TResult>, TRejected = never>(onfulfilled?: ((value: LuxResult<TResult>) => TFulfilled | PromiseLike<TFulfilled>) | null, onrejected?: ((reason: unknown) => TRejected | PromiseLike<TRejected>) | null): Promise<TFulfilled | TRejected>;
+    catch<TRejected = never>(onrejected?: ((reason: unknown) => TRejected | PromiseLike<TRejected>) | null): Promise<LuxResult<TResult> | TRejected>;
+    finally(onfinally?: (() => void) | null): Promise<LuxResult<TResult>>;
+    abstract execute(): Promise<LuxResult<TResult>>;
+}
+declare abstract class LuxProjectFilterBuilder<TResult, TSelf> extends LuxProjectThenable<TResult> {
+    protected client: LuxProjectClient;
+    protected tableName: string;
+    protected filters: QueryFilter[];
+    protected orderBy?: QueryOrder;
+    protected limitCount?: number;
+    protected offsetCount?: number;
+    protected constructor(client: LuxProjectClient, tableName: string);
+    eq(column: string, value: QueryValue): TSelf;
+    neq(column: string, value: QueryValue): TSelf;
+    gt(column: string, value: QueryValue): TSelf;
+    gte(column: string, value: QueryValue): TSelf;
+    lt(column: string, value: QueryValue): TSelf;
+    lte(column: string, value: QueryValue): TSelf;
+    is(column: string, value: QueryValue): TSelf;
+    protected addFilter(column: string, operator: FilterOperator, value: QueryValue): TSelf;
+    protected filteredQueryParams(): URLSearchParams;
+}
+export declare class LuxProjectSelectBuilder<T extends Record<string, unknown>, TResult> extends LuxProjectFilterBuilder<TResult, LuxProjectSelectBuilder<T, TResult>> {
+    private columns;
+    private expectSingle;
+    constructor(client: LuxProjectClient, tableName: string, columns: string);
+    order(column: string, options?: {
+        ascending?: boolean;
+    }): this;
+    limit(count: number): this;
+    range(from: number, to: number): this;
+    single(): LuxProjectSelectBuilder<T, T>;
+    execute(): Promise<LuxResult<TResult>>;
+}
+export declare class LuxProjectInsertBuilder<TResult> extends LuxProjectThenable<TResult> {
+    private client;
+    private tableName;
+    private rowOrRows;
+    constructor(client: LuxProjectClient, tableName: string, rowOrRows: Record<string, QueryValue> | Array<Record<string, QueryValue>>);
+    execute(): Promise<LuxResult<TResult>>;
+}
+export declare class LuxProjectMutationBuilder<TResult> extends LuxProjectFilterBuilder<TResult, LuxProjectMutationBuilder<TResult>> {
+    private method;
+    private body?;
+    constructor(client: LuxProjectClient, tableName: string, method: 'PATCH' | 'DELETE', body?: Record<string, QueryValue> | undefined);
+    execute(): Promise<LuxResult<TResult>>;
+}
+export declare function createProjectClient(options: LuxProjectOptions): LuxProjectClient;
+export declare function createClient(url: string, key: string, options?: Omit<LuxProjectOptions, 'url' | 'key'>): LuxProjectClient;
+export {};

package/dist/types/realtime.d.ts

@@ -0,0 +1,16 @@
+import type Redis from 'ioredis';
+import type { KSubEvent } from './types';
+interface RealtimeClient {
+    duplicate(): Redis;
+}
+export declare class LuxRealtimeManager {
+    private client;
+    private connection;
+    private initPromise;
+    private nextHandlerId;
+    private handlersByPattern;
+    constructor(client: RealtimeClient);
+    private ensureConnection;
+    subscribe(pattern: string, handler: (event: KSubEvent) => void): Promise<() => void>;
+}
+export {};

package/dist/types/ssr.d.ts

@@ -0,0 +1,22 @@
+import { type LuxProjectOptions } from './project';
+export interface LuxCookieOptions {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    sameSite?: 'lax' | 'strict' | 'none';
+    secure?: boolean;
+}
+export interface LuxCookieMethods {
+    get(name: string): string | null | undefined | Promise<string | null | undefined>;
+    set?(name: string, value: string, options?: LuxCookieOptions): void | Promise<void>;
+    remove?(name: string, options?: LuxCookieOptions): void | Promise<void>;
+}
+export interface LuxServerClientOptions extends Omit<LuxProjectOptions, 'url' | 'key' | 'auth'> {
+    auth?: Omit<NonNullable<LuxProjectOptions['auth']>, 'storage'> & {
+        cookieOptions?: LuxCookieOptions;
+    };
+    cookies: LuxCookieMethods;
+}
+export declare function createServerClient(url: string, key: string, options: LuxServerClientOptions): import("./project").LuxProjectClient;

package/dist/types/table.d.ts

@@ -0,0 +1,92 @@
+import type { KSubEvent, LuxError, LuxResult, TableChangeEvent, TableErrorEvent, TableRow, TableSchema, VSearchResult } from './types';
+type TableWhereOp = '=' | '!=' | '>' | '<' | '>=' | '<=';
+type TableWhereValue = string | number | boolean;
+interface TableWhereCondition {
+    field: string;
+    op: TableWhereOp;
+    value: TableWhereValue;
+}
+interface TableClient {
+    call(command: string, ...args: Array<string | number>): Promise<unknown>;
+    _tselect(args: string[]): Promise<TableRow[]>;
+    _subscribePattern(pattern: string, handler: (event: KSubEvent) => void): Promise<() => void>;
+    vsearch(query: number[], options: {
+        k: number;
+        filter?: {
+            key: string;
+            value: string;
+        };
+        meta?: boolean;
+    }): Promise<VSearchResult[]>;
+}
+export interface TableQueryBuilderOptions<T extends TableRow> {
+    schema?: TableSchema<T>;
+}
+export declare class TableSubscription<T extends TableRow> {
+    private client;
+    private table;
+    private selectArgsBuilder;
+    private handlers;
+    private knownRows;
+    private unsubscribeFn;
+    private initError;
+    constructor(client: TableClient, table: string, selectArgsBuilder: (extra?: TableWhereCondition[]) => string[], initError?: LuxError | null);
+    on(event: 'insert' | 'update' | 'delete' | 'change', handler: (event: TableChangeEvent<T>) => void): this;
+    on(event: 'error', handler: (event: TableErrorEvent) => void): this;
+    unsubscribe(): Promise<void>;
+    private emitError;
+    private emitChange;
+    private extractPkFromKey;
+    private fetchMatches;
+    private start;
+    private handleRawChange;
+}
+export declare class TableQueryBuilder<T extends TableRow = TableRow> {
+    private client;
+    private name;
+    private conditions;
+    private orderField?;
+    private orderDir?;
+    private limitCount?;
+    private offsetCount?;
+    private joinClause?;
+    private similarityClause?;
+    private selectClause;
+    private expectSingle;
+    private schema?;
+    constructor(client: TableClient, name: string, options?: TableQueryBuilderOptions<T>);
+    private validateRow;
+    private buildSelectArgs;
+    select(columns?: string): this;
+    single(): this;
+    where(field: string, op: TableWhereOp, value: TableWhereValue): this;
+    eq(field: string, value: TableWhereValue): this;
+    neq(field: string, value: TableWhereValue): this;
+    gt(field: string, value: TableWhereValue): this;
+    gte(field: string, value: TableWhereValue): this;
+    lt(field: string, value: TableWhereValue): this;
+    lte(field: string, value: TableWhereValue): this;
+    orderBy(field: string, dir?: 'asc' | 'desc'): this;
+    order(field: string, options?: {
+        ascending?: boolean;
+    }): this;
+    limit(n: number): this;
+    offset(n: number): this;
+    join(table: string, alias: string, onLeft: string, onRight: string): this;
+    similar(field: string, vector: number[], options: {
+        k: number;
+        filter?: {
+            key: string;
+            value: string;
+        };
+    }): this;
+    private parseSimilarityPk;
+    run(): Promise<LuxResult<T[] | T>>;
+    then<TFulfilled = LuxResult<T[] | T>, TRejected = never>(onfulfilled?: ((value: LuxResult<T[] | T>) => TFulfilled | PromiseLike<TFulfilled>) | null, onrejected?: ((reason: unknown) => TRejected | PromiseLike<TRejected>) | null): Promise<TFulfilled | TRejected>;
+    insert(data: Record<string, unknown>): Promise<LuxResult<number>>;
+    update(id: number | string, data: Record<string, unknown>): Promise<LuxResult<number>>;
+    update(data: Record<string, unknown>): Promise<LuxResult<number>>;
+    delete(...ids: Array<number | string>): Promise<LuxResult<number>>;
+    subscribe(): TableSubscription<T>;
+}
+export {};

package/dist/types/types.d.ts

@@ -0,0 +1,70 @@
+export interface VSearchResult {
+    key: string;
+    similarity: number;
+    metadata?: Record<string, unknown>;
+}
+export interface TSSample {
+    timestamp: number;
+    value: number;
+}
+export interface TSAddOptions {
+    retention?: number;
+    labels?: Record<string, string>;
+}
+export interface TSRangeOptions {
+    aggregation?: {
+        type: 'avg' | 'sum' | 'min' | 'max' | 'count' | 'first' | 'last' | 'range' | 'std.p' | 'std.s' | 'var.p' | 'var.s';
+        bucketSize: number;
+    };
+}
+export interface TSMRangeResult {
+    key: string;
+    labels: Record<string, string>;
+    samples: TSSample[];
+}
+export interface KSubEvent {
+    pattern: string;
+    key: string;
+    operation: string;
+}
+export interface TableRow {
+    id?: number | string;
+    [field: string]: unknown;
+}
+export interface LuxError {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+export interface LuxResult<T> {
+    data: T | null;
+    error: LuxError | null;
+}
+type SchemaSafeParse<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: unknown;
+};
+export interface TableSchema<T> {
+    parse?: (input: unknown) => T;
+    safeParse?: (input: unknown) => SchemaSafeParse<T>;
+}
+export type TableChangeType = 'insert' | 'update' | 'delete' | 'change' | 'error';
+export interface TableChangeEvent<T extends TableRow> {
+    type: Exclude<TableChangeType, 'error'>;
+    table: string;
+    pk: string;
+    operation: string;
+    new: T | null;
+    old: T | null;
+    changed?: string[];
+    raw?: KSubEvent;
+}
+export interface TableErrorEvent {
+    type: 'error';
+    table: string;
+    error: LuxError;
+}
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1,4 @@
+import type { LuxError, LuxResult } from './types';
+export declare function ok<T>(data: T): LuxResult<T>;
+export declare function err<T>(code: string, message: string, details?: unknown): LuxResult<T>;
+export declare function toLuxError(error: unknown, fallbackCode?: string): LuxError;

package/package.json

@@ -1,12 +1,46 @@
 {
     "name": "@luxdb/sdk",
-    "version": "1.2.1",
+    "version": "1.4.1",
     "description": "Lux SDK - ioredis extended with vector search, time series, and realtime key subscriptions",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
+    "main": "./dist/cjs/index.js",
+    "module": "./dist/esm/index.js",
+    "types": "./dist/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/types/index.d.ts",
+            "import": "./dist/esm/index.js",
+            "require": "./dist/cjs/index.js",
+            "default": "./dist/esm/index.js"
+        },
+        "./project": {
+            "types": "./dist/types/project.d.ts",
+            "import": "./dist/esm/project.js",
+            "require": "./dist/cjs/project.js",
+            "default": "./dist/esm/project.js"
+        },
+        "./auth": {
+            "types": "./dist/types/auth.d.ts",
+            "import": "./dist/esm/auth.js",
+            "require": "./dist/cjs/auth.js",
+            "default": "./dist/esm/auth.js"
+        },
+        "./browser": {
+            "types": "./dist/types/browser.d.ts",
+            "import": "./dist/esm/browser.js",
+            "require": "./dist/cjs/browser.js",
+            "default": "./dist/esm/browser.js"
+        },
+        "./ssr": {
+            "types": "./dist/types/ssr.d.ts",
+            "import": "./dist/esm/ssr.js",
+            "require": "./dist/cjs/ssr.js",
+            "default": "./dist/esm/ssr.js"
+        }
+    },
     "files": ["dist"],
     "scripts": {
-        "build": "tsc",
+        "build": "bun scripts/build.ts",
+        "test": "bun test tests",
         "prepublishOnly": "bun run build"
     },
     "dependencies": {

package/dist/index.d.ts

@@ -1,121 +0,0 @@
-import Redis, { type RedisOptions } from 'ioredis';
-export interface VSearchResult {
-    key: string;
-    similarity: number;
-    metadata?: Record<string, unknown>;
-}
-export interface TSSample {
-    timestamp: number;
-    value: number;
-}
-export interface TSAddOptions {
-    retention?: number;
-    labels?: Record<string, string>;
-}
-export interface TSRangeOptions {
-    aggregation?: {
-        type: 'avg' | 'sum' | 'min' | 'max' | 'count' | 'first' | 'last' | 'range' | 'std.p' | 'std.s' | 'var.p' | 'var.s';
-        bucketSize: number;
-    };
-}
-export interface TSMRangeResult {
-    key: string;
-    labels: Record<string, string>;
-    samples: TSSample[];
-}
-export interface KSubEvent {
-    pattern: string;
-    key: string;
-    operation: string;
-}
-export interface TableRow {
-    id: number;
-    [field: string]: unknown;
-}
-declare class TableQueryBuilder {
-    private client;
-    private name;
-    private conditions;
-    private orderField?;
-    private orderDir?;
-    private limitCount?;
-    private joinTable?;
-    constructor(client: Lux, name: string);
-    where(field: string, op: '=' | '!=' | '>' | '<' | '>=' | '<=', value: string | number | boolean): this;
-    orderBy(field: string, dir?: 'asc' | 'desc'): this;
-    limit(n: number): this;
-    join(table: string): this;
-    run(): Promise<TableRow[]>;
-    insert(data: Record<string, unknown>): Promise<number>;
-    update(id: number, data: Record<string, unknown>): Promise<string>;
-    delete(...ids: number[]): Promise<number>;
-}
-declare class VectorNamespace {
-    private client;
-    constructor(client: Lux);
-    set(key: string, vector: number[], metadata?: Record<string, unknown>): Promise<string>;
-    get(key: string): Promise<{
-        dims: number;
-        vector: number[];
-        metadata?: Record<string, unknown>;
-    } | null>;
-    search(query: number[], options: {
-        topK: number;
-        filter?: {
-            key: string;
-            value: string;
-        };
-        meta?: boolean;
-    }): Promise<VSearchResult[]>;
-    count(): Promise<number>;
-}
-declare class TimeSeriesNamespace {
-    private client;
-    constructor(client: Lux);
-    add(key: string, value: number, options?: {
-        timestamp?: number | '*';
-        retention?: number;
-        labels?: Record<string, string>;
-    }): Promise<number>;
-    get(key: string): Promise<TSSample | null>;
-    range(key: string, from: number | '-', to: number | '+', options?: TSRangeOptions): Promise<TSSample[]>;
-    mrange(from: number | '-', to: number | '+', filter: string, options?: TSRangeOptions): Promise<TSMRangeResult[]>;
-    info(key: string): Promise<Record<string, unknown>>;
-}
-export declare class Lux extends Redis {
-    vectors: VectorNamespace;
-    timeseries: TimeSeriesNamespace;
-    constructor(options?: RedisOptions | string);
-    table(name: string): TableQueryBuilder;
-    _tquery(args: string[]): Promise<TableRow[]>;
-    vset(key: string, vector: number[], options?: {
-        metadata?: Record<string, unknown>;
-        ex?: number;
-        px?: number;
-    }): Promise<'OK'>;
-    vget(key: string): Promise<{
-        dims: number;
-        vector: number[];
-        metadata?: Record<string, unknown>;
-    } | null>;
-    vsearch(query: number[], options: {
-        k: number;
-        filter?: {
-            key: string;
-            value: string;
-        };
-        meta?: boolean;
-    }): Promise<VSearchResult[]>;
-    vcard(): Promise<number>;
-    tsadd(key: string, timestamp: number | '*', value: number, options?: TSAddOptions): Promise<number>;
-    tsmadd(...entries: [string, number | '*', number][]): Promise<string>;
-    tsget(key: string): Promise<TSSample | null>;
-    tsrange(key: string, from: number | '-', to: number | '+', options?: TSRangeOptions): Promise<TSSample[]>;
-    tsmrange(from: number | '-', to: number | '+', filter: string, options?: TSRangeOptions): Promise<TSMRangeResult[]>;
-    tsinfo(key: string): Promise<Record<string, unknown>>;
-    ksub(patterns: string[], handler: (event: KSubEvent) => void): {
-        unsubscribe: () => void;
-        connection: Redis;
-    };
-}
-export default Lux;