@housekit/orm 0.1.47 → 0.1.48

package/dist/metadata.js

@@ -0,0 +1,59 @@
+export const supportedMetadataVersions = ['1.1.0', '1.2.0'];
+export const defaultMetadataVersion = '1.2.0';
+export const housekitMetadataSchemas = {
+    '1.1.0': { version: 'string', appendOnly: 'boolean' },
+    '1.2.0': { version: 'string', appendOnly: 'boolean', readOnly: 'boolean' }
+};
+export const housekitMetadataDefaults = {
+    '1.1.0': { appendOnly: true },
+    '1.2.0': { appendOnly: true, readOnly: false }
+};
+export function assertMetadataVersion(version) {
+    if (!supportedMetadataVersions.includes(version)) {
+        throw new Error(`Unsupported housekit metadata version "${version}". Supported versions: ${supportedMetadataVersions.join(', ')}`);
+    }
+}
+export function getMetadataDefaults(version) {
+    return housekitMetadataDefaults[version];
+}
+export function buildHousekitMetadata(version, opts) {
+    const defaults = getMetadataDefaults(version);
+    if (version === '1.1.0') {
+        return { version, appendOnly: opts.appendOnly ?? defaults.appendOnly };
+    }
+    if (version === '1.2.0') {
+        return { version, appendOnly: opts.appendOnly ?? defaults.appendOnly, readOnly: opts.readOnly ?? defaults.readOnly ?? false };
+    }
+    assertMetadataVersion(version);
+    return buildHousekitMetadata(defaultMetadataVersion, opts);
+}
+export function normalizeHousekitMetadata(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    if (!raw.version)
+        return null;
+    const versionStr = String(raw.version);
+    try {
+        assertMetadataVersion(versionStr);
+    }
+    catch {
+        return null;
+    }
+    const version = versionStr;
+    if (version === '1.1.0') {
+        return { version, meta: { version, appendOnly: Boolean(raw.appendOnly ?? true) } };
+    }
+    if (version === '1.2.0') {
+        return { version, meta: { version, appendOnly: Boolean(raw.appendOnly ?? true), readOnly: Boolean(raw.readOnly ?? false) } };
+    }
+    return null;
+}
+export function upgradeMetadataVersion(base, targetVersion, overrides) {
+    const defaults = getMetadataDefaults(targetVersion);
+    const appendOnly = overrides?.appendOnly ?? base?.appendOnly ?? defaults.appendOnly;
+    if (targetVersion === '1.1.0') {
+        return { version: '1.1.0', appendOnly };
+    }
+    const readOnly = overrides?.readOnly ?? (base && 'readOnly' in base ? base.readOnly : defaults.readOnly ?? false);
+    return { version: '1.2.0', appendOnly, readOnly };
+}

package/dist/modules/aggregates.d.ts

@@ -1,205 +1,41 @@
 import { ClickHouseColumn } from '../core';
 import { SQLExpression } from '../expressions';
-/**
- * Count rows or non-null values in column
- * @param col - Column to count (optional, defaults to all rows)
- */
 export declare function count(col?: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Get minimum value
- * @param col - Column to find minimum
- */
 export declare function min<T>(col: ClickHouseColumn<T, any, any> | SQLExpression<T>): SQLExpression<T>;
-/**
- * Get maximum value
- * @param col - Column to find maximum
- */
 export declare function max<T>(col: ClickHouseColumn<T, any, any> | SQLExpression<T>): SQLExpression<T>;
-/**
- * Calculate sum of values
- * @param col - Column to sum
- */
 export declare function sum(col: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Calculate average of values
- * @param col - Column to average
- */
 export declare function avg(col: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Count approximate unique values (HyperLogLog)
- * @param col - Column to count unique values
- */
 export declare function uniq(col: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Count exact unique values (ClickHouse-native naming)
- * @param col - Column to count unique values
- */
 export declare function uniqExact(col: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Count exact unique values (SQL-standard naming)
- * @param col - Column to count unique values
- */
 export declare function countDistinct(col: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Create an array from all values in the group
- * @param expr - Expression to aggregate into array
- */
 export declare function groupArray<T>(expr: ClickHouseColumn<T, any, any> | SQLExpression<T>): SQLExpression<T[]>;
-/**
- * Create an array of unique values from all values in the group
- * @param expr - Expression to aggregate into unique array
- */
 export declare function groupUniqArray<T>(expr: ClickHouseColumn<T, any, any> | SQLExpression<T>): SQLExpression<T[]>;
-/**
- * Get any value from the group (non-deterministic)
- * @param expr - Expression to get any value from
- */
 export declare function any<T>(expr: ClickHouseColumn<T, any, any> | SQLExpression<T>): SQLExpression<T>;
-/**
- * Get any value from the group, preferring the last one
- * @param expr - Expression to get any value from
- */
 export declare function anyLast<T>(expr: ClickHouseColumn<T, any, any> | SQLExpression<T>): SQLExpression<T>;
-/**
- * Get the value with the minimum weight
- * Extremely useful in logs/metrics/"latest state" queries
- * @param value - The value to return when weight is minimum
- * @param weight - The weight to compare
- */
 export declare function argMin<T>(value: ClickHouseColumn<T, any, any> | SQLExpression<T>, weight: ClickHouseColumn | SQLExpression): SQLExpression<T>;
-/**
- * Get the value with the maximum weight
- * Extremely useful in logs/metrics/"latest state" queries
- * @param value - The value to return when weight is maximum
- * @param weight - The weight to compare
- */
 export declare function argMax<T>(value: ClickHouseColumn<T, any, any> | SQLExpression<T>, weight: ClickHouseColumn | SQLExpression): SQLExpression<T>;
-/**
- * Calculate standard deviation
- * @param col - Column to calculate standard deviation
- */
 export declare function stddevSamp(col: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Calculate population standard deviation
- * @param col - Column to calculate standard deviation
- */
 export declare function stddevPop(col: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Calculate sample variance
- * @param col - Column to calculate variance
- */
 export declare function varSamp(col: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Calculate population variance
- * @param col - Column to calculate variance
- */
 export declare function varPop(col: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Calculate median
- * @param col - Column to calculate median
- */
 export declare function median(col: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Calculate quantile
- * @param col - Column to calculate quantile
- * @param level - Quantile level (0.0 to 1.0)
- */
 export declare function quantile(col: ClickHouseColumn | SQLExpression, level: number): SQLExpression<number>;
-/**
- * Calculate quantiles (multiple levels)
- * @param col - Column to calculate quantiles
- * @param levels - Array of quantile levels
- */
 export declare function quantiles(col: ClickHouseColumn | SQLExpression, levels: number[]): SQLExpression<number[]>;
-/**
- * Calculate Pearson correlation coefficient
- * @param col1 - First column
- * @param col2 - Second column
- */
 export declare function corr(col1: ClickHouseColumn | SQLExpression, col2: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Calculate covariance
- * @param col1 - First column
- * @param col2 - Second column
- */
 export declare function covarSamp(col1: ClickHouseColumn | SQLExpression, col2: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Calculate population covariance
- * @param col1 - First column
- * @param col2 - Second column
- */
 export declare function covarPop(col1: ClickHouseColumn | SQLExpression, col2: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Calculate rate per second (for counters and metrics)
- * @param col - Counter column
- * @param bucket - Time bucket column
- */
 export declare function rate(col: ClickHouseColumn | SQLExpression, bucket: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Calculate increase in counter value
- * @param col - Counter column
- * @param bucket - Time bucket column
- */
 export declare function increase(col: ClickHouseColumn | SQLExpression, bucket?: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Calculate delta between consecutive values
- * @param col - Column to calculate delta
- */
 export declare function delta(col: ClickHouseColumn | SQLExpression): SQLExpression<number>;
-/**
- * Get top N values by frequency
- * @param col - Column to analyze
- * @param n - Number of top values to return
- */
 export declare function topK<T>(col: ClickHouseColumn<T, any, any> | SQLExpression<T>, n: number): SQLExpression<T[]>;
-/**
- * Get bottom N values by frequency
- * @param col - Column to analyze
- * @param n - Number of bottom values to return
- */
 export declare function bottomK<T>(col: ClickHouseColumn<T, any, any> | SQLExpression<T>, n: number): SQLExpression<T[]>;
-/**
- * Get top N values by sum
- * @param col - Column to analyze
- * @param n - Number of top values to return
- */
 export declare function topSum<T>(col: ClickHouseColumn<T, any, any> | SQLExpression<T>, n: number): SQLExpression<T[]>;
-/**
- * Get bottom N values by sum
- * @param col - Column to analyze
- * @param n - Number of bottom values to return
- */
 export declare function bottomSum<T>(col: ClickHouseColumn<T, any, any> | SQLExpression<T>, n: number): SQLExpression<T[]>;
-/**
- * Sum values if condition is met
- */
 export declare function sumIf(col: ClickHouseColumn | SQLExpression, condition: SQLExpression): SQLExpression<number>;
-/**
- * Count rows if condition is met
- */
 export declare function countIf(condition: SQLExpression): SQLExpression<number>;
-/**
- * Average values if condition is met
- */
 export declare function avgIf(col: ClickHouseColumn | SQLExpression, condition: SQLExpression): SQLExpression<number>;
-/**
- * Minimum value if condition is met
- */
 export declare function minIf<T>(col: ClickHouseColumn<T, any, any> | SQLExpression<T>, condition: SQLExpression): SQLExpression<T>;
-/**
- * Maximum value if condition is met
- */
 export declare function maxIf<T>(col: ClickHouseColumn<T, any, any> | SQLExpression<T>, condition: SQLExpression): SQLExpression<T>;
-/**
- * Approximate unique values if condition is met
- */
 export declare function uniqIf(col: ClickHouseColumn | SQLExpression, condition: SQLExpression): SQLExpression<number>;
-/**
- * Exact unique values if condition is met
- */
 export declare function uniqExactIf(col: ClickHouseColumn | SQLExpression, condition: SQLExpression): SQLExpression<number>;
-/**
- * Aggregates all array elements into a single array
- * @example t.array(1, 2), t.array(3, 4) -> [1, 2, 3, 4]
- */
 export declare function groupArrayArray<T>(expr: ClickHouseColumn<T[], any, any> | SQLExpression<T[]>): SQLExpression<T[]>;

package/dist/modules/aggregates.js

@@ -0,0 +1,121 @@
+import { sql } from '../expressions';
+export function count(col) {
+    if (!col)
+        return sql `count(*)`;
+    return sql `count(${col})`;
+}
+export function min(col) {
+    return sql `min(${col})`;
+}
+export function max(col) {
+    return sql `max(${col})`;
+}
+export function sum(col) {
+    return sql `sum(${col})`;
+}
+export function avg(col) {
+    return sql `avg(${col})`;
+}
+export function uniq(col) {
+    return sql `uniq(${col})`;
+}
+export function uniqExact(col) {
+    return sql `uniqExact(${col})`;
+}
+export function countDistinct(col) {
+    return sql `uniqExact(${col})`;
+}
+export function groupArray(expr) {
+    return sql `groupArray(${expr})`;
+}
+export function groupUniqArray(expr) {
+    return sql `groupUniqArray(${expr})`;
+}
+export function any(expr) {
+    return sql `any(${expr})`;
+}
+export function anyLast(expr) {
+    return sql `anyLast(${expr})`;
+}
+export function argMin(value, weight) {
+    return sql `argMin(${value}, ${weight})`;
+}
+export function argMax(value, weight) {
+    return sql `argMax(${value}, ${weight})`;
+}
+export function stddevSamp(col) {
+    return sql `stddevSamp(${col})`;
+}
+export function stddevPop(col) {
+    return sql `stddevPop(${col})`;
+}
+export function varSamp(col) {
+    return sql `varSamp(${col})`;
+}
+export function varPop(col) {
+    return sql `varPop(${col})`;
+}
+export function median(col) {
+    return sql `median(${col})`;
+}
+export function quantile(col, level) {
+    return sql `quantile(${level})(${col})`;
+}
+export function quantiles(col, levels) {
+    const levelsStr = levels.join(', ');
+    return sql `quantiles(${levelsStr})(${col})`;
+}
+export function corr(col1, col2) {
+    return sql `corr(${col1}, ${col2})`;
+}
+export function covarSamp(col1, col2) {
+    return sql `covarSamp(${col1}, ${col2})`;
+}
+export function covarPop(col1, col2) {
+    return sql `covarPop(${col1}, ${col2})`;
+}
+export function rate(col, bucket) {
+    return sql `rate(${col})`;
+}
+export function increase(col, bucket) {
+    return sql `increase(${col})`;
+}
+export function delta(col) {
+    return sql `delta(${col})`;
+}
+export function topK(col, n) {
+    return sql `topK(${n})(${col})`;
+}
+export function bottomK(col, n) {
+    return sql `bottomK(${n})(${col})`;
+}
+export function topSum(col, n) {
+    return sql `topSum(${n})(${col})`;
+}
+export function bottomSum(col, n) {
+    return sql `bottomSum(${n})(${col})`;
+}
+export function sumIf(col, condition) {
+    return sql `sumIf(${col}, ${condition})`;
+}
+export function countIf(condition) {
+    return sql `countIf(${condition})`;
+}
+export function avgIf(col, condition) {
+    return sql `avgIf(${col}, ${condition})`;
+}
+export function minIf(col, condition) {
+    return sql `minIf(${col}, ${condition})`;
+}
+export function maxIf(col, condition) {
+    return sql `maxIf(${col}, ${condition})`;
+}
+export function uniqIf(col, condition) {
+    return sql `uniqIf(${col}, ${condition})`;
+}
+export function uniqExactIf(col, condition) {
+    return sql `uniqExactIf(${col}, ${condition})`;
+}
+export function groupArrayArray(expr) {
+    return sql `groupArrayArray(${expr})`;
+}

package/dist/modules/array.d.ts

@@ -1,122 +1,24 @@
 import { ClickHouseColumn } from '../core';
 import { SQLExpression } from '../expressions';
-/**
- * Join array elements with a separator
- * @param separator - Separator string
- * @param col - Array column or expression
- */
 export declare function arrayJoin(separator: string | ClickHouseColumn | SQLExpression, col?: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Apply a lambda function to each element of an array
- * @param lambda - Lambda function (e.g., 'x -> x * 2')
- * @param col - Array column or expression
- */
 export declare function arrayMap(lambda: string, col: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Filter array elements using a lambda function
- * @param lambda - Lambda function (e.g., 'x -> x > 0')
- * @param col - Array column or expression
- */
 export declare function arrayFilter(lambda: string, col: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Get the length of an array
- * @param col - Array column or expression
- */
 export declare function arrayLength(col: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Reduce an array using a function
- * @param func - Aggregate function name (e.g., 'sum', 'avg', 'max')
- * @param col - Array column or expression
- */
 export declare function arrayReduce(func: string, col: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Concatenate multiple arrays
- * @param arrays - Array columns or expressions to concatenate
- */
 export declare function arrayConcat(...arrays: (ClickHouseColumn | SQLExpression)[]): SQLExpression<any>;
-/**
- * Get element at specific index (1-based)
- * @param col - Array column or expression
- * @param index - Index (1-based)
- */
 export declare function arrayElement(col: ClickHouseColumn | SQLExpression, index: number): SQLExpression<any>;
-/**
- * Check if array contains an element
- * @param col - Array column or expression
- * @param element - Element to search for
- */
 export declare function arrayHas(col: ClickHouseColumn | SQLExpression, element: any): SQLExpression<any>;
-/**
- * Check if array has all elements from another array
- * @param col - Array column or expression
- * @param elements - Array of elements to check
- */
 export declare function arrayHasAll(col: ClickHouseColumn | SQLExpression, elements: any[] | ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Check if array has any element from another array
- * @param col - Array column or expression
- * @param elements - Array of elements to check
- */
 export declare function arrayHasAny(col: ClickHouseColumn | SQLExpression, elements: any[] | ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Get the first element of an array
- * @param col - Array column or expression
- */
 export declare function arrayFirst(col: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Get the last element of an array
- * @param col - Array column or expression
- */
 export declare function arrayLast(col: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Sort an array
- * @param col - Array column or expression
- * @param ascending - Sort order (default: true for ascending)
- */
 export declare function arraySort(col: ClickHouseColumn | SQLExpression, ascending?: boolean): SQLExpression<any>;
-/**
- * Reverse an array
- * @param col - Array column or expression
- */
 export declare function arrayReverse(col: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Get unique elements from an array
- * @param col - Array column or expression
- */
 export declare function arrayDistinct(col: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Count occurrences of an element in an array
- * @param col - Array column or expression
- * @param element - Element to count
- */
 export declare function arrayCountMatches(col: ClickHouseColumn | SQLExpression, element: any): SQLExpression<any>;
-/**
- * Check if array is empty
- * @param col - Array column or expression
- */
 export declare function empty(col: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Check if array is not empty
- * @param col - Array column or expression
- */
 export declare function notEmpty(col: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Get the minimum value in an array
- * @param col - Array column or expression
- */
 export declare function arrayMin(col: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Get the maximum value in an array
- * @param col - Array column or expression
- */
 export declare function arrayMax(col: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Calculate the sum of array elements
- * @param col - Array column or expression
- */
 export declare function arraySum(col: ClickHouseColumn | SQLExpression): SQLExpression<any>;
-/**
- * Calculate the average of array elements
- * @param col - Array column or expression
- */
 export declare function arrayAvg(col: ClickHouseColumn | SQLExpression): SQLExpression<any>;

package/dist/modules/array.js

@@ -0,0 +1,71 @@
+import { sql } from '../expressions';
+export function arrayJoin(separator, col) {
+    if (col) {
+        return sql `arrayJoin(${separator}, ${col})`;
+    }
+    return sql `arrayJoin(${separator})`;
+}
+export function arrayMap(lambda, col) {
+    return sql `arrayMap(${lambda}, ${col})`;
+}
+export function arrayFilter(lambda, col) {
+    return sql `arrayFilter(${lambda}, ${col})`;
+}
+export function arrayLength(col) {
+    return sql `arrayLength(${col})`;
+}
+export function arrayReduce(func, col) {
+    return sql `arrayReduce('${func}', ${col})`;
+}
+export function arrayConcat(...arrays) {
+    const params = arrays.map(arr => sql `${arr}`).join(', ');
+    return sql `arrayConcat(${params})`;
+}
+export function arrayElement(col, index) {
+    return sql `arrayElement(${col}, ${index})`;
+}
+export function arrayHas(col, element) {
+    return sql `has(${col}, ${element})`;
+}
+export function arrayHasAll(col, elements) {
+    return sql `hasAll(${col}, ${elements})`;
+}
+export function arrayHasAny(col, elements) {
+    return sql `hasAny(${col}, ${elements})`;
+}
+export function arrayFirst(col) {
+    return sql `arrayFirst(${col})`;
+}
+export function arrayLast(col) {
+    return sql `arrayLast(${col})`;
+}
+export function arraySort(col, ascending = true) {
+    return ascending ? sql `arraySort(${col})` : sql `arrayReverseSort(${col})`;
+}
+export function arrayReverse(col) {
+    return sql `arrayReverse(${col})`;
+}
+export function arrayDistinct(col) {
+    return sql `arrayDistinct(${col})`;
+}
+export function arrayCountMatches(col, element) {
+    return sql `countMatches(${col}, ${element})`;
+}
+export function empty(col) {
+    return sql `empty(${col})`;
+}
+export function notEmpty(col) {
+    return sql `notEmpty(${col})`;
+}
+export function arrayMin(col) {
+    return sql `arrayMin(${col})`;
+}
+export function arrayMax(col) {
+    return sql `arrayMax(${col})`;
+}
+export function arraySum(col) {
+    return sql `arraySum(${col})`;
+}
+export function arrayAvg(col) {
+    return sql `arrayAvg(${col})`;
+}

package/dist/modules/conditional.d.ts

@@ -1,110 +1,26 @@
 import { ClickHouseColumn } from '../core';
 import { SQLExpression } from '../expressions';
-/**
- * Return alternative value if column is null
- * @param col - Column to check
- * @param alt - Alternative value
- */
 export declare function ifNull(col: ClickHouseColumn | SQLExpression, alt: any): SQLExpression;
-/**
- * Simple if-then-else conditional
- * @param condition - Condition to evaluate
- * @param trueVal - Value if condition is true
- * @param falseVal - Value if condition is false
- */
 export declare function sqlIf(condition: SQLExpression, trueVal: any, falseVal: any): SQLExpression;
-/**
- * Multi-conditional function for ClickHouse case-like logic
- * Usage: multiIf(cond1, val1, cond2, val2, ..., default)
- */
 export declare function multiIf(...args: (ClickHouseColumn | SQLExpression | any)[]): SQLExpression;
-/**
- * Case When builder for analytics queries
- * Compiles to multiIf for better DX
- *
- * @example
- * caseWhen()
- *   .when(gt(events.count, 100), sql`'high'`)
- *   .when(gt(events.count, 50), sql`'medium'`)
- *   .otherwise(sql`'low'`)
- */
 export declare function caseWhen(): CaseWhenBuilder;
 declare class CaseWhenBuilder {
     private conditions;
     private values;
     private defaultValue?;
-    /**
-     * Add a condition-value pair
-     * @param condition - The condition to evaluate
-     * @param value - The value to return if condition is true
-     */
     when(condition: ClickHouseColumn | SQLExpression, value: ClickHouseColumn | SQLExpression | any): this;
-    /**
-     * Set the default value (required)
-     * @param value - The default value to return if all conditions are false
-     */
     otherwise(value: ClickHouseColumn | SQLExpression | any): SQLExpression;
-    /**
-     * Build the final multiIf expression
-     */
     private build;
 }
-/**
- * Return first non-null value
- * @param args - Values to check
- */
 export declare function coalesce(...args: (ClickHouseColumn | SQLExpression | any)[]): SQLExpression;
-/**
- * Return greatest value
- * @param args - Values to compare
- */
 export declare function greatest(...args: (ClickHouseColumn | SQLExpression | any)[]): SQLExpression;
-/**
- * Return smallest value
- * @param args - Values to compare
- */
 export declare function least(...args: (ClickHouseColumn | SQLExpression | any)[]): SQLExpression;
-/**
- * Check if value is null
- * @param col - Column or expression to check
- */
 export declare function isNull(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Check if value is not null
- * @param col - Column or expression to check
- */
 export declare function isNotNull(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Convert to null if condition is met
- * @param condition - Condition to check
- * @param col - Column to convert to null
- */
 export declare function nullIf(condition: SQLExpression, col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Convert to null if value matches
- * @param col - Column to check
- * @param value - Value to match
- */
 export declare function nullIfEqual(col: ClickHouseColumn | SQLExpression, value: any): SQLExpression;
-/**
- * Logical NOT
- * @param expr - Expression to negate
- */
 export declare function not(expr: SQLExpression): SQLExpression;
-/**
- * Logical AND (multiple conditions)
- * @param exprs - Conditions to AND together
- */
 export declare function and(...exprs: (SQLExpression | undefined | null | false)[]): SQLExpression | undefined;
-/**
- * Logical OR (multiple conditions)
- * @param exprs - Conditions to OR together
- */
 export declare function or(...exprs: (SQLExpression | undefined | null | false)[]): SQLExpression | undefined;
-/**
- * Logical XOR (exclusive or)
- * @param expr1 - First expression
- * @param expr2 - Second expression
- */
 export declare function xor(expr1: SQLExpression, expr2: SQLExpression): SQLExpression;
 export {};