sqllens 1.0.0 → 1.2.0

package/dist/ident/fold.d.ts

@@ -1,18 +1,27 @@
 /** "table" = a table/view identifier — only BigQuery treats these differently from everything
  *  else (columns, aliases, CTE names, struct/field names, …), which is "other". */
 export type IdentKind = "table" | "other";
-/** Unquote (dialect's delimiters, doubled-delimiter unescape) + case-fold per the dialect's
- *  documented identifier rules. The result is the IDENTITY KEY for name comparison — display
- *  text always comes from the raw source, never from this. */
-export declare function foldIdentifier(raw: string, dialect: string | undefined, kind?: IdentKind): string;
-/** PRESENTATION twin of foldIdentifier: strip the dialect's delimiters (unescaping the body) but
- *  apply NO case change — the string a UI shows for a name. Never use this for comparison; two
- *  displayName results being equal proves nothing about identity. */
-export declare function displayName(raw: string, dialect: string | undefined): string;
-/** Fold a multipart table name for a catalog lookup — every part folded with kind "table" (only
- *  BigQuery treats table parts specially; everywhere else this is the plain fold). */
-export declare function foldTableName(parts: string[], dialect: string | undefined): string[];
-/** True when a source-map KEY (already folded — an alias folded as "other", or a table's last name
- *  part folded as "table") matches a RAW qualifier part. Tries both folds; they differ only for
- *  BigQuery, whose table identifiers preserve case while aliases/columns fold lower. */
-export declare function matchesSourceKey(key: string, rawPart: string, dialect: string | undefined): boolean;
+type CaseFold = "lower" | "upper" | "preserve";
+export interface FoldRule {
+    /** [open, close] delimiter pairs this dialect recognizes, tried in order. */
+    delimiters: readonly (readonly [string, string])[];
+    /** Case fold applied to an unquoted identifier. */
+    unquoted: "lower" | "upper";
+    /** Case fold applied to a quoted (delimited) identifier. */
+    quoted: CaseFold;
+    /** BigQuery only: table identifiers preserve case whether or not they're backtick-quoted —
+     *  backticks there are an escaping mechanism, not a case-quoting one. When set, this
+     *  overrides both `unquoted`/`quoted` for kind:"table". */
+    tableCase?: "preserve";
+    /** How an escaped delimiter is written inside a quoted identifier's body.
+     *  "double" (default) — the close delimiter is escaped by doubling it (`""`→`"`, `` `` ``→`` ` ``,
+     *  `]]`→`]`).
+     *  "backslash" — BigQuery only (see its rule comment): quoted identifiers use string-literal escape
+     *  sequences, not doubling. */
+    escapeStyle?: "double" | "backslash";
+}
+/** Fold an identifier to its identity key under an explicit rule (the engine each dialect folder binds). */
+export declare function foldWith(rule: FoldRule, raw: string, kind?: IdentKind): string;
+/** Presentation twin of foldWith: strip delimiters, no case change. */
+export declare function displayWith(rule: FoldRule, raw: string): string;
+export {};

package/dist/ident/fold.js

@@ -1,128 +1,12 @@
-// Dialect-true identifier case-folding — the single fold module every dialect's scope/qualify/
-// references pass threads through (Tasks 2-3 wire the callers; this module is self-contained).
+// The dialect-agnostic identifier case-folding ENGINE. A dialect owns its FoldRule (in
+// src/<dialect>/fold.ts) and binds it to these functions; the registry maps a dialect string to that
+// bound behavior. This module holds no per-dialect knowledge — only the rule shape and the fold/display
+// mechanics every dialect's rule runs through.
 //
-// The result of foldIdentifier() is an IDENTITY KEY for name comparison ONLY — display text
-// always comes from the raw source text, never from this function's return value. Getting the
-// fold DIRECTION wrong silently breaks equality: e.g. Snowflake's unquoted `foo` must equal
-// quoted `"FOO"` and must NOT equal quoted `"foo"` — a lowercase fold gets both wrong.
-//
-// Every rule row below was verified against the LIVE vendor page (not training data) before
-// encoding; citations note the verbatim wording that decided the direction, and any place the
-// live page diverged from the originally proposed rule.
-const DOUBLE_QUOTE = ['"', '"'];
-const BACKTICK = ["`", "`"];
-const RULES = {
-    // docs.databricks.com/en/sql/language-manual/sql-ref-identifiers.html — verified live:
-    // "Identifiers are case-insensitive when referenced." Backtick escaping is doubling, not
-    // case-quoting: "Use ` to escape ` itself" (example: `` `a``b` `` → `` a`b ``).
-    databricks: {
-        delimiters: [BACKTICK],
-        unquoted: "lower",
-        quoted: "lower",
-    },
-    // learn.microsoft.com/en-us/sql/relational-databases/databases/database-identifiers +
-    // .../sql/t-sql/statements/collations — verified live: case folding is NOT a hardcoded T-SQL
-    // rule, it's a function of the identifier's COLLATION: "you can create two tables with names
-    // that differ only in case in a database that has case-sensitive collation, but you can't...
-    // in a database that has case-insensitive collation." Most SQL Server / Fabric SQL database
-    // defaults are case-insensitive (e.g. SQL_Latin1_General_CP1_CI_AS), but this is not universal
-    // — Fabric Warehouse defaults to the case-SENSITIVE Latin1_General_100_BIN2_UTF8. This module
-    // encodes the common default-collation (CI) behavior; a caller with a known case-sensitive
-    // collation is a documented boundary this module does not cross. Delimiting with `[ ]` or
-    // `" "` does not itself change case behavior — quoting only unlocks reserved words/specials.
-    tsql: {
-        delimiters: [["[", "]"], DOUBLE_QUOTE],
-        unquoted: "lower",
-        quoted: "lower",
-    },
-    // docs.snowflake.com/en/sql-reference/identifiers-syntax — verified live: unquoted identifiers
-    // "are stored and resolved as uppercase characters (e.g. id is stored and resolved as ID)";
-    // quoted identifiers — "the case of the identifier is preserved when storing and resolving the
-    // identifier" (case-sensitive). Doubled-quote escape: "To use the double quote character inside
-    // a quoted identifier, use two quotes."
-    snowflake: {
-        delimiters: [DOUBLE_QUOTE],
-        unquoted: "upper",
-        quoted: "preserve",
-    },
-    // cloud.google.com/bigquery/docs/reference/standard-sql/lexical — verified live (via search,
-    // the JS-rendered page would not return body text to WebFetch): "table names are case-sensitive,
-    // but column names are not" — so table identifiers preserve case and everything else (column,
-    // field, alias, CTE) folds to lower, REGARDLESS of backtick-quoting either way (backticks are
-    // required for reserved words/specials, not a case-quoting mechanism — same "not case-quoting"
-    // shape as Databricks, but the preserved/folded split is per identifier KIND here, not
-    // per-quoting). Escape mechanism corrected from the originally assumed doubling: "Quoted
-    // identifiers have the same escape sequences as string literals" (backslash-escaped, e.g.
-    // `` `a\`b` `` → `` a`b ``) — NOT doubling like every other backtick/quote dialect here. This
-    // module unescapes the identifier-relevant case (`` \` ``) plus the general `\X`→`X` pattern; it
-    // does not implement BigQuery's full string-literal escape grammar (\n, \xHH, \uXXXX, octal, …),
-    // out of scope for an identifier fold — those escapes are exotic in identifier text.
-    bigquery: {
-        delimiters: [BACKTICK],
-        unquoted: "lower",
-        quoted: "lower",
-        tableCase: "preserve",
-        escapeStyle: "backslash",
-    },
-    // docs.aws.amazon.com/redshift/latest/dg/r_names.html — verified live: "ASCII letters in
-    // standard and delimited identifiers are case-insensitive and are folded to lowercase in the
-    // database" — explicitly covers BOTH unquoted and quoted by default (the
-    // enable_case_sensitive_identifier parameter can flip quoted identifiers case-sensitive; this
-    // module encodes the default). Doubled-quote escape: "To use a double quotation mark in a
-    // string, you must precede it with another double quotation mark character."
-    redshift: {
-        delimiters: [DOUBLE_QUOTE],
-        unquoted: "lower",
-        quoted: "lower",
-    },
-    // postgresql.org/docs/18/sql-syntax-lexical.html §4.1.1 — verified live: "unquoted names are
-    // always folded to lower case"; "Quoting an identifier also makes it case-sensitive" — example
-    // "the identifiers FOO, foo, and "foo" are considered the same by PostgreSQL, but "Foo" and
-    // "FOO" are different." Doubled-quote escape: "To include a double quote, write two double
-    // quotes."
-    postgres: {
-        delimiters: [DOUBLE_QUOTE],
-        unquoted: "lower",
-        quoted: "preserve",
-    },
-    // duckdb.org/docs/current/sql/dialect/keywords_and_identifiers.html — verified live: "Identifiers
-    // in DuckDB are always case-insensitive, similarly to PostgreSQL. However, unlike PostgreSQL...
-    // DuckDB also treats quoted identifiers as case-insensitive" — quoting only preserves the
-    // identifier for DISPLAY, not identity. Doubled-quote escape: "Double quotes can be escaped by
-    // repeating the quote character."
-    duckdb: {
-        delimiters: [DOUBLE_QUOTE],
-        unquoted: "lower",
-        quoted: "lower",
-    },
-    // trino.io/docs/current/language/reserved.html — verified live: "Identifiers with other
-    // characters must be delimited with double quotes (\"). ... Escape a \" with another preceding
-    // double quote in a delimited identifier." and, blanket, "Identifiers are not treated as case
-    // sensitive" — no quoted/unquoted distinction is drawn, and no backtick delimiter is documented
-    // (adjusted from the originally proposed "backtick tolerated" — dropped, unconfirmed by the
-    // live page). The fold DIRECTION (lower here) is this module's choice, not vendor-documented —
-    // the live docs only commit to uniform case-insensitivity across quoted/unquoted, which lower-
-    // folding both forms reproduces; chosen for consistency with the other case-insensitive-quoted
-    // dialects (redshift/duckdb) and this module's undefined-dialect default. NOTE: Trino's own
-    // engine source is internally inconsistent with this blanket docs claim — trino-parser's
-    // Identifier.getCanonicalValue() canonicalizes unquoted to UPPER and preserves quoted verbatim
-    // (ANSI-style, would make quoted case-sensitive), while trino-main's Field field-matching does
-    // a blanket case-insensitive compare regardless of quoting. Encoding the documented behavior
-    // per this module's citation policy; flagged as a discrepancy, not resolved against a live
-    // engine.
-    trino: {
-        delimiters: [DOUBLE_QUOTE],
-        unquoted: "lower",
-        quoted: "lower",
-    },
-};
-// Today's behavior — the safe default for an unrecognized/absent dialect tag: strip backticks,
-// fold to lower.
-const DEFAULT_RULE = {
-    delimiters: [BACKTICK],
-    unquoted: "lower",
-    quoted: "lower",
-};
+// The result of foldWith() is an IDENTITY KEY for name comparison ONLY — display text always comes from
+// the raw source text, never from a fold result. Getting the fold DIRECTION wrong silently breaks
+// equality: e.g. Snowflake's unquoted `foo` must equal quoted `"FOO"` and must NOT equal quoted `"foo"`
+// — a lowercase fold gets both wrong. Each dialect's rule is doc-cited in its own src/<dialect>/fold.ts.
 function applyCase(text, fold) {
     if (fold === "lower")
         return text.toLowerCase();
@@ -144,31 +28,14 @@ function unwrap(raw, rule) {
     }
     return [raw, false];
 }
-/** Unquote (dialect's delimiters, doubled-delimiter unescape) + case-fold per the dialect's
- *  documented identifier rules. The result is the IDENTITY KEY for name comparison — display
- *  text always comes from the raw source, never from this. */
-export function foldIdentifier(raw, dialect, kind = "other") {
-    const rule = (dialect && Object.hasOwn(RULES, dialect) ? RULES[dialect] : undefined) || DEFAULT_RULE;
+/** Fold an identifier to its identity key under an explicit rule (the engine each dialect folder binds). */
+export function foldWith(rule, raw, kind = "other") {
     const [body, wasQuoted] = unwrap(raw, rule);
     if (kind === "table" && rule.tableCase)
         return applyCase(body, rule.tableCase);
     return applyCase(body, wasQuoted ? rule.quoted : rule.unquoted);
 }
-/** PRESENTATION twin of foldIdentifier: strip the dialect's delimiters (unescaping the body) but
- *  apply NO case change — the string a UI shows for a name. Never use this for comparison; two
- *  displayName results being equal proves nothing about identity. */
-export function displayName(raw, dialect) {
-    const rule = (dialect && Object.hasOwn(RULES, dialect) ? RULES[dialect] : undefined) || DEFAULT_RULE;
+/** Presentation twin of foldWith: strip delimiters, no case change. */
+export function displayWith(rule, raw) {
     return unwrap(raw, rule)[0];
 }
-/** Fold a multipart table name for a catalog lookup — every part folded with kind "table" (only
- *  BigQuery treats table parts specially; everywhere else this is the plain fold). */
-export function foldTableName(parts, dialect) {
-    return parts.map((p) => foldIdentifier(p, dialect, "table"));
-}
-/** True when a source-map KEY (already folded — an alias folded as "other", or a table's last name
- *  part folded as "table") matches a RAW qualifier part. Tries both folds; they differ only for
- *  BigQuery, whose table identifiers preserve case while aliases/columns fold lower. */
-export function matchesSourceKey(key, rawPart, dialect) {
-    return key === foldIdentifier(rawPart, dialect) || key === foldIdentifier(rawPart, dialect, "table");
-}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { parse, analyze, toAst, toScopes, qualify, lineage, deriveSymbols, TypeInfo, type Nullability, Lineage, originsOfExpr, lineageAt, lineageOf, type LineageHop, type ViaStep, tokenize, SqlDocument, LineIndex, complete, completeAt, type Completion, signatureAt, FUNCTION_SIGNATURES, HARVESTED_SIGNATURES, lookupSignature, hasSignature, referencesAt, type Occurrence, type Occurrences, dialectSymbols, type DialectSymbols, CallbackSchema, type SchemaProvider, type TableResolver, DERIVED_DIALECTS, resolveDialect, foldIdentifier, displayName, type IdentKind, type SignatureInfo, type FnSignature, type ParamSig, type Dialect, type DialectOpts, type ParseResultIR, type Analysis, type Token, type TokenRole, type DocumentAnalysis, type StatementCell, type StatementCellSpan, type DocumentVariant, type UnionCte, } from "./api.js";
+export { parse, analyze, toAst, toScopes, qualify, lineage, deriveSymbols, TypeInfo, type Nullability, Lineage, originsOfExpr, lineageAt, lineageOf, type LineageHop, type ViaStep, tokenize, SqlDocument, LineIndex, complete, completeAt, type Completion, jinjaSlotAt, type JinjaSlot, signatureAt, SIGNATURES, lookupSignature, hasSignature, referencesAt, type Occurrence, type Occurrences, dialectSymbols, type DialectSymbols, CallbackSchema, type SchemaProvider, type TableResolver, DERIVED_DIALECTS, resolveDialect, foldIdentifier, displayName, type IdentKind, type SignatureHelpInfo, type SignatureLabel, type FnSignature, type ParamSig, type Dialect, type DialectOpts, type ParseResultIR, type Analysis, type Token, type TokenRole, type DocumentAnalysis, type StatementCell, type StatementCellSpan, type DocumentVariant, type UnionCte, } from "./api.js";
 export { SqlSession, type SessionOptions } from "./session.js";
 export { parseDatabricks } from "./databricks/parse.js";
 export { parseTSql } from "./tsql/parse.js";
@@ -8,6 +8,8 @@ export { parseRedshift } from "./redshift/parse.js";
 export { parsePostgres } from "./postgres/parse.js";
 export { parseDuckdb } from "./duckdb/parse.js";
 export { parseTrino } from "./trino/parse.js";
+export { parseSqlite } from "./sqlite/parse.js";
+export { parseMysql } from "./mysql/parse.js";
 export { lower as lowerDatabricks } from "./databricks/lower.js";
 export { lower as lowerTSql } from "./tsql/lower.js";
 export { lower as lowerSnowflake } from "./snowflake/lower.js";
@@ -16,6 +18,8 @@ export { lower as lowerRedshift } from "./redshift/lower.js";
 export { lower as lowerPostgres } from "./postgres/lower.js";
 export { lower as lowerDuckdb } from "./duckdb/lower.js";
 export { lower as lowerTrino } from "./trino/lower.js";
+export { lower as lowerSqlite } from "./sqlite/lower.js";
+export { lower as lowerMysql } from "./mysql/lower.js";
 export type { ParseResult } from "./parse-result.js";
 export { type TemplatedParseResult, type TemplatedParseOptions } from "./template/engine.js";
 export type { Clause, ColumnRef, CteDef, Expr, GraphElement, GraphTableSource, Join, JoinKind, LateralViewSource, LimitInfo, PartSpan, PipeBranch, PipeExpr, PipeSetItem, PipeStage, PivotInfo, Projection, QueryBody, QueryExpr, SelectExpr, SetOpExpr, Source, SubquerySource, TableSource, TemplateExprInfo, TemplateSourceInfo, UnpivotInfo, UnsupportedFlag, WindowSpec, } from "./ir/ir.js";
@@ -30,7 +34,7 @@ export { resolveScopes, type CteRef, type ResolvedSource, type Scope, type Scope
 export { walk, scopeOf } from "./scope/walk.js";
 export { type Diagnostic, type Qualification, type ColumnBinding } from "./qualify/qualify.js";
 export { Schema, type Column, type SchemaMapping, type SchemaLeaf } from "./qualify/schema.js";
-export { DefaultTemplateProvider, OPEN_PROVIDER, NO_OUTPUT_BUILTINS, type TemplateProvider, type TemplateCall, type ResolvedExpansion, type ResolvedRelation, type ValueType, type ExpansionShape, } from "./qualify/template-provider.js";
+export { DefaultTemplateProvider, DbtTemplateProvider, OPEN_PROVIDER, NO_OUTPUT_BUILTINS, type TemplateProvider, type TemplateCall, type ResolvedExpansion, type ResolvedRelation, type TemplateCandidate, type ValueType, type ExpansionShape, } from "./qualify/template-provider.js";
 export type { TemplateEngine } from "./template/engine.js";
 export { MAIN_FRAME, symbolAt, type Span, type StarExpansion, type Sym, type SymbolKind, type SymbolModifier, } from "./symbols/symbols.js";
 export { inferType } from "./infer/infer.js";

package/dist/index.js

@@ -10,7 +10,7 @@
 //   - Building blocks: the per-dialect parse*/lower and the raw shared passes, for callers who
 //                 want a specific tier or the raw CST escape hatch.
 // --- Uniform entry, lift helpers, typed wrappers, composable passes (src/api.ts) ---
-export { parse, analyze, toAst, toScopes, qualify, lineage, deriveSymbols, TypeInfo, Lineage, originsOfExpr, lineageAt, lineageOf, tokenize, SqlDocument, LineIndex, complete, completeAt, signatureAt, FUNCTION_SIGNATURES, HARVESTED_SIGNATURES, lookupSignature, hasSignature, referencesAt, dialectSymbols, CallbackSchema, DERIVED_DIALECTS, resolveDialect, foldIdentifier, displayName, } from "./api.js";
+export { parse, analyze, toAst, toScopes, qualify, lineage, deriveSymbols, TypeInfo, Lineage, originsOfExpr, lineageAt, lineageOf, tokenize, SqlDocument, LineIndex, complete, completeAt, jinjaSlotAt, signatureAt, SIGNATURES, lookupSignature, hasSignature, referencesAt, dialectSymbols, CallbackSchema, DERIVED_DIALECTS, resolveDialect, foldIdentifier, displayName, } from "./api.js";
 // SqlSession — the verb-shaped facade over one SqlDocument (offset in, answer out; pure delegation).
 export { SqlSession } from "./session.js";
 // --- Per-dialect building blocks: parse* (CST + errors) and lower* (CST → IR), kept as one
@@ -25,6 +25,8 @@ export { parseRedshift } from "./redshift/parse.js";
 export { parsePostgres } from "./postgres/parse.js";
 export { parseDuckdb } from "./duckdb/parse.js";
 export { parseTrino } from "./trino/parse.js";
+export { parseSqlite } from "./sqlite/parse.js";
+export { parseMysql } from "./mysql/parse.js";
 export { lower as lowerDatabricks } from "./databricks/lower.js";
 export { lower as lowerTSql } from "./tsql/lower.js";
 export { lower as lowerSnowflake } from "./snowflake/lower.js";
@@ -33,13 +35,15 @@ export { lower as lowerRedshift } from "./redshift/lower.js";
 export { lower as lowerPostgres } from "./postgres/lower.js";
 export { lower as lowerDuckdb } from "./duckdb/lower.js";
 export { lower as lowerTrino } from "./trino/lower.js";
+export { lower as lowerSqlite } from "./sqlite/lower.js";
+export { lower as lowerMysql } from "./mysql/lower.js";
 export { partSpanOf, partSpansOf } from "./ir/part-span.js";
 export { endPosition } from "./ir/span.js";
 // The shared IR walk — expr/query-tree traversal with no scope/document knowledge, single-sourced
-// for src/document/node-at.ts and the LSP folding feature (and any other IR-only consumer).
+// for src/document/node-at.ts and any other IR-only consumer.
 export { childExprs, walkExprs, allQueryExprs } from "./ir/walk.js";
-// The CST node-at-offset walk — the one genuinely LSP-shaped capability that lives outside
-// src/lsp/: given an offset, the smallest IR Expr (+ owning Scope) that covers it. Backs hover.
+// The CST node-at-offset walk — the one genuinely editor-shaped capability: given an offset, the
+// smallest IR Expr (+ owning Scope) that covers it. Backs hover.
 export { nodeAt } from "./document/node-at.js";
 export { coarseKind } from "./ir/statement.js";
 // --- Shared passes as building blocks (raw forms) + their typed result interfaces ---
@@ -51,10 +55,12 @@ export { walk, scopeOf } from "./scope/walk.js";
 export { Schema } from "./qualify/schema.js";
 // The template PROVIDER (the catalog-unification redesign): ONE resolution seam —
 // `expansion(call)` — for every template expression. `DefaultTemplateProvider` is the shipped,
-// concrete, inheritance-designed default (fully functional with zero input; override the granular
-// methods with what your host knows; misses + prime() warm lazily). Pass the SAME per-document
-// instance to parseTemplated (fills) and qualify/analyze (semantics).
-export { DefaultTemplateProvider, OPEN_PROVIDER, NO_OUTPUT_BUILTINS, } from "./qualify/template-provider.js";
+// concrete, inheritance-designed NEUTRAL default (fully functional with zero input, knows no macro
+// vocabulary; override the granular methods with what your host knows; misses + prime() warm
+// lazily). `DbtTemplateProvider` is the shipped dbt overlay (ref/source/env_var/no-output builtins) a
+// dbt consumer extends. Pass the SAME per-document instance to parseTemplated (fills) and
+// qualify/analyze (semantics).
+export { DefaultTemplateProvider, DbtTemplateProvider, OPEN_PROVIDER, NO_OUTPUT_BUILTINS, } from "./qualify/template-provider.js";
 export { MAIN_FRAME, symbolAt, } from "./symbols/symbols.js";
 export { inferType } from "./infer/infer.js";
 export { parseType, formatType } from "./infer/types.js";

package/dist/infer/functions.d.ts

@@ -1,13 +1,24 @@
-import type { Expr } from "../ir/ir.js";
 import { type Type } from "./types.js";
 export type FnRule = (args: Type[]) => Type;
-export declare const FUNCTION_RETURNS: Record<string, FnRule>;
-export declare const TSQL_FUNCTION_RETURNS: Record<string, FnRule>;
-/** T-SQL pre-registry inference hook — the XML data type methods, which `lowerUdtElem` lowers to
- *  `function` nodes with the receiver as arg 0. `value(xpath, 'sqltype')` is typed by its literal
- *  sqltype argument (never-wrong: no XML shredding — the declared sqltype is the value's runtime
- *  type; a non-literal sqltype falls through to unknown); `exist()` → boolean (bit); `query()` → xml.
- *  https://learn.microsoft.com/en-us/sql/t-sql/xml/xml-data-type-methods */
-export declare function tsqlSpecial(fn: Extract<Expr, {
-    kind: "function";
-}>): Type | undefined;
+export declare const S: Type;
+export declare const I: Type;
+export declare const BIG: Type;
+export declare const D: Type;
+export declare const B: Type;
+export declare const DATE: Type;
+export declare const TS: Type;
+export declare const BIN: Type;
+export declare const INTERVAL: Type;
+export declare const fixed: (t: Type) => FnRule;
+export declare const firstArg: FnRule;
+export declare const common: FnRule;
+export declare const restCommon: FnRule;
+export declare const arrayOfFirst: FnRule;
+export declare const arrayOfCommon: FnRule;
+export declare const elementOf: FnRule;
+export declare const mapKeys: FnRule;
+export declare const mapValues: FnRule;
+export declare const concatRule: FnRule;
+/** date_add(unit, n, ts) / dateadd / timestampadd → the date/timestamp argument's type. */
+export declare const dateArg: FnRule;
+export declare function group(rule: FnRule, names: string[]): Record<string, FnRule>;