@514labs/moose-lib 0.6.527 → 0.6.528

package/dist/{view-BCWJcLF6.d.mts → query-client-6YrlC3Df.d.mts}

@@ -3,6 +3,421 @@ import { IJsonSchemaCollection, tags } from 'typia';
 import { Pattern, TagBase } from 'typia/lib/tags';
 import { Readable } from 'node:stream';
 
+/**
+ * Configuration options for creating a View.
+ */
+interface ViewConfig {
+    /** The SQL SELECT statement or Sql object defining the view's logic. */
+    selectStatement: string | Sql;
+    /** Source tables/views the SELECT reads from. Used for dependency tracking during migrations. */
+    baseTables: (OlapTable<any> | View)[];
+    /** Optional database where the view is created. When set, the view is created as `database`.`name` in ClickHouse. */
+    database?: string;
+    /** Optional metadata for the view (e.g., description, source file). */
+    metadata?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Represents a database View, defined by a SQL SELECT statement based on one or more base tables or other views.
+ * Emits structured data for the Moose infrastructure system.
+ */
+declare class View {
+    /** @internal */
+    readonly kind = "View";
+    /** The name of the view */
+    name: string;
+    /** Optional database where the view is created. When set, the view is created as `database`.`name` in ClickHouse. */
+    database?: string;
+    /** The SELECT SQL statement that defines the view */
+    selectSql: string;
+    /** Names of source tables/views that the SELECT reads from */
+    sourceTables: string[];
+    /** Optional metadata for the view */
+    metadata: {
+        [key: string]: any;
+    };
+    /**
+     * Creates a new View instance.
+     * @param name The name of the view to be created.
+     * @param config Configuration for the view: select statement, base tables, optional database, and optional metadata.
+     */
+    constructor(name: string, config: ViewConfig);
+    /**
+     * @deprecated Use the config-object overload: `new View(name, { selectStatement, baseTables, metadata? })`.
+     */
+    constructor(name: string, selectStatement: string | Sql, baseTables: (OlapTable<any> | View)[], metadata?: {
+        [key: string]: any;
+    });
+}
+
+/**
+ * Defines how Moose manages the lifecycle of database resources when your code changes.
+ *
+ * This enum controls the behavior when there are differences between your code definitions
+ * and the actual database schema or structure.
+ */
+declare enum LifeCycle {
+    /**
+     * Full automatic management (default behavior).
+     * Moose will automatically modify database resources to match your code definitions,
+     * including potentially destructive operations like dropping columns or tables.
+     */
+    FULLY_MANAGED = "FULLY_MANAGED",
+    /**
+     * Deletion-protected automatic management.
+     * Moose will modify resources to match your code but will avoid destructive actions
+     * such as dropping columns, or tables. Only additive changes are applied.
+     */
+    DELETION_PROTECTED = "DELETION_PROTECTED",
+    /**
+     * External management - no automatic changes.
+     * Moose will not modify the database resources. You are responsible for managing
+     * the schema and ensuring it matches your code definitions manually.
+     */
+    EXTERNALLY_MANAGED = "EXTERNALLY_MANAGED"
+}
+
+/**
+ * Per-column attribute configuration for dictionary attributes.
+ * The column name and ClickHouse type are inferred from the TypeScript generic T.
+ * This object carries optional ClickHouse dictionary attribute flags.
+ */
+interface DictionaryColumnConfig {
+    /** DEFAULT expression — fallback value when key is not found */
+    defaultValue?: string;
+    /** EXPRESSION attribute — computed from other columns */
+    expression?: string;
+    /** IS_INJECTIVE — enables GROUP BY optimization (one-to-one mapping) */
+    isInjective?: boolean;
+    /** IS_HIERARCHICAL — enables hierarchical parent-child lookups */
+    isHierarchical?: boolean;
+    /** IS_OBJECT_ID — MongoDB-specific attribute */
+    isObjectId?: boolean;
+    /** Optional column comment */
+    comment?: string;
+}
+/**
+ * ClickHouse dictionary layout types.
+ * All 16 layout variants with their per-layout parameters.
+ * The `type` field uses SCREAMING_SNAKE_CASE to match Rust serde.
+ */
+type DictionaryLayout = {
+    type: "FLAT";
+} | {
+    type: "HASHED";
+    initialArraySize?: number;
+    maxLoadFactor?: number;
+} | {
+    type: "SPARSE_HASHED";
+    initialArraySize?: number;
+    maxLoadFactor?: number;
+} | {
+    type: "HASHED_ARRAY";
+    shards?: number;
+} | {
+    type: "RANGE_HASHED";
+    rangeLookupStrategy?: string;
+} | {
+    type: "CACHE";
+    sizeInCells: number;
+    maxThreadsForUpdates?: number;
+} | {
+    type: "SSD_CACHE";
+    path: string;
+    blockSize?: number;
+    fileSize?: number;
+    readBufferSize?: number;
+    writeBufferSize?: number;
+    maxStoredKeys?: number;
+} | {
+    type: "DIRECT";
+} | {
+    type: "IP_TRIE";
+    accessToKeyFromAttributes?: boolean;
+} | {
+    type: "COMPLEX_KEY_HASHED";
+    initialArraySize?: number;
+    maxLoadFactor?: number;
+} | {
+    type: "COMPLEX_KEY_SPARSE_HASHED";
+    initialArraySize?: number;
+    maxLoadFactor?: number;
+} | {
+    type: "COMPLEX_KEY_HASHED_ARRAY";
+    shards?: number;
+} | {
+    type: "COMPLEX_KEY_CACHE";
+    sizeInCells: number;
+    maxThreadsForUpdates?: number;
+} | {
+    type: "COMPLEX_KEY_SSD_CACHE";
+    path: string;
+    blockSize?: number;
+    fileSize?: number;
+    readBufferSize?: number;
+    writeBufferSize?: number;
+    maxStoredKeys?: number;
+} | {
+    type: "COMPLEX_KEY_DIRECT";
+};
+/** Set of COMPLEX_KEY_* layouts that accept any-type keys (string, composite, etc.) and support one or more primary key columns */
+declare const COMPLEX_KEY_LAYOUTS: Set<"FLAT" | "HASHED" | "SPARSE_HASHED" | "HASHED_ARRAY" | "RANGE_HASHED" | "CACHE" | "SSD_CACHE" | "DIRECT" | "IP_TRIE" | "COMPLEX_KEY_HASHED" | "COMPLEX_KEY_SPARSE_HASHED" | "COMPLEX_KEY_HASHED_ARRAY" | "COMPLEX_KEY_CACHE" | "COMPLEX_KEY_SSD_CACHE" | "COMPLEX_KEY_DIRECT">;
+/**
+ * Dictionary lifetime configuration.
+ * - `0` → LIFETIME(0) — static, never reloads
+ * - `N` (positive number) → LIFETIME(N) — reload every N seconds
+ * - `{ min: N, max: M }` → LIFETIME(MIN N MAX M) — reload with jitter
+ */
+type DictionaryLifetime = number | {
+    min: number;
+    max: number;
+};
+/** HTTP endpoint source */
+interface HttpExternalSource {
+    type: "http";
+    url: string;
+    format: string;
+    method?: string;
+    whereClause?: string;
+}
+/** Remote ClickHouse server source */
+interface ClickHouseExternalSource {
+    type: "clickhouse";
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    db: string;
+    table: string;
+    query?: string;
+    whereClause?: string;
+    invalidateQuery?: string;
+}
+/** MySQL database source */
+interface MysqlExternalSource {
+    type: "mysql";
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    db: string;
+    table: string;
+    query?: string;
+    whereClause?: string;
+    invalidateQuery?: string;
+}
+/** PostgreSQL database source */
+interface PostgresqlExternalSource {
+    type: "postgresql";
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    db: string;
+    table: string;
+    query?: string;
+    whereClause?: string;
+    invalidateQuery?: string;
+}
+/** Redis source */
+interface RedisExternalSource {
+    type: "redis";
+    host: string;
+    port: number;
+    password?: string;
+    dbIndex?: number;
+    /** Storage type: "simple", "hash", "range_hashed", etc. */
+    storageType: string;
+}
+/** MongoDB collection source */
+interface MongodbExternalSource {
+    type: "mongodb";
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    db: string;
+    collection: string;
+}
+/** External executable process source */
+interface ExecutableExternalSource {
+    type: "executable";
+    command: string;
+    format: string;
+    implicitKey?: boolean;
+}
+/** S3 object storage source */
+interface S3ExternalSource {
+    type: "s3";
+    url: string;
+    format: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+}
+/** Union of all supported external source types */
+type ExternalSource = HttpExternalSource | ClickHouseExternalSource | MysqlExternalSource | PostgresqlExternalSource | RedisExternalSource | MongodbExternalSource | ExecutableExternalSource | S3ExternalSource;
+/**
+ * Configuration for creating an OlapDictionary.
+ *
+ * Exactly ONE of `sourceTable`, `sourceQuery`, or `externalSource` must be set.
+ */
+interface OlapDictionaryConfig<T> {
+    /**
+     * Read from a local ClickHouse table managed by Moose.
+     * Moose automatically tracks this as a dependency.
+     */
+    sourceTable?: OlapTable<any> | View;
+    /**
+     * Read from an arbitrary SQL query on the local ClickHouse.
+     * Requires `sourceTables` to be set for dependency tracking.
+     * Use the `sql` template tag: `sql\`SELECT ...\``
+     */
+    sourceQuery?: Sql;
+    /**
+     * The tables referenced in `sourceQuery`.
+     * Required when `sourceQuery` is set to enable dependency tracking.
+     */
+    sourceTables?: (OlapTable<any> | View)[];
+    /**
+     * Read from an external data source (HTTP, MySQL, PostgreSQL, Redis, etc.).
+     * Use `mooseRuntimeEnv.get()` for credentials — never hardcode secrets.
+     */
+    externalSource?: ExternalSource;
+    /** Primary key column names. Use a single column for simple layouts (FLAT, HASHED, CACHE, DIRECT, IP_TRIE, RANGE_HASHED) and multiple columns for COMPLEX_KEY_* layouts. */
+    primaryKey: (keyof T & string)[];
+    /** Per-column attribute overrides (DEFAULT, EXPRESSION, INJECTIVE, HIERARCHICAL, IS_OBJECT_ID). Column names and types are inferred from T. */
+    columns?: Partial<Record<keyof T & string, DictionaryColumnConfig>>;
+    /** Dictionary memory layout. Controls in-memory data structure and lookup performance. */
+    layout: DictionaryLayout;
+    /** Refresh policy: 0 = static, N = every N seconds, { min, max } = random interval */
+    lifetime: DictionaryLifetime;
+    /** Database where the dictionary is created. Defaults to the project's default database. */
+    database?: string;
+    /** ON CLUSTER name for distributed ClickHouse deployments. */
+    clusterName?: string;
+    /** Optional top-level INVALIDATE_QUERY expression. */
+    invalidateQuery?: string;
+    /** Additional ClickHouse dictionary settings (key=value pairs). */
+    settings?: Record<string, string>;
+    /** Optional dictionary COMMENT. */
+    comment?: string;
+    /** Lifecycle management policy. Defaults to FULLY_MANAGED. */
+    lifeCycle?: LifeCycle;
+    /** Optional metadata for documentation and tooling. */
+    metadata?: {
+        description?: string;
+        [key: string]: any;
+    };
+}
+/** JSON shape for a single DictionaryColumn, matching Rust's #[serde(rename_all = "camelCase")] */
+interface DictionaryColumnJson {
+    name: string;
+    typeString: string;
+    defaultValue?: string;
+    expression?: string;
+    isInjective?: boolean;
+    isHierarchical?: boolean;
+    isObjectId?: boolean;
+    comment?: string;
+}
+/**
+ * Represents a ClickHouse Dictionary — an in-memory key-value store for fast
+ * point lookups backed by a local ClickHouse table, a SQL query, or an
+ * external data source (MySQL, PostgreSQL, HTTP, Redis, S3, etc.).
+ *
+ * Dictionaries are significantly faster than JOINs for repeated lookups of
+ * static or slowly-changing reference data.
+ *
+ * @example
+ * ```typescript
+ * interface ProductLookup {
+ *   ProductId: string;
+ *   ProductName: string;
+ *   PriceLevel: number & ClickHouseInt<"Int32">;
+ * }
+ *
+ * export const ProductDict = new OlapDictionary<ProductLookup>("dict_products", {
+ *   sourceTable: ProductsTable,
+ *   primaryKey: ["ProductId"],
+ *   layout: { type: "HASHED" },
+ *   lifetime: 3600,
+ * });
+ *
+ * // Use in a materialized view:
+ * sql`SELECT ${ProductDict.get("ProductName", sql.raw("product_id"))} AS name FROM ...`
+ * ```
+ */
+declare class OlapDictionary<T> {
+    /** @internal */
+    readonly kind = "OlapDictionary";
+    /** Dictionary name */
+    readonly name: string;
+    /** User configuration */
+    readonly config: OlapDictionaryConfig<T>;
+    /** Compiler-injected columns (name + type from T) */
+    readonly _columns: Column[];
+    /** Serialized column list (DictionaryColumn JSON objects) */
+    readonly serializedColumns: DictionaryColumnJson[];
+    /**
+     * Creates a new OlapDictionary.
+     *
+     * @param name - Dictionary name (used in ClickHouse DDL and dictGet calls)
+     * @param config - Dictionary configuration
+     */
+    constructor(name: string, config: OlapDictionaryConfig<T>);
+    /** @internal — compiler plugin injects schema and columns */
+    constructor(name: string, config: OlapDictionaryConfig<T>, _schema: IJsonSchemaCollection.IV3_1, columns: Column[]);
+    /**
+     * Returns the qualified dictionary name for use in dictGet calls.
+     * Format: `database.name` if database is set, otherwise just `name`.
+     */
+    getQualifiedName(): string;
+    /**
+     * Formats key arguments for use in dictGet/dictHas SQL functions.
+     * Strings are treated as SQL identifiers, numbers as literals.
+     */
+    private formatKeyArgs;
+    /**
+     * Generates a `dictGet('dict', 'attr', key)` SQL fragment.
+     *
+     * @param attr - The attribute (column) name to retrieve
+     * @param keys - Key expression(s). Strings are treated as column identifiers.
+     *
+     * @example
+     * ```typescript
+     * sql`SELECT ${ProductDict.get("ProductName", "product_id")} AS name FROM ...`
+     * // → SELECT dictGet('db.dict_products', 'ProductName', `product_id`) AS name FROM ...
+     * ```
+     */
+    get(attr: keyof T & string, ...keys: Array<Sql | string | number>): Sql;
+    /**
+     * Generates a `dictGetOrDefault('dict', 'attr', key, default)` SQL fragment.
+     *
+     * @param attr - The attribute (column) name to retrieve
+     * @param defaultVal - The default value if the key is not found
+     * @param keys - Key expression(s)
+     */
+    getOrDefault(attr: keyof T & string, defaultVal: Sql | string | number, ...keys: Array<Sql | string | number>): Sql;
+    /**
+     * Generates a `dictHas('dict', key)` SQL fragment.
+     *
+     * @param keys - Key expression(s)
+     *
+     * @example
+     * ```typescript
+     * sql`SELECT * FROM source WHERE ${ProductDict.has("product_id")}`
+     * // → SELECT * FROM source WHERE dictHas('db.dict_products', `product_id`)
+     * ```
+     */
+    has(...keys: Array<Sql | string | number>): Sql;
+    /**
+     * Serializes this dictionary to the JSON format expected by the Rust CLI.
+     * @internal
+     */
+    toJson(): Record<string, unknown>;
+}
+
 /**
  * Quote a ClickHouse identifier with backticks if not already quoted.
  * Backticks allow special characters (e.g., hyphens) in identifiers.
@@ -29,17 +444,17 @@ interface SqlTemplateTag {
     /**
      * @deprecated Use `sql.statement` for full SQL statements or `sql.fragment` for SQL fragments.
      */
-    (strings: readonly string[], ...values: readonly (RawValue | Column | OlapTable<any> | View)[]): Sql;
+    (strings: readonly string[], ...values: readonly (RawValue | Column | OlapTable<any> | View | OlapDictionary<any>)[]): Sql;
     /**
      * Template literal tag for complete SQL statements (e.g. SELECT, INSERT, CREATE).
      * Produces a Sql instance with `isFragment = false`.
      */
-    statement(strings: readonly string[], ...values: readonly (RawValue | Column | OlapTable<any> | View)[]): Sql;
+    statement(strings: readonly string[], ...values: readonly (RawValue | Column | OlapTable<any> | View | OlapDictionary<any>)[]): Sql;
     /**
      * Template literal tag for SQL fragments (e.g. expressions, conditions, partial clauses).
      * Produces a Sql instance with `isFragment = true`.
      */
-    fragment(strings: readonly string[], ...values: readonly (RawValue | Column | OlapTable<any> | View)[]): Sql;
+    fragment(strings: readonly string[], ...values: readonly (RawValue | Column | OlapTable<any> | View | OlapDictionary<any>)[]): Sql;
     /**
      * Join an array of Sql fragments with a separator.
      * @param fragments - Array of Sql fragments to join
@@ -60,7 +475,7 @@ declare class Sql {
     readonly values: Value[];
     readonly strings: string[];
     readonly isFragment: boolean | undefined;
-    constructor(rawStrings: readonly string[], rawValues: readonly (RawValue | Column | OlapTable<any> | View | Sql)[], isFragment?: boolean);
+    constructor(rawStrings: readonly string[], rawValues: readonly (RawValue | Column | OlapTable<any> | View | OlapDictionary<any> | Sql)[], isFragment?: boolean);
     /**
      * Append another Sql fragment, returning a new Sql instance.
      */
@@ -494,33 +909,6 @@ declare enum ClickHouseEngines {
     ReplicatedVersionedCollapsingMergeTree = "ReplicatedVersionedCollapsingMergeTree"
 }
 
-/**
- * Defines how Moose manages the lifecycle of database resources when your code changes.
- *
- * This enum controls the behavior when there are differences between your code definitions
- * and the actual database schema or structure.
- */
-declare enum LifeCycle {
-    /**
-     * Full automatic management (default behavior).
-     * Moose will automatically modify database resources to match your code definitions,
-     * including potentially destructive operations like dropping columns or tables.
-     */
-    FULLY_MANAGED = "FULLY_MANAGED",
-    /**
-     * Deletion-protected automatic management.
-     * Moose will modify resources to match your code but will avoid destructive actions
-     * such as dropping columns, or tables. Only additive changes are applied.
-     */
-    DELETION_PROTECTED = "DELETION_PROTECTED",
-    /**
-     * External management - no automatic changes.
-     * Moose will not modify the database resources. You are responsible for managing
-     * the schema and ensuring it matches your code definitions manually.
-     */
-    EXTERNALLY_MANAGED = "EXTERNALLY_MANAGED"
-}
-
 interface TableIndex {
     name: string;
     expression: string;
@@ -1364,52 +1752,4 @@ declare class QueryClient {
     command(sql: Sql): Promise<CommandResult>;
 }
 
-/**
- * Configuration options for creating a View.
- */
-interface ViewConfig {
-    /** The SQL SELECT statement or Sql object defining the view's logic. */
-    selectStatement: string | Sql;
-    /** Source tables/views the SELECT reads from. Used for dependency tracking during migrations. */
-    baseTables: (OlapTable<any> | View)[];
-    /** Optional database where the view is created. When set, the view is created as `database`.`name` in ClickHouse. */
-    database?: string;
-    /** Optional metadata for the view (e.g., description, source file). */
-    metadata?: {
-        [key: string]: any;
-    };
-}
-/**
- * Represents a database View, defined by a SQL SELECT statement based on one or more base tables or other views.
- * Emits structured data for the Moose infrastructure system.
- */
-declare class View {
-    /** @internal */
-    readonly kind = "View";
-    /** The name of the view */
-    name: string;
-    /** Optional database where the view is created. When set, the view is created as `database`.`name` in ClickHouse. */
-    database?: string;
-    /** The SELECT SQL statement that defines the view */
-    selectSql: string;
-    /** Names of source tables/views that the SELECT reads from */
-    sourceTables: string[];
-    /** Optional metadata for the view */
-    metadata: {
-        [key: string]: any;
-    };
-    /**
-     * Creates a new View instance.
-     * @param name The name of the view to be created.
-     * @param config Configuration for the view: select statement, base tables, optional database, and optional metadata.
-     */
-    constructor(name: string, config: ViewConfig);
-    /**
-     * @deprecated Use the config-object overload: `new View(name, { selectStatement, baseTables, metadata? })`.
-     */
-    constructor(name: string, selectStatement: string | Sql, baseTables: (OlapTable<any> | View)[], metadata?: {
-        [key: string]: any;
-    });
-}
-
-export { QueryClient as $, type Decimal as A, type Insertable as B, ClickHouseEngines as C, type DateTime as D, quoteIdentifier as E, type FixedString as F, type IdentifierBrandedString as G, type Value as H, type Int8 as I, type SqlTemplateTag as J, sql as K, LifeCycle as L, Sql as M, type NonIdentifierBrandedString as N, OlapTable as O, toStaticQuery as P, toQuery as Q, type RawValue as R, type S3QueueTableSettings as S, type TableConstraint as T, type UInt8 as U, View as V, type WithDefault as W, toQueryPreview as X, getValueFromParameter as Y, createClickhouseParameter as Z, mapToClickHouseType as _, type OlapConfig as a, TypedBase as a0, type Column as a1, type RowPolicyOptions as a2, type TypiaValidators as a3, type ViewConfig as a4, type DataType as a5, type ClickHousePoint as a6, type ClickHouseRing as a7, type ClickHouseLineString as a8, type ClickHouseMultiLineString as a9, type ClickHousePolygon as aa, type ClickHouseMultiPolygon as ab, type ClickHousePrecision as b, type ClickHouseDecimal as c, type ClickHouseByteSize as d, type ClickHouseFixedStringSize as e, type ClickHouseFloat as f, type ClickHouseInt as g, type ClickHouseJson as h, type LowCardinality as i, type ClickHouseNamedTuple as j, type ClickHouseDefault as k, type ClickHouseTTL as l, type ClickHouseMaterialized as m, type ClickHouseAlias as n, type ClickHouseCodec as o, type DateTime64 as p, type DateTimeString as q, type DateTime64String as r, type Float32 as s, type Float64 as t, type Int16 as u, type Int32 as v, type Int64 as w, type UInt16 as x, type UInt32 as y, type UInt64 as z };
+export { type Insertable as $, type DateTimeString as A, type DateTime64String as B, ClickHouseEngines as C, type DictionaryColumnConfig as D, type ExternalSource as E, type FixedString as F, type Float32 as G, type HttpExternalSource as H, type Float64 as I, type Int8 as J, type Int16 as K, LifeCycle as L, type MysqlExternalSource as M, type Int32 as N, OlapTable as O, type PostgresqlExternalSource as P, type Int64 as Q, type RedisExternalSource as R, type S3QueueTableSettings as S, type TableConstraint as T, type UInt8 as U, View as V, type WithDefault as W, type UInt16 as X, type UInt32 as Y, type UInt64 as Z, type Decimal as _, type OlapConfig as a, quoteIdentifier as a0, type IdentifierBrandedString as a1, type NonIdentifierBrandedString as a2, type Value as a3, type RawValue as a4, type SqlTemplateTag as a5, sql as a6, Sql as a7, toStaticQuery as a8, toQuery as a9, toQueryPreview as aa, getValueFromParameter as ab, createClickhouseParameter as ac, mapToClickHouseType as ad, QueryClient as ae, TypedBase as af, type Column as ag, type RowPolicyOptions as ah, type TypiaValidators as ai, type ViewConfig as aj, type DataType as ak, type ClickHousePoint as al, type ClickHouseRing as am, type ClickHouseLineString as an, type ClickHouseMultiLineString as ao, type ClickHousePolygon as ap, type ClickHouseMultiPolygon as aq, OlapDictionary as b, type OlapDictionaryConfig as c, type DictionaryLayout as d, type DictionaryLifetime as e, type ClickHouseExternalSource as f, type MongodbExternalSource as g, type ExecutableExternalSource as h, type S3ExternalSource as i, COMPLEX_KEY_LAYOUTS as j, type ClickHousePrecision as k, type ClickHouseDecimal as l, type ClickHouseByteSize as m, type ClickHouseFixedStringSize as n, type ClickHouseFloat as o, type ClickHouseInt as p, type ClickHouseJson as q, type LowCardinality as r, type ClickHouseNamedTuple as s, type ClickHouseDefault as t, type ClickHouseTTL as u, type ClickHouseMaterialized as v, type ClickHouseAlias as w, type ClickHouseCodec as x, type DateTime as y, type DateTime64 as z };