@luxdb/sdk 1.4.2 → 2.0.0

package/dist/esm/table.js

@@ -1,4 +1,39 @@
 import { err, ok, toLuxError } from './utils.js';
+/** Serialize a field value: JSON objects/arrays round-trip as JSON text. */
+function serializeFieldValue(v) {
+    if (v !== null && typeof v === 'object') {
+        return JSON.stringify(v);
+    }
+    return String(v);
+}
+/** Serialize one WHERE condition into RESP tokens. */
+function serializeCondition(cond) {
+    if (cond.op === 'IN' || cond.op === 'NOT IN') {
+        const values = Array.isArray(cond.value) ? cond.value : [cond.value];
+        return [
+            cond.field,
+            ...(cond.op === 'NOT IN' ? ['NOT', 'IN'] : ['IN']),
+            '(',
+            ...values.map(String),
+            ')',
+        ];
+    }
+    if (cond.op === 'IS VALID')
+        return [cond.field, 'IS', 'VALID'];
+    if (cond.op === 'IS NOT VALID')
+        return [cond.field, 'IS', 'NOT', 'VALID'];
+    return [cond.field, cond.op, String(cond.value)];
+}
+/** Join serialized conditions with AND separators. */
+function serializeConditions(conditions) {
+    const out = [];
+    for (let i = 0; i < conditions.length; i++) {
+        out.push(...serializeCondition(conditions[i]));
+        if (i < conditions.length - 1)
+            out.push('AND');
+    }
+    return out;
+}
 export class TableSubscription {
     constructor(client, table, selectArgsBuilder, initError = null) {
         this.handlers = {
@@ -56,9 +91,10 @@ export class TableSubscription {
         try {
             const initial = await this.fetchMatches();
             for (const row of initial) {
-                if (row.id == null)
+                const id = row.id;
+                if (id == null)
                     continue;
-                this.knownRows.set(String(row.id), row);
+                this.knownRows.set(String(id), row);
             }
             const pattern = `_t:${this.table}:row:*`;
             this.unsubscribeFn = await this.client._subscribePattern(pattern, (raw) => {
@@ -108,7 +144,9 @@ export class TableSubscription {
             if (!previous || !next)
                 return;
             this.knownRows.set(pk, next);
-            const changed = Object.keys(next).filter((key) => previous[key] !== next[key]);
+            const previousRow = previous;
+            const nextRow = next;
+            const changed = Object.keys(nextRow).filter((key) => previousRow[key] !== nextRow[key]);
             this.emitChange({
                 type: 'update',
                 table: this.table,
@@ -128,6 +166,8 @@ export class TableSubscription {
 export class TableQueryBuilder {
     constructor(client, name, options) {
         this.conditions = [];
+        this.groupFields = [];
+        this.havingConditions = [];
         this.selectClause = '*';
         this.expectSingle = false;
         this.client = client;
@@ -153,18 +193,30 @@ export class TableQueryBuilder {
         const args = [this.selectClause, 'FROM', this.name];
         const allConditions = extra ? [...this.conditions, ...extra] : this.conditions;
         if (this.joinClause) {
-            args.push('JOIN', this.joinClause.table, this.joinClause.alias, 'ON', this.joinClause.onLeft, '=', this.joinClause.onRight);
+            args.push(...(this.joinClause.type === 'LEFT' ? ['LEFT', 'JOIN'] : ['JOIN']), this.joinClause.table, this.joinClause.alias, 'ON', this.joinClause.onLeft, '=', this.joinClause.onRight);
         }
         if (allConditions.length) {
-            args.push('WHERE');
-            for (let i = 0; i < allConditions.length; i++) {
-                const cond = allConditions[i];
+            args.push('WHERE', ...serializeConditions(allConditions));
+        }
+        if (this.groupFields.length) {
+            args.push('GROUP', 'BY', ...this.groupFields);
+        }
+        if (this.havingConditions.length) {
+            args.push('HAVING');
+            for (let i = 0; i < this.havingConditions.length; i++) {
+                const cond = this.havingConditions[i];
                 args.push(cond.field, cond.op, String(cond.value));
-                if (i < allConditions.length - 1) {
+                if (i < this.havingConditions.length - 1) {
                     args.push('AND');
                 }
             }
         }
+        if (this.similarityClause) {
+            args.push('NEAR', this.similarityClause.field, `[${this.similarityClause.vector.join(',')}]`, 'K', String(this.similarityClause.k));
+            if (this.similarityClause.threshold != null) {
+                args.push('THRESHOLD', String(this.similarityClause.threshold));
+            }
+        }
         if (this.orderField) {
             args.push('ORDER', 'BY', this.orderField, this.orderDir || 'ASC');
         }
@@ -209,6 +261,29 @@ export class TableQueryBuilder {
     lte(field, value) {
         return this.where(field, '<=', value);
     }
+    in(field, values) {
+        this.conditions.push({ field, op: 'IN', value: values });
+        return this;
+    }
+    notIn(field, values) {
+        this.conditions.push({ field, op: 'NOT IN', value: values });
+        return this;
+    }
+    /** Match rows where a JSON dot-path resolves to a present, non-null value. */
+    isValid(field) {
+        this.conditions.push({ field, op: 'IS VALID', value: '' });
+        return this;
+    }
+    /** Match rows where a JSON dot-path is absent or resolves to null. */
+    isNotValid(field) {
+        this.conditions.push({ field, op: 'IS NOT VALID', value: '' });
+        return this;
+    }
+    /** Match rows where an ARRAY column (or array-valued path) contains a value. */
+    contains(field, value) {
+        this.conditions.push({ field, op: 'CONTAINS', value });
+        return this;
+    }
     orderBy(field, dir = 'asc') {
         this.orderField = field;
         this.orderDir = dir.toUpperCase();
@@ -226,68 +301,41 @@ export class TableQueryBuilder {
         return this;
     }
     join(table, alias, onLeft, onRight) {
-        this.joinClause = { table, alias, onLeft, onRight };
+        this.joinClause = { type: 'INNER', table, alias, onLeft, onRight };
+        return this;
+    }
+    leftJoin(table, alias, onLeft, onRight) {
+        this.joinClause = { type: 'LEFT', table, alias, onLeft, onRight };
+        return this;
+    }
+    group(fields) {
+        this.groupFields = Array.isArray(fields)
+            ? fields
+            : fields.split(',').map((field) => field.trim()).filter(Boolean);
+        return this;
+    }
+    groupBy(fields) {
+        return this.group(fields);
+    }
+    having(field, op, value) {
+        this.havingConditions.push({ field, op, value });
         return this;
     }
-    similar(field, vector, options) {
+    near(field, vector, options = {}) {
         this.similarityClause = {
             field,
             vector,
-            k: options.k,
-            filter: options.filter,
+            k: options.k ?? 10,
+            threshold: options.threshold,
         };
         return this;
     }
-    parseSimilarityPk(result, field) {
-        const metadata = result.metadata;
-        if (metadata && typeof metadata === 'object') {
-            for (const key of ['id', 'pk', 'row_id']) {
-                const value = metadata[key];
-                if (value != null)
-                    return String(value);
-            }
-        }
-        const expectedPrefix = `${this.name}:${field}:`;
-        if (result.key.startsWith(expectedPrefix)) {
-            return result.key.slice(expectedPrefix.length);
-        }
-        const segments = result.key.split(':');
-        if (segments.length > 0) {
-            return segments[segments.length - 1] || null;
-        }
-        return null;
+    similar(field, vector, options = {}) {
+        return this.near(field, vector, options);
     }
     async run() {
         try {
-            let rows = [];
-            if (this.similarityClause) {
-                if (this.joinClause) {
-                    return err('SIMILAR_JOIN_UNSUPPORTED', 'similar(...) cannot be combined with join(...) yet');
-                }
-                const similarResults = await this.client.vsearch(this.similarityClause.vector, {
-                    k: this.similarityClause.k,
-                    filter: this.similarityClause.filter,
-                    meta: true,
-                });
-                for (const match of similarResults) {
-                    const pk = this.parseSimilarityPk(match, this.similarityClause.field);
-                    if (!pk)
-                        continue;
-                    const args = this.buildSelectArgs([{ field: 'id', op: '=', value: pk }]);
-                    const one = await this.client._tselect(args);
-                    if (one.length === 0)
-                        continue;
-                    rows.push({ ...one[0], _similarity: match.similarity });
-                }
-                if (this.offsetCount != null || this.limitCount != null) {
-                    const start = this.offsetCount ?? 0;
-                    const end = this.limitCount != null ? start + this.limitCount : undefined;
-                    rows = rows.slice(start, end);
-                }
-            }
-            else {
-                rows = await this.client._tselect(this.buildSelectArgs());
-            }
+            const rows = await this.client._tselect(this.buildSelectArgs());
             const validated = rows.map((row) => this.validateRow(row));
             if (this.expectSingle) {
                 if (validated.length === 0) {
@@ -311,7 +359,7 @@ export class TableQueryBuilder {
             }
             const args = [this.name];
             for (const [k, v] of Object.entries(data)) {
-                args.push(k, String(v));
+                args.push(k, serializeFieldValue(v));
             }
             const result = await this.client.call('TINSERT', ...args);
             return ok(parseInt(result, 10) || 0);
@@ -320,6 +368,26 @@ export class TableQueryBuilder {
             return err('TINSERT_ERROR', `Failed to insert into '${this.name}'`, toLuxError(error));
         }
     }
+    /** Declare a typed index on a JSON dot-path, e.g. ('meta.reactions.count', 'int'). */
+    async createIndex(path, type) {
+        try {
+            await this.client.call('TINDEX', this.name, path, type.toUpperCase());
+            return ok(true);
+        }
+        catch (error) {
+            return err('TINDEX_ERROR', `Failed to index '${path}'`, toLuxError(error));
+        }
+    }
+    /** Drop a previously declared JSON path index. */
+    async dropIndex(path) {
+        try {
+            await this.client.call('TDROPINDEX', this.name, path);
+            return ok(true);
+        }
+        catch (error) {
+            return err('TDROPINDEX_ERROR', `Failed to drop index '${path}'`, toLuxError(error));
+        }
+    }
     async update(idOrData, data) {
         try {
             const hasExplicitId = data !== undefined;
@@ -329,20 +397,14 @@ export class TableQueryBuilder {
             }
             const args = [this.name, 'SET'];
             for (const [k, v] of Object.entries(patch)) {
-                args.push(k, String(v));
+                args.push(k, serializeFieldValue(v));
             }
             args.push('WHERE');
             if (hasExplicitId) {
                 args.push('id', '=', String(idOrData));
             }
             else {
-                for (let i = 0; i < this.conditions.length; i++) {
-                    const cond = this.conditions[i];
-                    args.push(cond.field, cond.op, String(cond.value));
-                    if (i < this.conditions.length - 1) {
-                        args.push('AND');
-                    }
-                }
+                args.push(...serializeConditions(this.conditions));
             }
             const result = await this.client.call('TUPDATE', ...args);
             return ok(Number(result) || 0);
@@ -358,13 +420,7 @@ export class TableQueryBuilder {
                     return err('MISSING_WHERE', 'delete requires at least one filter');
                 }
                 const args = ['FROM', this.name, 'WHERE'];
-                for (let i = 0; i < this.conditions.length; i++) {
-                    const cond = this.conditions[i];
-                    args.push(cond.field, cond.op, String(cond.value));
-                    if (i < this.conditions.length - 1) {
-                        args.push('AND');
-                    }
-                }
+                args.push(...serializeConditions(this.conditions));
                 const result = await this.client.call('TDELETE', ...args);
                 return ok(Number(result) || 0);
             }
@@ -380,12 +436,6 @@ export class TableQueryBuilder {
         }
     }
     subscribe() {
-        if (this.similarityClause) {
-            return new TableSubscription(this.client, this.name, (extra) => this.buildSelectArgs(extra), {
-                code: 'SIMILAR_SUBSCRIBE_UNSUPPORTED',
-                message: 'subscribe() is not supported on similar(...) queries yet',
-            });
-        }
         return new TableSubscription(this.client, this.name, (extra) => this.buildSelectArgs(extra));
     }
 }

package/dist/types/auth.d.ts

@@ -11,6 +11,90 @@ export interface LuxAuthUser {
     user_metadata?: Record<string, unknown>;
     app_metadata?: Record<string, unknown>;
 }
+export type LuxUser = LuxAuthUser;
+export interface LuxAuthUserRow {
+    id: string;
+    email?: string;
+    phone?: string;
+    encrypted_password?: string;
+    email_confirmed_at?: number | null;
+    phone_confirmed_at?: number | null;
+    raw_user_meta_data?: string;
+    raw_app_meta_data?: string;
+    created_at?: number | null;
+    updated_at?: number | null;
+    last_sign_in_at?: number | null;
+    banned_until?: number | null;
+    deleted_at?: number | null;
+}
+export interface LuxAuthIdentityRow {
+    id: string;
+    user_id: string;
+    provider: string;
+    provider_id: string;
+    identity_data?: string;
+    created_at?: number | null;
+    updated_at?: number | null;
+}
+export interface LuxAuthSessionRow {
+    id: string;
+    user_id: string;
+    refresh_token_hash: string;
+    refresh_token_family?: string;
+    user_agent?: string;
+    ip?: string;
+    expires_at?: number | null;
+    revoked_at?: number | null;
+    created_at?: number | null;
+    updated_at?: number | null;
+}
+export interface LuxAuthKeyRow {
+    id: string;
+    name?: string;
+    kind: 'publishable' | 'secret' | string;
+    prefix: string;
+    key_hash: string;
+    scopes?: string;
+    created_at?: number | null;
+    revoked_at?: number | null;
+    last_used_at?: number | null;
+}
+export interface LuxAuthSigningKeyRow {
+    id: string;
+    kid: string;
+    algorithm: string;
+    public_jwk?: string;
+    private_key_encrypted?: string;
+    active: boolean;
+    created_at?: number | null;
+    rotated_at?: number | null;
+}
+export interface LuxAuthGrantRow {
+    id: string;
+    user_id: string;
+    capability: string;
+    created_at?: number | null;
+    revoked_at?: number | null;
+}
+export interface LuxAuthProviderRow {
+    provider: LuxOAuthProvider | string;
+    enabled: boolean;
+    client_id?: string;
+    client_secret?: string;
+    redirect_uri?: string;
+    scopes?: string;
+    created_at?: number | null;
+    updated_at?: number | null;
+}
+export interface LuxAuthTables {
+    'auth.users': LuxAuthUserRow;
+    'auth.identities': LuxAuthIdentityRow;
+    'auth.sessions': LuxAuthSessionRow;
+    'auth.keys': LuxAuthKeyRow;
+    'auth.signing_keys': LuxAuthSigningKeyRow;
+    'auth.grants': LuxAuthGrantRow;
+    'auth.providers': LuxAuthProviderRow;
+}
 export interface LuxAuthSession {
     access_token: string;
     token_type: 'bearer';

package/dist/types/index.d.ts

@@ -3,15 +3,16 @@ 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';
+import type { KSubEvent, LuxTypedRow, TableRow, TSAddOptions, TSMRangeResult, TSRangeOptions, TSSample, VSearchResult } from './types';
+export type { LuxAuthKey, LuxAuthGrantRow, LuxAuthIdentityRow, LuxAuthChangeEvent, LuxAuthOptions, LuxAuthKeyRow, LuxAuthProviderRow, LuxAuthSession, LuxAuthSessionRow, LuxAuthSigningKeyRow, LuxAuthStateChangeCallback, LuxAuthStorage, LuxAuthSubscription, LuxAuthTables, LuxAuthUserRow, LuxAuthUser, LuxUser, LuxOAuthProvider, LuxOAuthUrl, LuxSignInWithOAuthOptions, LuxCreateApiKeyOptions, LuxSignInOptions, LuxSignUpOptions, } from './auth';
 export { createProjectClient, LuxProjectClient, };
+export { LuxProjectLiveSubscription } from './project';
 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 type { LuxLiveResult, LuxProjectLiveEvent, LuxProjectLiveEventType, LuxProjectOptions, LuxTableColumn, LuxVectorSearchOptions, } from './project';
+export type { KSubEvent, LuxAggregateRow, LuxAggregateValue, LuxError, LuxInferRow, LuxNearRow, LuxResult, LuxSimilarity, LuxTypedRow, 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;
@@ -23,7 +24,7 @@ export declare class Lux extends Redis {
     authApi: LuxAuthClient;
     private realtimeManager?;
     constructor(options?: LuxClientOptions | RedisOptions | string);
-    table<T extends TableRow = TableRow>(name: string, options?: TableQueryBuilderOptions<T>): TableQueryBuilder<T>;
+    table<T extends object | readonly object[] = TableRow>(name: string, options?: TableQueryBuilderOptions<LuxTypedRow<T>>): TableQueryBuilder<LuxTypedRow<T>>;
     _subscribePattern(pattern: string, handler: (event: KSubEvent) => void): Promise<() => void>;
     _tselect(args: string[]): Promise<TableRow[]>;
     vset(key: string, vector: number[], options?: {

package/dist/types/project.d.ts

@@ -1,14 +1,15 @@
 import { LuxAuthClient, type LuxAuthOptions } from './auth';
-import type { LuxResult } from './types';
+import type { LuxError, LuxResult, LuxTypedRow } from './types';
 export interface LuxProjectOptions {
     url: string;
     key: string;
     fetch?: typeof fetch;
+    websocket?: typeof WebSocket;
     auth?: Omit<LuxAuthOptions, 'httpUrl' | 'apiKey' | 'fetch'>;
 }
 export interface LuxTableColumn {
     name: string;
-    type: 'STR' | 'INT' | 'FLOAT' | 'BOOL' | 'TIMESTAMP' | 'UUID';
+    type: 'STR' | 'INT' | 'FLOAT' | 'BOOL' | 'TIMESTAMP' | 'UUID' | `VECTOR(${number})`;
     primaryKey?: boolean;
     unique?: boolean;
     notNull?: boolean;
@@ -21,24 +22,73 @@ export interface LuxVectorSearchOptions {
     filter?: string;
     filter_value?: string;
 }
-type QueryValue = string | number | boolean | null;
-type FilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'is';
+type QueryValue = string | number | boolean | number[] | null;
+type FilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'is' | 'in' | 'notIn' | 'isValid' | 'isNotValid' | 'contains';
+type ProjectRowInput<T extends object> = Partial<T> & Record<string, QueryValue>;
+type ProjectSelectSingle<TResult> = TResult extends readonly (infer Row)[] ? Row : TResult;
 interface QueryFilter {
     column: string;
     operator: FilterOperator;
-    value: QueryValue;
+    value: QueryValue | QueryValue[];
 }
 interface QueryOrder {
     column: string;
     ascending: boolean;
 }
+interface QueryJoin {
+    type: 'inner' | 'left';
+    table: string;
+    alias: string;
+    onLeft: string;
+    onRight: string;
+}
+interface QueryHaving {
+    column: string;
+    operator: FilterOperator;
+    value: QueryValue;
+}
+interface QueryNear {
+    field: string;
+    vector: number[];
+    k: number;
+    threshold?: number;
+}
+export type LuxProjectLiveEventType = 'snapshot' | 'insert' | 'update' | 'delete' | 'error';
+export interface LuxProjectLiveEvent<T extends object = Record<string, unknown>> {
+    type: LuxProjectLiveEventType;
+    table: string;
+    pk?: string;
+    new: T | null;
+    old: T | null;
+    rows?: T[];
+    changed?: string[];
+    raw?: unknown;
+    error?: {
+        code?: string;
+        message?: string;
+    };
+}
+type LiveEventHandler<T extends object> = (event: LuxProjectLiveEvent<T>) => void;
+/**
+ * Result of opening a live subscription, in the same `{ data, error }` spirit as
+ * the rest of the SDK: `live` is the established subscription (or `null` if the
+ * server rejected it), `error` carries the rejection (e.g. a grant `FORBIDDEN`).
+ */
+export interface LuxLiveResult<T extends object> {
+    live: LuxProjectLiveSubscription<T> | null;
+    error: LuxError | null;
+}
 export declare class LuxProjectClient {
     readonly url: string;
     readonly key: string;
     readonly auth: LuxAuthClient;
     private fetchImpl;
+    private WebSocketImpl?;
+    private liveSocket;
+    private liveSubscriptions;
+    private livePending;
     constructor(options: LuxProjectOptions);
-    table<T extends Record<string, unknown> = Record<string, unknown>>(name: string): LuxProjectTable<T>;
+    table<T extends object | readonly object[] = Record<string, unknown>>(name: string): LuxProjectTable<LuxTypedRow<T>>;
     ping(): Promise<LuxResult<unknown>>;
     createTable(name: string, columns: Array<string | LuxTableColumn>): Promise<LuxResult<unknown>>;
     exec(command: string | string[]): Promise<LuxResult<unknown>>;
@@ -55,15 +105,33 @@ export declare class LuxProjectClient {
         count?: number;
     }): Promise<LuxResult<unknown>>;
     request<T = unknown>(method: string, path: string, body?: unknown): Promise<LuxResult<T>>;
+    _subscribeLive(spec: Record<string, unknown>, handler: (event: unknown) => void, error: (error: {
+        code?: string;
+        message?: string;
+    }) => void): Promise<() => void>;
+    private ensureLiveSocket;
+    private sendLive;
 }
-export declare class LuxProjectTable<T extends Record<string, unknown>> {
+export declare class LuxProjectTable<T extends object> {
     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>;
+    select<TResult extends object = T>(columns?: string): LuxProjectSelectBuilder<T, TResult[]>;
+    eq(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    neq(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    gt(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    gte(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    lt(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    lte(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    near(column: string, vector: number[], options?: {
+        k?: number;
+        threshold?: number;
+    }): LuxProjectSelectBuilder<T, T[]>;
+    is(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    live(): Promise<LuxLiveResult<T>>;
+    insert(row: ProjectRowInput<T>): LuxProjectInsertBuilder<unknown>;
+    insert(rows: Array<ProjectRowInput<T>>): LuxProjectInsertBuilder<unknown[]>;
+    update(patch: ProjectRowInput<T>): LuxProjectMutationBuilder<unknown>;
     delete(): LuxProjectMutationBuilder<unknown>;
     count(): Promise<LuxResult<number>>;
 }
@@ -78,6 +146,10 @@ declare abstract class LuxProjectFilterBuilder<TResult, TSelf> extends LuxProjec
     protected tableName: string;
     protected filters: QueryFilter[];
     protected orderBy?: QueryOrder;
+    protected joins: QueryJoin[];
+    protected groupColumns: string[];
+    protected havingFilters: QueryHaving[];
+    protected nearQuery?: QueryNear;
     protected limitCount?: number;
     protected offsetCount?: number;
     protected constructor(client: LuxProjectClient, tableName: string);
@@ -88,20 +160,66 @@ declare abstract class LuxProjectFilterBuilder<TResult, TSelf> extends LuxProjec
     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;
+    in(column: string, values: QueryValue[]): TSelf;
+    notIn(column: string, values: QueryValue[]): TSelf;
+    isValid(column: string): TSelf;
+    isNotValid(column: string): TSelf;
+    contains(column: string, value: QueryValue): TSelf;
+    join(table: string, alias: string, onLeft: string, onRight: string): TSelf;
+    leftJoin(table: string, alias: string, onLeft: string, onRight: string): TSelf;
+    group(columns: string | string[]): TSelf;
+    having(column: string, operator: FilterOperator, value: QueryValue): TSelf;
+    protected addFilter(column: string, operator: FilterOperator, value: QueryValue | QueryValue[]): TSelf;
     protected filteredQueryParams(): URLSearchParams;
 }
-export declare class LuxProjectSelectBuilder<T extends Record<string, unknown>, TResult> extends LuxProjectFilterBuilder<TResult, LuxProjectSelectBuilder<T, TResult>> {
+export declare class LuxProjectSelectBuilder<T extends object, 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;
+    near(column: string, vector: number[], options?: {
+        k?: number;
+        threshold?: number;
+    }): this;
     limit(count: number): this;
     range(from: number, to: number): this;
-    single(): LuxProjectSelectBuilder<T, T>;
+    single(): LuxProjectSelectBuilder<T, ProjectSelectSingle<TResult>>;
     execute(): Promise<LuxResult<TResult>>;
+    live(): Promise<LuxLiveResult<LuxTypedRow<TResult>>>;
+}
+export declare class LuxProjectLiveSubscription<T extends object> {
+    private client;
+    private table;
+    private columns;
+    private filters;
+    private nearQuery?;
+    private orderBy?;
+    private limitCount?;
+    private offsetCount?;
+    private handlers;
+    private unsubscribeFn;
+    private queue;
+    private waiters;
+    private closed;
+    constructor(client: LuxProjectClient, table: string, columns: string, filters: QueryFilter[], nearQuery?: QueryNear | undefined, orderBy?: QueryOrder | undefined, limitCount?: number | undefined, offsetCount?: number | undefined);
+    on(type: LuxProjectLiveEventType | 'change', handler: LiveEventHandler<T>): this;
+    unsubscribe(): Promise<void>;
+    /**
+     * Open the subscription and wait for the server to confirm it. Resolves
+     * `null` once the initial snapshot arrives, or a `LuxError` if the
+     * subscription is rejected (e.g. a grant `FORBIDDEN`) or the socket fails.
+     * Subsequent errors after a successful start surface via `on('error')` and
+     * end the async iterator.
+     */
+    start(): Promise<LuxError | null>;
+    [Symbol.asyncIterator](): AsyncIterator<LuxProjectLiveEvent<T>>;
+    private close;
+    private spec;
+    private handleEvent;
+    private emit;
+    private pushIterator;
 }
 export declare class LuxProjectInsertBuilder<TResult> extends LuxProjectThenable<TResult> {
     private client;