@lossless.org/client 0.1.0

package/dist_ts/sqldb/clickhouse/index.js

@@ -0,0 +1,13 @@
+// Core
+export * from './smartclickhouse.classes.smartclickhouse.js';
+export * from './smartclickhouse.classes.clickhousetable.js';
+export * from './smartclickhouse.classes.httpclient.js';
+// Query & Results
+export * from './smartclickhouse.classes.querybuilder.js';
+export * from './smartclickhouse.classes.resultset.js';
+// Time Data Table (backward compat)
+export * from './smartclickhouse.classes.timedatatable.js';
+// Types
+export * from './smartclickhouse.types.js';
+export { MetricWriter } from './classes.metricwriter.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9zcWxkYi9jbGlja2hvdXNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU87QUFDUCxjQUFjLDhDQUE4QyxDQUFDO0FBQzdELGNBQWMsOENBQThDLENBQUM7QUFDN0QsY0FBYyx5Q0FBeUMsQ0FBQztBQUV4RCxrQkFBa0I7QUFDbEIsY0FBYywyQ0FBMkMsQ0FBQztBQUMxRCxjQUFjLHdDQUF3QyxDQUFDO0FBRXZELG9DQUFvQztBQUNwQyxjQUFjLDRDQUE0QyxDQUFDO0FBRTNELFFBQVE7QUFDUixjQUFjLDRCQUE0QixDQUFDO0FBQzNDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQyJ9

package/dist_ts/sqldb/clickhouse/smartclickhouse.classes.clickhousetable.d.ts

@@ -0,0 +1,88 @@
+import * as plugins from './smartclickhouse.plugins.js';
+import type { SmartClickHouseDb } from './smartclickhouse.classes.smartclickhouse.js';
+import { ClickhouseQueryBuilder } from './smartclickhouse.classes.querybuilder.js';
+import type { IClickhouseTableOptions, IColumnInfo, IEngineConfig } from './smartclickhouse.types.js';
+import { MetricWriter, type IMetricWriterOptions } from './classes.metricwriter.js';
+import type { IOperationOptions } from '../../core/interfaces.js';
+export declare class ClickhouseTable<T extends Record<string, any>> {
+    static create<T extends Record<string, any>>(db: SmartClickHouseDb, options: IClickhouseTableOptions<T>): Promise<ClickhouseTable<T>>;
+    db: SmartClickHouseDb;
+    options: IClickhouseTableOptions<T> & {
+        database: string;
+        engine: IEngineConfig;
+    };
+    columns: IColumnInfo[];
+    constructor(db: SmartClickHouseDb, options: IClickhouseTableOptions<T>);
+    protected get qualifiedName(): string;
+    private interval;
+    /**
+     * Creates the table if it doesn't exist and refreshes column metadata
+     */
+    setup(): Promise<void>;
+    /**
+     * Refresh column metadata from system.columns
+     */
+    updateColumns(): Promise<IColumnInfo[]>;
+    /**
+     * Auto-schema evolution: detect new columns from data and add them
+     */
+    syncSchema(data: Record<string, any>): Promise<void>;
+    /**
+     * Insert a single row
+     */
+    insert(data: Partial<T>): Promise<void>;
+    /**
+     * Insert multiple rows
+     */
+    insertMany(data: Partial<T>[]): Promise<void>;
+    /**
+     * Insert in batches of configurable size
+     */
+    insertBatch(data: Partial<T>[], options?: {
+        batchSize?: number;
+    }): Promise<void>;
+    /** Await write() for backpressure and close() for the final acknowledged flush. */
+    createInsertStream(options?: IMetricWriterOptions): MetricWriter<Partial<T>>;
+    /**
+     * Returns a fluent query builder for this table
+     */
+    query(): ClickhouseQueryBuilder<T>;
+    /**
+     * Update rows matching a where condition (ClickHouse mutation - use sparingly)
+     */
+    update(set: Partial<T>, whereFn: (q: ClickhouseQueryBuilder<T>) => ClickhouseQueryBuilder<T>): Promise<void>;
+    /**
+     * Delete rows matching a where condition (ClickHouse mutation)
+     */
+    deleteWhere(whereFn: (q: ClickhouseQueryBuilder<T>) => ClickhouseQueryBuilder<T>): Promise<void>;
+    /**
+     * Delete entries older than a given interval on a column
+     */
+    deleteOlderThan(column: keyof T & string, interval: string): Promise<void>;
+    /**
+     * Drop the entire table
+     */
+    drop(): Promise<void>;
+    /**
+     * Wait for all pending mutations on this table to complete
+     */
+    waitForMutations(options?: IOperationOptions): Promise<void>;
+    /**
+     * Get the total row count
+     */
+    getRowCount(): Promise<number>;
+    /**
+     * Optimize table (useful for ReplacingMergeTree deduplication)
+     */
+    optimize(final?: boolean): Promise<void>;
+    /**
+     * Watch for new entries via polling. Returns an RxJS Observable.
+     */
+    watch(_options?: {
+        pollInterval?: number;
+    }): plugins.smartrx.rxjs.Observable<T>;
+    private ensureColumn;
+    private flattenDocument;
+    private prepareDocument;
+    private executeInsert;
+}

package/dist_ts/sqldb/clickhouse/smartclickhouse.classes.clickhousetable.js

@@ -0,0 +1,304 @@
+import * as plugins from './smartclickhouse.plugins.js';
+import { ClickhouseQueryBuilder } from './smartclickhouse.classes.querybuilder.js';
+import { detectClickhouseType } from './smartclickhouse.types.js';
+import { quoteClickHouseIdentifier as quoteIdentifier } from '../interfaces.js';
+import { MetricWriter } from './classes.metricwriter.js';
+import { Operation } from '../../core/classes.operation.js';
+import { LosslessClientError } from '../../core/classes.error.js';
+export class ClickhouseTable {
+    // ---- STATIC FACTORY ----
+    static async create(db, options) {
+        const table = new ClickhouseTable(db, options);
+        await table.setup();
+        return table;
+    }
+    // ---- INSTANCE ----
+    db;
+    options;
+    columns = [];
+    constructor(db, options) {
+        this.db = db;
+        this.options = {
+            autoSchemaEvolution: true,
+            ...options,
+            database: options.database || db.options.database,
+            engine: options.engine || { engine: 'MergeTree' },
+        };
+    }
+    get qualifiedName() {
+        return quoteIdentifier(this.options.database) + '.' + quoteIdentifier(this.options.tableName);
+    }
+    interval(value) {
+        if (!/^[1-9][0-9]* (SECOND|MINUTE|HOUR|DAY|WEEK|MONTH|QUARTER|YEAR)$/i.test(value)) {
+            throw new RangeError('An interval must be a positive integer and a supported unit.');
+        }
+        return value;
+    }
+    // ---- SCHEMA MANAGEMENT ----
+    /**
+     * Creates the table if it doesn't exist and refreshes column metadata
+     */
+    async setup() {
+        const { database, tableName, engine, orderBy, partitionBy, primaryKey, ttl, retainDataForDays, columns } = this.options;
+        // Build column definitions
+        let columnDefs;
+        if (columns && columns.length > 0) {
+            columnDefs = columns.map((col) => {
+                let def = `${quoteIdentifier(col.name)} ${col.type}`;
+                if (col.defaultExpression)
+                    def += ` DEFAULT ${col.defaultExpression}`;
+                if (col.codec)
+                    def += ` CODEC(${col.codec})`;
+                return def;
+            }).join(',\n          ');
+        }
+        else {
+            // Default minimal schema — downstream code can add columns via auto-schema evolution
+            columnDefs = `timestamp DateTime64(3, 'Europe/Berlin'),\n          message String`;
+        }
+        // Build engine clause
+        if (!['MergeTree', 'ReplacingMergeTree', 'SummingMergeTree', 'AggregatingMergeTree',
+            'CollapsingMergeTree', 'VersionedCollapsingMergeTree'].includes(engine.engine)) {
+            throw new RangeError('Unsupported table engine.');
+        }
+        let engineClause = engine.engine;
+        if (engine.engine === 'ReplacingMergeTree' && engine.versionColumn) {
+            engineClause = `ReplacingMergeTree(${quoteIdentifier(engine.versionColumn)})`;
+        }
+        else if (engine.engine === 'CollapsingMergeTree' && engine.signColumn) {
+            engineClause = `CollapsingMergeTree(${quoteIdentifier(engine.signColumn)})`;
+        }
+        else if (engine.engine === 'VersionedCollapsingMergeTree' && engine.signColumn && engine.versionColumn) {
+            engineClause = `VersionedCollapsingMergeTree(${quoteIdentifier(engine.signColumn)}, ${quoteIdentifier(engine.versionColumn)})`;
+        }
+        else {
+            engineClause = `${engine.engine}()`;
+        }
+        // Build ORDER BY
+        const orderByStr = Array.isArray(orderBy) ? orderBy.map(quoteIdentifier).join(', ') : quoteIdentifier(orderBy);
+        let createSQL = `
+      CREATE TABLE IF NOT EXISTS ${this.qualifiedName} (
+          ${columnDefs}
+      ) ENGINE = ${engineClause}`;
+        if (partitionBy) {
+            createSQL += `\n      PARTITION BY ${partitionBy}`;
+        }
+        createSQL += `\n      ORDER BY (${orderByStr})`;
+        if (primaryKey) {
+            const primaryKeyStr = Array.isArray(primaryKey) ? primaryKey.map(quoteIdentifier).join(', ') : quoteIdentifier(primaryKey);
+            createSQL += `\n      PRIMARY KEY (${primaryKeyStr})`;
+        }
+        await this.db.clickhouseHttpClient.queryPromise(createSQL);
+        // Apply TTL if configured
+        if (ttl) {
+            await this.db.clickhouseHttpClient.queryPromise(`
+        ALTER TABLE ${this.qualifiedName}
+        MODIFY TTL toDateTime(${quoteIdentifier(String(ttl.column))}) + INTERVAL ${this.interval(ttl.interval)}
+      `);
+        }
+        else if (retainDataForDays && retainDataForDays > 0) {
+            // Legacy shorthand
+            await this.db.clickhouseHttpClient.queryPromise(`
+        ALTER TABLE ${this.qualifiedName}
+        MODIFY TTL toDateTime(timestamp) + INTERVAL ${this.interval(retainDataForDays + ' DAY')}
+      `);
+        }
+        await this.updateColumns();
+    }
+    /**
+     * Refresh column metadata from system.columns
+     */
+    async updateColumns() {
+        this.columns = await this.db.clickhouseHttpClient.queryPromise(`
+      SELECT * FROM system.columns
+      WHERE database = {database:String}
+      AND table = {table:String}
+    `, { database: this.options.database, table: this.options.tableName });
+        return this.columns;
+    }
+    /**
+     * Auto-schema evolution: detect new columns from data and add them
+     */
+    async syncSchema(data) {
+        const flatData = plugins.smartobject.toFlatObject(data);
+        for (const key of Object.keys(flatData)) {
+            if (key === 'timestamp')
+                continue;
+            const value = flatData[key];
+            const clickhouseType = detectClickhouseType(value);
+            if (!clickhouseType)
+                continue;
+            await this.ensureColumn(key, clickhouseType);
+        }
+    }
+    // ---- INSERT ----
+    /**
+     * Insert a single row
+     */
+    async insert(data) {
+        const storageDoc = await this.prepareDocument(data);
+        await this.executeInsert([storageDoc]);
+    }
+    /**
+     * Insert multiple rows
+     */
+    async insertMany(data) {
+        if (data.length === 0)
+            return;
+        // Schema sync across all documents
+        if (this.options.autoSchemaEvolution) {
+            const allKeys = new Set();
+            const sampleValues = {};
+            for (const doc of data) {
+                const flat = plugins.smartobject.toFlatObject(doc);
+                for (const [key, value] of Object.entries(flat)) {
+                    if (!allKeys.has(key)) {
+                        allKeys.add(key);
+                        sampleValues[key] = value;
+                    }
+                }
+            }
+            await this.syncSchema(sampleValues);
+        }
+        const storageDocs = data.map((doc) => this.flattenDocument(doc));
+        await this.executeInsert(storageDocs);
+    }
+    /**
+     * Insert in batches of configurable size
+     */
+    async insertBatch(data, options) {
+        const size = options?.batchSize ?? 500;
+        if (!Number.isSafeInteger(size) || size < 1)
+            throw new RangeError('batchSize must be positive.');
+        for (let offset = 0; offset < data.length; offset += size) {
+            await this.insertMany(data.slice(offset, offset + size));
+        }
+    }
+    /** Await write() for backpressure and close() for the final acknowledged flush. */
+    createInsertStream(options = {}) {
+        return this.db.ownWriter(new MetricWriter(rows => this.insertMany(rows), options));
+    }
+    // ---- QUERY ----
+    /**
+     * Returns a fluent query builder for this table
+     */
+    query() {
+        return new ClickhouseQueryBuilder(this.options.tableName, this.options.database, this.db.clickhouseHttpClient);
+    }
+    // ---- UPDATE ----
+    /**
+     * Update rows matching a where condition (ClickHouse mutation - use sparingly)
+     */
+    async update(set, whereFn) {
+        const qb = whereFn(new ClickhouseQueryBuilder(this.options.tableName, this.options.database, this.db.clickhouseHttpClient));
+        const whereClause = qb.buildWhereClause();
+        if (!whereClause) {
+            throw new Error('UPDATE requires a WHERE clause. Use a where condition to target specific rows.');
+        }
+        const setClauses = Object.entries(set)
+            .map(([key, value]) => `${quoteIdentifier(key)} = ${qb.bind(value)}`)
+            .join(', ');
+        await this.db.clickhouseHttpClient.mutatePromise(`ALTER TABLE ${this.qualifiedName} UPDATE ${setClauses} WHERE ${whereClause}`, qb.parameters);
+        await this.waitForMutations();
+    }
+    // ---- DELETE ----
+    /**
+     * Delete rows matching a where condition (ClickHouse mutation)
+     */
+    async deleteWhere(whereFn) {
+        const qb = whereFn(new ClickhouseQueryBuilder(this.options.tableName, this.options.database, this.db.clickhouseHttpClient));
+        const whereClause = qb.buildWhereClause();
+        if (!whereClause) {
+            throw new Error('DELETE requires a WHERE clause.');
+        }
+        await this.db.clickhouseHttpClient.mutatePromise(`ALTER TABLE ${this.qualifiedName} DELETE WHERE ${whereClause}`, qb.parameters);
+        await this.waitForMutations();
+    }
+    /**
+     * Delete entries older than a given interval on a column
+     */
+    async deleteOlderThan(column, interval) {
+        await this.db.clickhouseHttpClient.mutatePromise(`ALTER TABLE ${this.qualifiedName} DELETE WHERE ${quoteIdentifier(String(column))} < now() - INTERVAL ${this.interval(interval)}`);
+        await this.waitForMutations();
+    }
+    /**
+     * Drop the entire table
+     */
+    async drop() {
+        await this.db.clickhouseHttpClient.queryPromise(`DROP TABLE IF EXISTS ${this.qualifiedName}`);
+        this.columns = [];
+    }
+    // ---- UTILITIES ----
+    /**
+     * Wait for all pending mutations on this table to complete
+     */
+    async waitForMutations(options = {}) {
+        const operation = new Operation(options, this.db.options.timeoutMs);
+        try {
+            while (true) {
+                operation.check();
+                const rows = await this.db.clickhouseHttpClient.queryPromise('SELECT count() AS cnt FROM system.mutations WHERE is_done = 0 AND database = {database:String} AND table = {table:String}', { database: this.options.database, table: this.options.tableName }, { signal: operation.signal });
+                if (BigInt(rows[0]?.cnt ?? 0) === 0n)
+                    return;
+                await plugins.smartdelay.delayFor(100);
+            }
+        }
+        finally {
+            operation.dispose();
+        }
+    }
+    /**
+     * Get the total row count
+     */
+    async getRowCount() {
+        const result = await this.db.clickhouseHttpClient.queryPromise(`
+      SELECT count() AS cnt FROM ${this.qualifiedName} FORMAT JSONEachRow
+    `);
+        const count = Number(result[0]?.cnt ?? 0);
+        if (!Number.isSafeInteger(count))
+            throw new RangeError('Count exceeds a safe JavaScript integer.');
+        return count;
+    }
+    /**
+     * Optimize table (useful for ReplacingMergeTree deduplication)
+     */
+    async optimize(final = false) {
+        const finalClause = final ? ' FINAL' : '';
+        await this.db.clickhouseHttpClient.queryPromise(`OPTIMIZE TABLE ${this.qualifiedName}${finalClause}`);
+    }
+    // ---- OBSERVATION ----
+    /**
+     * Watch for new entries via polling. Returns an RxJS Observable.
+     */
+    watch(_options) {
+        return new plugins.smartrx.rxjs.Observable(observer => observer.error(new LosslessClientError('unsupported_capability', 'Timestamp polling cannot guarantee delivery of equal-timestamp or late rows. Use an explicit stable ingestion cursor before enabling a watch.')));
+    }
+    // ---- PRIVATE HELPERS ----
+    async ensureColumn(name, type) {
+        if (this.columns.some(column => column.name === name))
+            return;
+        await this.db.clickhouseHttpClient.queryPromise(`ALTER TABLE ${this.qualifiedName} ADD COLUMN IF NOT EXISTS ${quoteIdentifier(name)} ${type}`);
+        await this.updateColumns();
+    }
+    flattenDocument(data) {
+        const flat = plugins.smartobject.toFlatObject(data);
+        const storageDoc = {};
+        for (const [key, value] of Object.entries(flat)) {
+            const type = detectClickhouseType(value);
+            if (type || key === 'timestamp') {
+                storageDoc[key] = value;
+            }
+        }
+        return storageDoc;
+    }
+    async prepareDocument(data) {
+        if (this.options.autoSchemaEvolution) {
+            await this.syncSchema(data);
+        }
+        return this.flattenDocument(data);
+    }
+    async executeInsert(docs) {
+        await this.db.clickhouseHttpClient.insertPromise(this.options.database, this.options.tableName, docs);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartclickhouse.classes.clickhousetable.js","sourceRoot":"","sources":["../../../ts/sqldb/clickhouse/smartclickhouse.classes.clickhousetable.ts"],"names":[],"mappings":"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"}

package/dist_ts/sqldb/clickhouse/smartclickhouse.classes.httpclient.d.ts

@@ -0,0 +1,28 @@
+import { ClickHouseConnection } from '../classes.clickhouseconnection.js';
+import type { IOperationOptions } from '../../core/interfaces.js';
+import type { IQueryOptions } from '../interfaces.js';
+export interface IClickhouseHttpClientOptions {
+    username?: string;
+    password?: string;
+    url: string;
+    timeoutMs?: number;
+}
+/** Migrated public transport API, using the official streaming ClickHouse connector. */
+export declare class ClickhouseHttpClient {
+    options: IClickhouseHttpClientOptions;
+    readonly connection: ClickHouseConnection;
+    private readonly ownsConnection;
+    constructor(options: IClickhouseHttpClientOptions, connection?: ClickHouseConnection);
+    static createAndStart(options: IClickhouseHttpClientOptions): Promise<ClickhouseHttpClient>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    ping(options?: IOperationOptions): Promise<boolean>;
+    queryPromise(query: string, values?: Record<string, unknown>, options?: IQueryOptions): Promise<any[]>;
+    queryTyped<T>(query: string, values?: Record<string, unknown>, options?: IQueryOptions): Promise<T[]>;
+    insertPromise(database: string, table: string, documents: Record<string, unknown>[]): Promise<{
+        queryId: string;
+        completion: "acknowledged";
+    }>;
+    insertBatch(database: string, table: string, documents: Record<string, unknown>[], batchSize?: number): Promise<void>;
+    mutatePromise(query: string, values?: Record<string, unknown>, options?: IOperationOptions): Promise<void>;
+}

package/dist_ts/sqldb/clickhouse/smartclickhouse.classes.httpclient.js

@@ -0,0 +1,46 @@
+import { ClickHouseConnection } from '../classes.clickhouseconnection.js';
+/** Migrated public transport API, using the official streaming ClickHouse connector. */
+export class ClickhouseHttpClient {
+    options;
+    connection;
+    ownsConnection;
+    constructor(options, connection) {
+        this.options = options;
+        this.ownsConnection = !connection;
+        this.connection = connection ?? new ClickHouseConnection({ ...options, backend: 'clickhouse', database: 'default' });
+    }
+    static async createAndStart(options) {
+        const instance = new ClickhouseHttpClient(options);
+        await instance.start();
+        return instance;
+    }
+    async start() { await this.connection.connect(); }
+    async close() { if (this.ownsConnection)
+        await this.connection.close(); }
+    async ping(options = {}) { return (await this.connection.ready(options)).ready; }
+    async queryPromise(query, values, options = {}) {
+        const sql = query.trim().replace(/\s+FORMAT\s+JSONEachRow\s*;?$/i, '');
+        if (/^(SELECT|WITH|SHOW|DESCRIBE|DESC|EXISTS|EXPLAIN)\b/i.test(sql)) {
+            return this.connection.query({ sql, values }, options);
+        }
+        await this.connection.execute({ sql, values }, options);
+        return [];
+    }
+    async queryTyped(query, values, options = {}) {
+        return this.queryPromise(query, values, options);
+    }
+    async insertPromise(database, table, documents) {
+        return this.connection.insertQualified(database, table, documents);
+    }
+    async insertBatch(database, table, documents, batchSize = 10_000) {
+        if (!Number.isSafeInteger(batchSize) || batchSize < 1)
+            throw new RangeError('batchSize must be positive.');
+        for (let i = 0; i < documents.length; i += batchSize) {
+            await this.insertPromise(database, table, documents.slice(i, i + batchSize));
+        }
+    }
+    async mutatePromise(query, values, options = {}) {
+        await this.connection.execute({ sql: query, values }, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/sqldb/clickhouse/smartclickhouse.classes.querybuilder.d.ts

@@ -0,0 +1,43 @@
+import type { ClickhouseHttpClient } from './smartclickhouse.classes.httpclient.js';
+import { ClickhouseResultSet } from './smartclickhouse.classes.resultset.js';
+import type { TComparisonOperator } from './smartclickhouse.types.js';
+import type { IClickHouseStatement, IQueryOptions } from '../interfaces.js';
+/** Identifier methods quote names. Methods ending in Raw and having() accept trusted SQL expressions. */
+export declare class ClickhouseQueryBuilder<T extends Record<string, any>> {
+    private tableName;
+    private database;
+    private httpClient;
+    private selectColumns;
+    private whereClauses;
+    private orderByClauses;
+    private groupByClauses;
+    private havingClauses;
+    private limitValue;
+    private offsetValue;
+    private readonly values;
+    constructor(tableName: string, database: string, httpClient: ClickhouseHttpClient);
+    select<K extends keyof T & string>(...columns: K[]): this;
+    selectRaw(...expressions: string[]): this;
+    where<K extends keyof T & string>(column: K, operator: TComparisonOperator, value: unknown): this;
+    and<K extends keyof T & string>(column: K, operator: TComparisonOperator, value: unknown): this;
+    or<K extends keyof T & string>(column: K, operator: TComparisonOperator, value: unknown): this;
+    whereRaw(expression: string): this;
+    orderBy(column: (keyof T & string) | string, direction?: 'ASC' | 'DESC'): this;
+    groupBy<K extends keyof T & string>(...columns: K[]): this;
+    having(expression: string): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    private validateCount;
+    execute(options?: IQueryOptions): Promise<ClickhouseResultSet<T>>;
+    first(): Promise<T | null>;
+    count(): Promise<number>;
+    toArray(options?: IQueryOptions): Promise<T[]>;
+    /** SQL contains typed placeholders. Pass parameters alongside it, or use toStatement(). */
+    toSQL(): string;
+    get parameters(): Record<string, unknown>;
+    toStatement(): IClickHouseStatement;
+    buildWhereClause(): string;
+    /** Bind a scalar for table mutations as well as predicates. */
+    bind(value: unknown): string;
+    private buildCondition;
+}