@housekit/orm 0.1.1

package/dist/materialized-views.d.ts

@@ -0,0 +1,271 @@
+/**
+ * HouseKit Materialized Views DSL - Type-Safe Materialized Views
+ *
+ * Unlike generic ORMs which often treat materialized views as static SQL strings,
+ * HouseKit allows defining MV queries using the Query Builder for
+ * compile-time type safety. If you rename a column in the source table,
+ * TypeScript will catch the error before deployment.
+ */
+import { ClickHouseColumn } from './column';
+import { type TableDefinition, type TableColumns } from './table';
+import { EngineConfiguration } from './engines';
+import { type SQLExpression } from './expressions';
+/**
+ * Helper type to extract columns from a TableDefinition
+ */
+export type InferTableColumns<T> = T extends TableDefinition<infer TCols> ? TCols : TableColumns;
+/**
+ * Helper type to ensure we have access to $columns
+ */
+type TableWithColumns<TCols extends TableColumns> = {
+    $table: string;
+    $columns: TCols;
+};
+/**
+ * Configuration for type-safe materialized views
+ */
+export interface MaterializedViewConfig<TSource extends TableDefinition<any>, TTargetCols extends TableColumns = TableColumns> {
+    /**
+     * Source table(s) for the materialized view.
+     * This is used to provide type information for the query builder.
+     */
+    source: TSource;
+    /**
+     * The query definition for the materialized view.
+     * Use the query builder to ensure type safety.
+     *
+     * @example
+     * ```typescript
+     * query: (qb) => qb
+     *   .from(events)
+     *   .select({
+     *     eventType: events.event_type,
+     *     count: sql`count()`
+     *   })
+     *   .groupBy(events.event_type)
+     * ```
+     */
+    query: (qb: MaterializedViewQueryBuilder<TSource>) => MaterializedViewQueryBuilder<any>;
+    /**
+     * Target table to write materialized data to.
+     * If not specified, ClickHouse creates an internal table.
+     *
+     * Can be:
+     * - A string table name
+     * - A TableDefinition reference (type-safe)
+     */
+    toTable?: string | TableDefinition<TTargetCols>;
+    /**
+     * Cluster name for distributed materialized view
+     */
+    onCluster?: string;
+    /**
+     * Whether to populate the MV with existing data on creation.
+     * Warning: Can be slow and resource-intensive for large tables.
+     */
+    populate?: boolean;
+    /**
+     * Engine configuration for the internal table (when toTable is not specified).
+     * Uses the type-safe Engine DSL.
+     */
+    engine?: EngineConfiguration;
+    /**
+     * Whether to use OR REPLACE semantics
+     */
+    orReplace?: boolean;
+    /**
+     * Optional ORDER BY for the internal storage table
+     */
+    orderBy?: string | string[];
+    /**
+     * Optional partition by for the internal storage table
+     */
+    partitionBy?: string | string[];
+}
+/**
+ * Simplified query builder for materialized view definitions.
+ * This is a subset of the full ClickHouseQueryBuilder that generates
+ * SQL without executing queries.
+ */
+export interface MaterializedViewQueryBuilder<TTable extends TableDefinition<any>> {
+    select<TSelection extends Record<string, ClickHouseColumn | SQLExpression>>(fields: TSelection): MaterializedViewQueryBuilder<TTable>;
+    from<TNewTable extends TableDefinition<any>>(table: TNewTable): MaterializedViewQueryBuilder<TNewTable>;
+    where(expression: SQLExpression): MaterializedViewQueryBuilder<TTable>;
+    groupBy(...cols: (ClickHouseColumn | SQLExpression)[]): MaterializedViewQueryBuilder<TTable>;
+    having(expression: SQLExpression): MaterializedViewQueryBuilder<TTable>;
+    orderBy(col: ClickHouseColumn | SQLExpression, dir?: 'ASC' | 'DESC'): MaterializedViewQueryBuilder<TTable>;
+    limit(val: number): MaterializedViewQueryBuilder<TTable>;
+    innerJoin(table: TableDefinition<any>, on: SQLExpression): MaterializedViewQueryBuilder<TTable>;
+    leftJoin(table: TableDefinition<any>, on: SQLExpression): MaterializedViewQueryBuilder<TTable>;
+    toSQL(): {
+        query: string;
+        params: Record<string, unknown>;
+    };
+}
+/**
+ * Extended type for materialized views - contains table-like properties
+ * plus MV-specific metadata for drift detection and query tracking.
+ */
+export type MaterializedViewDefinition<TCols extends TableColumns, TSource extends TableDefinition<any>, TOptions = MaterializedViewConfig<TSource>> = {
+    $table: string;
+    $columns: TCols;
+    $options: TOptions;
+    $kind: 'materializedView';
+    $source: TSource;
+    $querySQL: string;
+    $config: TOptions;
+    /**
+     * Get the SQL to create the materialized view
+     */
+    toSQL(): string;
+    /**
+     * Get all SQL statements (for views that need multiple statements)
+     */
+    toSQLs(): string[];
+    /**
+     * Create an aliased version for use in queries
+     */
+    as(alias: string): MaterializedViewDefinition<TCols, TSource, TOptions>;
+} & TCols;
+/**
+ * Result type for projection definitions using query builder
+ */
+export interface TypedProjectionDefinition<TSource extends TableDefinition<any>> {
+    name: string;
+    query: string;
+    sourceTable: TSource;
+    orderBy?: string[];
+}
+/**
+ * Create a type-safe materialized view definition.
+ * The query is defined using a query builder that validates column references
+ * at compile time.
+ *
+ * @example
+ * ```typescript
+ * import { defineMaterializedView, text, uint64, sql, Engine } from '@housekit/orm';
+ *
+ * // Source table
+ * const events = defineTable('events', {
+ *   event_type: t.text('event_type'),
+ *   user_id: t.text('user_id'),
+ *   revenue: t.uint64('revenue'),
+ * }, { engine: Engine.MergeTree(), orderBy: 'event_type' });
+ *
+ * // Type-safe materialized view
+ * export const revenueByEvent = defineMaterializedView('revenue_by_event_mv', {
+ *   event_type: t.text('event_type'),
+ *   total_revenue: t.uint64('total_revenue'),
+ *   event_count: t.uint64('event_count'),
+ * }, {
+ *   source: events,
+ *   query: (qb) => qb
+ *     .from(events)  // Type-safe: only accepts events columns
+ *     .select({
+ *       event_type: events.event_type,
+ *       total_revenue: sql`sum(${events.revenue})`,
+ *       event_count: sql`count()`,
+ *     })
+ *     .groupBy(events.event_type),
+ *   engine: Engine.SummingMergeTree(['total_revenue', 'event_count']),
+ *   orderBy: 'event_type',
+ * });
+ * ```
+ */
+export declare function chMaterializedView<TCols extends TableColumns, TSource extends TableDefinition<any>, TTarget extends TableColumns = TCols>(name: string, columns: TCols, config: MaterializedViewConfig<TSource, TTarget>): MaterializedViewDefinition<TCols, TSource, MaterializedViewConfig<TSource, TTarget>>;
+/**
+ * Create a type-safe projection definition.
+ *
+ * Projections are precomputed aggregations stored alongside the main table.
+ * They're automatically used by ClickHouse when the query matches.
+ *
+ * @example
+ * ```typescript
+ * const events = defineTable('events', {
+ *   event_type: t.text('event_type'),
+ *   user_id: t.text('user_id'),
+ *   created_at: t.timestamp('created_at'),
+ * }, {
+ *   engine: Engine.MergeTree(),
+ *   orderBy: ['event_type', 'created_at'],
+ *   projections: [
+ *     // Type-safe projection
+ *     chProjection('events_by_user', events, (cols) => ({
+ *       select: {
+ *         user_id: cols.user_id,
+ *         event_type: cols.event_type,
+ *         event_count: sql`count()`,
+ *       },
+ *       groupBy: [cols.user_id, cols.event_type],
+ *       orderBy: ['user_id', 'event_type'],
+ *     })),
+ *   ],
+ * });
+ * ```
+ */
+export declare function chProjection<TCols extends TableColumns, TSource extends TableDefinition<TCols>>(name: string, sourceTable: TSource & TableWithColumns<TCols>, definition: (cols: TCols) => {
+    select: Record<string, ClickHouseColumn | SQLExpression>;
+    groupBy?: (ClickHouseColumn | SQLExpression)[];
+    orderBy?: string[];
+}): TypedProjectionDefinition<TSource>;
+/**
+ * Convert a TypedProjectionDefinition to the format expected by defineTable
+ */
+export declare function toProjectionDefinition(projection: TypedProjectionDefinition<any>): {
+    name: string;
+    query: string;
+};
+/**
+ * Normalize SQL for comparison (removes extra whitespace, normalizes case)
+ */
+export declare function normalizeSQL(sql: string): string;
+/**
+ * Compare two materialized view definitions for drift
+ */
+export declare function detectMaterializedViewDrift(local: MaterializedViewDefinition<any, any>, remoteSQL: string): {
+    hasDrift: boolean;
+    localSQL: string;
+    remoteSQL: string;
+    normalizedLocal: string;
+    normalizedRemote: string;
+};
+/**
+ * Extract the AS query from a CREATE MATERIALIZED VIEW statement
+ */
+export declare function extractMVQuery(createStatement: string): string | null;
+/**
+ * Generate a Blue-Green migration plan for a Materialized View update.
+ *
+ * Instead of just dropping and recreating, we:
+ * 1. Create a "next" version of the target table (if using TO table)
+ * 2. Create a "next" version of the MV
+ * 3. Backfill data from source table using the NEW query
+ * 4. Swap them using RENAME
+ */
+export declare function generateBlueGreenMigration(oldMV: MaterializedViewDefinition<any, any>, newMV: MaterializedViewDefinition<any, any>, options?: {
+    backfill?: boolean;
+}): string[];
+/**
+ * Creates a "migration bridge" Materialized View that synchronizes data from an old table to a new one.
+ * This is extremely useful for zero-downtime migrations where you need to pipe real-time
+ * inserts from the v1 table into the v2 table while you perform a separate historical backfill.
+ *
+ * @example
+ * ```typescript
+ * const bridge = createMigrationBridge({
+ *   from: tableV1,
+ *   to: tableV2,
+ *   mapping: {
+ *     new_col: sql`upper(${tableV1.old_col})`
+ *   }
+ * });
+ * ```
+ */
+export declare function createMigrationBridge<TSourceCols extends TableColumns, TTargetCols extends TableColumns>(options: {
+    from: TableDefinition<TSourceCols>;
+    to: TableDefinition<TTargetCols>;
+    mapping?: Record<string, ClickHouseColumn | SQLExpression>;
+    name?: string;
+    onCluster?: string;
+}): MaterializedViewDefinition<TTargetCols, TableDefinition<TSourceCols>>;
+export {};

package/dist/metadata.d.ts

@@ -0,0 +1,33 @@
+export declare const supportedMetadataVersions: readonly ["1.1.0", "1.2.0"];
+export type MetadataVersion = typeof supportedMetadataVersions[number];
+export declare const defaultMetadataVersion: MetadataVersion;
+export type HousekitMetadata = {
+    version: '1.1.0';
+    appendOnly: boolean;
+} | {
+    version: '1.2.0';
+    appendOnly: boolean;
+    readOnly: boolean;
+};
+export declare const housekitMetadataSchemas: Record<MetadataVersion, Record<string, string>>;
+export declare const housekitMetadataDefaults: Record<MetadataVersion, {
+    appendOnly: boolean;
+    readOnly?: boolean;
+}>;
+export declare function assertMetadataVersion(version: string): asserts version is MetadataVersion;
+export declare function getMetadataDefaults(version: MetadataVersion): {
+    appendOnly: boolean;
+    readOnly?: boolean;
+};
+export declare function buildHousekitMetadata(version: MetadataVersion, opts: {
+    appendOnly?: boolean;
+    readOnly?: boolean;
+}): HousekitMetadata;
+export declare function normalizeHousekitMetadata(raw: any): {
+    version: MetadataVersion;
+    meta: HousekitMetadata;
+} | null;
+export declare function upgradeMetadataVersion(base: HousekitMetadata | null, targetVersion: MetadataVersion, overrides?: {
+    appendOnly?: boolean;
+    readOnly?: boolean;
+}): HousekitMetadata;

package/dist/modules/aggregates.d.ts

@@ -0,0 +1,205 @@
+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/array.d.ts

@@ -0,0 +1,122 @@
+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>;