rawsql-ts 0.1.0-beta.5 → 0.1.0-beta.7

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from './parsers/SelectQueryParser';
+export * from './models/BinarySelectQuery';
+export * from './models/SelectQuery';
+export * from './models/ValueComponent';
+export * from './models/ValuesQuery';
+export * from './transformers/CTECollector';
+export * from './transformers/CTENormalizer';
+export * from './transformers/Formatter';
+export * from './transformers/QueryNormalizer';
+export * from './transformers/SelectValueCollector';
+export * from './transformers/SelectableColumnCollector';
+export * from './transformers/TableSourceCollector';
+export * from './transformers/UpstreamSelectQueryFinder';

package/dist/models/BinarySelectQuery.d.ts

@@ -0,0 +1,91 @@
+import { SourceExpression } from "./Clause";
+import type { SelectQuery } from "./SelectQuery";
+import { SqlComponent } from "./SqlComponent";
+import { RawString } from "./ValueComponent";
+/**
+ * Represents a binary SELECT query (e.g., UNION, INTERSECT, EXCEPT).
+ */
+export declare class BinarySelectQuery extends SqlComponent {
+    static kind: symbol;
+    left: SelectQuery;
+    operator: RawString;
+    right: SelectQuery;
+    constructor(left: SelectQuery, operator: string, right: SelectQuery);
+    /**
+     * Appends another query to this binary query using UNION as the operator.
+     * This creates a new BinarySelectQuery where the left side is this binary query
+     * and the right side is the provided query.
+     *
+     * @param query The query to append with UNION
+     * @returns A new BinarySelectQuery representing "(this) UNION query"
+     */
+    union(query: SelectQuery): BinarySelectQuery;
+    /**
+     * Appends another query to this binary query using UNION ALL as the operator.
+     * This creates a new BinarySelectQuery where the left side is this binary query
+     * and the right side is the provided query.
+     *
+     * @param query The query to append with UNION ALL
+     * @returns A new BinarySelectQuery representing "(this) UNION ALL query"
+     */
+    unionAll(query: SelectQuery): BinarySelectQuery;
+    /**
+     * Appends another query to this binary query using INTERSECT as the operator.
+     * This creates a new BinarySelectQuery where the left side is this binary query
+     * and the right side is the provided query.
+     *
+     * @param query The query to append with INTERSECT
+     * @returns A new BinarySelectQuery representing "(this) INTERSECT query"
+     */
+    intersect(query: SelectQuery): BinarySelectQuery;
+    /**
+     * Appends another query to this binary query using INTERSECT ALL as the operator.
+     * This creates a new BinarySelectQuery where the left side is this binary query
+     * and the right side is the provided query.
+     *
+     * @param query The query to append with INTERSECT ALL
+     * @returns A new BinarySelectQuery representing "(this) INTERSECT ALL query"
+     */
+    intersectAll(query: SelectQuery): BinarySelectQuery;
+    /**
+     * Appends another query to this binary query using EXCEPT as the operator.
+     * This creates a new BinarySelectQuery where the left side is this binary query
+     * and the right side is the provided query.
+     *
+     * @param query The query to append with EXCEPT
+     * @returns A new BinarySelectQuery representing "(this) EXCEPT query"
+     */
+    except(query: SelectQuery): BinarySelectQuery;
+    /**
+     * Appends another query to this binary query using EXCEPT ALL as the operator.
+     * This creates a new BinarySelectQuery where the left side is this binary query
+     * and the right side is the provided query.
+     *
+     * @param query The query to append with EXCEPT ALL
+     * @returns A new BinarySelectQuery representing "(this) EXCEPT ALL query"
+     */
+    exceptAll(query: SelectQuery): BinarySelectQuery;
+    /**
+     * Appends another query to this binary query using the specified operator.
+     * This creates a new BinarySelectQuery where the left side is this binary query
+     * and the right side is the provided query.
+     *
+     * @param operator SQL operator to use (e.g. 'union', 'union all', 'intersect', 'except')
+     * @param query The query to append with the specified operator
+     * @returns A new BinarySelectQuery representing "(this) [operator] query"
+     */
+    appendSelectQuery(operator: string, query: SelectQuery): BinarySelectQuery;
+    /**
+     * Appends another query to this binary query using UNION as the operator, accepting a raw SQL string.
+     * This method parses the SQL string and appends the resulting query using UNION.
+     * @param sql The SQL string to parse and union
+     * @returns A new BinarySelectQuery representing "(this) UNION (parsed query)"
+     */
+    unionRaw(sql: string): BinarySelectQuery;
+    unionAllRaw(sql: string): BinarySelectQuery;
+    intersectRaw(sql: string): BinarySelectQuery;
+    intersectAllRaw(sql: string): BinarySelectQuery;
+    exceptRaw(sql: string): BinarySelectQuery;
+    exceptAllRaw(sql: string): BinarySelectQuery;
+    toSource(alias?: string): SourceExpression;
+}

package/dist/models/Clause.d.ts

@@ -0,0 +1,189 @@
+import { SelectQuery } from "./SelectQuery";
+import { SqlComponent } from "./SqlComponent";
+import { IdentifierString, RawString, ValueComponent, WindowFrameExpression } from "./ValueComponent";
+export type SelectComponent = SelectItem | ValueComponent;
+export declare class SelectItem extends SqlComponent {
+    static kind: symbol;
+    value: ValueComponent;
+    identifier: IdentifierString;
+    constructor(value: ValueComponent, name: string);
+}
+export declare class SelectClause extends SqlComponent {
+    static kind: symbol;
+    items: SelectComponent[];
+    distinct: DistinctComponent | null;
+    constructor(items: SelectComponent[], distinct?: DistinctComponent | null);
+}
+export type DistinctComponent = Distinct | DistinctOn;
+export declare class Distinct extends SqlComponent {
+    static kind: symbol;
+    constructor();
+}
+export declare class DistinctOn extends SqlComponent {
+    static kind: symbol;
+    value: ValueComponent;
+    constructor(value: ValueComponent);
+}
+export declare class WhereClause extends SqlComponent {
+    static kind: symbol;
+    condition: ValueComponent;
+    constructor(condition: ValueComponent);
+}
+export declare class PartitionByClause extends SqlComponent {
+    static kind: symbol;
+    value: ValueComponent;
+    constructor(value: ValueComponent);
+}
+export declare class WindowFrameClause extends SqlComponent {
+    static kind: symbol;
+    name: IdentifierString;
+    expression: WindowFrameExpression;
+    constructor(name: string, expression: WindowFrameExpression);
+}
+export declare enum SortDirection {
+    Ascending = "asc",
+    Descending = "desc"
+}
+export declare enum NullsSortDirection {
+    First = "first",
+    Last = "last"
+}
+export type OrderByComponent = OrderByItem | ValueComponent;
+export declare class OrderByClause extends SqlComponent {
+    static kind: symbol;
+    order: OrderByComponent[];
+    constructor(items: OrderByComponent[]);
+}
+export declare class OrderByItem extends SqlComponent {
+    static kind: symbol;
+    value: ValueComponent;
+    sortDirection: SortDirection;
+    nullsPosition: NullsSortDirection | null;
+    constructor(expression: ValueComponent, sortDirection: SortDirection | null, nullsPosition: NullsSortDirection | null);
+}
+export declare class GroupByClause extends SqlComponent {
+    static kind: symbol;
+    grouping: ValueComponent[];
+    constructor(expression: ValueComponent[]);
+}
+export declare class HavingClause extends SqlComponent {
+    static kind: symbol;
+    condition: ValueComponent;
+    constructor(condition: ValueComponent);
+}
+export type SourceComponent = TableSource | FunctionSource | SubQuerySource | ParenSource;
+export declare class TableSource extends SqlComponent {
+    static kind: symbol;
+    namespaces: IdentifierString[] | null;
+    table: IdentifierString;
+    identifier: IdentifierString;
+    constructor(namespaces: string[] | null, table: string);
+    getSourceName(): string;
+}
+export declare class FunctionSource extends SqlComponent {
+    static kind: symbol;
+    name: RawString;
+    argument: ValueComponent | null;
+    constructor(functionName: string, argument: ValueComponent | null);
+}
+export declare class ParenSource extends SqlComponent {
+    static kind: symbol;
+    source: SourceComponent;
+    constructor(source: SourceComponent);
+}
+export declare class SubQuerySource extends SqlComponent {
+    static kind: symbol;
+    query: SelectQuery;
+    constructor(query: SelectQuery);
+}
+export declare class SourceExpression extends SqlComponent {
+    static kind: symbol;
+    datasource: SourceComponent;
+    aliasExpression: SourceAliasExpression | null;
+    constructor(datasource: SourceComponent, aliasExpression: SourceAliasExpression | null);
+    getAliasName(): string | null;
+}
+export type JoinConditionComponent = JoinOnClause | JoinUsingClause;
+export declare class JoinOnClause extends SqlComponent {
+    static kind: symbol;
+    condition: ValueComponent;
+    constructor(condition: ValueComponent);
+}
+export declare class JoinUsingClause extends SqlComponent {
+    static kind: symbol;
+    condition: ValueComponent;
+    constructor(condition: ValueComponent);
+}
+export declare class JoinClause extends SqlComponent {
+    static kind: symbol;
+    joinType: RawString;
+    source: SourceExpression;
+    condition: JoinConditionComponent | null;
+    lateral: boolean;
+    constructor(joinType: string, source: SourceExpression, condition: JoinConditionComponent | null, lateral: boolean);
+    getAliasSourceName(): string | null;
+}
+export declare class FromClause extends SqlComponent {
+    static kind: symbol;
+    source: SourceExpression;
+    joins: JoinClause[] | null;
+    constructor(source: SourceExpression, join: JoinClause[] | null);
+    getAliasSourceName(): string | null;
+    /**
+     * Returns all SourceExpression objects in this FROM clause, including main source and all JOIN sources.
+     */
+    getSources(): SourceExpression[];
+}
+export declare class CommonTable extends SqlComponent {
+    static kind: symbol;
+    query: SelectQuery;
+    materialized: boolean | null;
+    aliasExpression: SourceAliasExpression;
+    constructor(query: SelectQuery, aliasExpression: SourceAliasExpression | string, materialized: boolean | null);
+    getAliasSourceName(): string;
+}
+export declare class WithClause extends SqlComponent {
+    static kind: symbol;
+    recursive: boolean;
+    tables: CommonTable[];
+    constructor(recursive: boolean, tables: CommonTable[]);
+}
+export declare class LimitClause extends SqlComponent {
+    static kind: symbol;
+    limit: ValueComponent;
+    offset: ValueComponent | null;
+    constructor(limit: ValueComponent, offset: ValueComponent | null);
+}
+export declare enum FetchType {
+    Next = "next",
+    First = "first"
+}
+export declare enum FetchUnit {
+    RowsOnly = "rows only",
+    Percent = "percent",
+    PercentWithTies = "percent with ties"
+}
+export declare class FetchSpecification extends SqlComponent {
+    static kind: symbol;
+    type: FetchType;
+    count: ValueComponent;
+    unit: FetchUnit | null;
+    constructor(type: FetchType, count: ValueComponent, unit: FetchUnit | null);
+}
+export declare enum LockMode {
+    Update = "update",
+    Share = "share",
+    KeyShare = "key share",
+    NokeyUpdate = "no key update"
+}
+export declare class ForClause extends SqlComponent {
+    static kind: symbol;
+    lockMode: LockMode;
+    constructor(lockMode: LockMode);
+}
+export declare class SourceAliasExpression extends SqlComponent {
+    static kind: symbol;
+    table: IdentifierString;
+    columns: IdentifierString[] | null;
+    constructor(alias: string, columnAlias: string[] | null);
+}

package/dist/models/KeywordTrie.d.ts

@@ -0,0 +1,11 @@
+import { KeywordMatchResult } from "../parsers/KeywordParser";
+export declare class KeywordTrie {
+    private root;
+    private currentNode;
+    private hasEndProperty;
+    private hasMoreProperties;
+    constructor(keywords: string[][]);
+    private addKeyword;
+    reset(): void;
+    pushLexeme(lexeme: string): KeywordMatchResult;
+}

package/dist/models/Lexeme.d.ts

@@ -0,0 +1,25 @@
+export declare enum TokenType {
+    Literal = 0,
+    Operator = 1,
+    OpenParen = 2,
+    CloseParen = 3,
+    Comma = 4,
+    Dot = 5,
+    Identifier = 6,
+    Command = 7,// select, from, where as, on, array etc
+    Parameter = 8,
+    OpenBracket = 9,
+    CloseBracket = 10,
+    Function = 11,// next token is open paren
+    StringSpecifier = 12,// next token is string literal
+    Type = 13
+}
+/**
+ * Represents a lexical token in SQL parsing
+ */
+export interface Lexeme {
+    type: TokenType;
+    value: string;
+    comments: string[] | null;
+    maybeType: boolean | null;
+}

package/dist/models/SelectQuery.d.ts

@@ -0,0 +1,5 @@
+import { SimpleSelectQuery } from "./SimpleSelectQuery";
+import { BinarySelectQuery } from "./BinarySelectQuery";
+import { ValuesQuery } from "./ValuesQuery";
+export type SelectQuery = SimpleSelectQuery | BinarySelectQuery | ValuesQuery;
+export { SimpleSelectQuery, BinarySelectQuery, ValuesQuery };

package/dist/models/SimpleSelectQuery.d.ts

@@ -0,0 +1,167 @@
+import { SqlComponent } from "./SqlComponent";
+import { ForClause, FromClause, GroupByClause, HavingClause, LimitClause, OrderByClause, SelectClause, SourceExpression, WhereClause, WindowFrameClause, WithClause, CommonTable } from "./Clause";
+import { ValueComponent } from "./ValueComponent";
+import { BinarySelectQuery } from "./BinarySelectQuery";
+import type { SelectQuery } from "./SelectQuery";
+/**
+ * Represents a simple SELECT query in SQL.
+ */
+export declare class SimpleSelectQuery extends SqlComponent {
+    static kind: symbol;
+    WithClause: WithClause | null;
+    selectClause: SelectClause;
+    fromClause: FromClause | null;
+    whereClause: WhereClause | null;
+    groupByClause: GroupByClause | null;
+    havingClause: HavingClause | null;
+    orderByClause: OrderByClause | null;
+    windowFrameClause: WindowFrameClause | null;
+    rowLimitClause: LimitClause | null;
+    forClause: ForClause | null;
+    constructor(withClause: WithClause | null, selectClause: SelectClause, fromClause: FromClause | null, whereClause: WhereClause | null, groupByClause: GroupByClause | null, havingClause: HavingClause | null, orderByClause: OrderByClause | null, windowFrameClause: WindowFrameClause | null, rowLimitClause: LimitClause | null, forClause: ForClause | null);
+    /**
+     * Creates a new BinarySelectQuery with this query as the left side and the provided query as the right side,
+     * using UNION as the operator.
+     *
+     * @param rightQuery The right side of the UNION
+     * @returns A new BinarySelectQuery representing "this UNION rightQuery"
+     */
+    toUnion(rightQuery: SelectQuery): BinarySelectQuery;
+    /**
+     * Creates a new BinarySelectQuery with this query as the left side and the provided query as the right side,
+     * using UNION ALL as the operator.
+     *
+     * @param rightQuery The right side of the UNION ALL
+     * @returns A new BinarySelectQuery representing "this UNION ALL rightQuery"
+     */
+    toUnionAll(rightQuery: SelectQuery): BinarySelectQuery;
+    /**
+     * Creates a new BinarySelectQuery with this query as the left side and the provided query as the right side,
+     * using INTERSECT as the operator.
+     *
+     * @param rightQuery The right side of the INTERSECT
+     * @returns A new BinarySelectQuery representing "this INTERSECT rightQuery"
+     */
+    toIntersect(rightQuery: SelectQuery): BinarySelectQuery;
+    /**
+     * Creates a new BinarySelectQuery with this query as the left side and the provided query as the right side,
+     * using INTERSECT ALL as the operator.
+     *
+     * @param rightQuery The right side of the INTERSECT ALL
+     * @returns A new BinarySelectQuery representing "this INTERSECT ALL rightQuery"
+     */
+    toIntersectAll(rightQuery: SelectQuery): BinarySelectQuery;
+    /**
+     * Creates a new BinarySelectQuery with this query as the left side and the provided query as the right side,
+     * using EXCEPT as the operator.
+     *
+     * @param rightQuery The right side of the EXCEPT
+     * @returns A new BinarySelectQuery representing "this EXCEPT rightQuery"
+     */
+    toExcept(rightQuery: SelectQuery): BinarySelectQuery;
+    /**
+     * Creates a new BinarySelectQuery with this query as the left side and the provided query as the right side,
+     * using EXCEPT ALL as the operator.
+     *
+     * @param rightQuery The right side of the EXCEPT ALL
+     * @returns A new BinarySelectQuery representing "this EXCEPT ALL rightQuery"
+     */
+    toExceptAll(rightQuery: SelectQuery): BinarySelectQuery;
+    /**
+     * Creates a new BinarySelectQuery with this query as the left side and the provided query as the right side,
+     * using the specified operator.
+     *
+     * @param operator SQL operator to use (e.g. 'union', 'union all', 'intersect', 'except')
+     * @param rightQuery The right side of the binary operation
+     * @returns A new BinarySelectQuery representing "this [operator] rightQuery"
+     */
+    toBinaryQuery(operator: string, rightQuery: SelectQuery): BinarySelectQuery;
+    /**
+     * Appends a new condition to the query's WHERE clause using AND logic.
+     * The condition is provided as a raw SQL string which is parsed internally.
+     *
+     * @param rawCondition Raw SQL string representing the condition (e.g. "status = 'active'")
+     */
+    appendWhereRaw(rawCondition: string): void;
+    /**
+     * Appends a new condition to the query's WHERE clause using AND logic.
+     * The condition is provided as a ValueComponent object.
+     *
+     * @param condition ValueComponent representing the condition
+     */
+    appendWhere(condition: ValueComponent): void;
+    /**
+     * Appends a new condition to the query's HAVING clause using AND logic.
+     * The condition is provided as a raw SQL string which is parsed internally.
+     *
+     * @param rawCondition Raw SQL string representing the condition (e.g. "count(*) > 5")
+     */
+    appendHavingRaw(rawCondition: string): void;
+    /**
+     * Appends a new condition to the query's HAVING clause using AND logic.
+     * The condition is provided as a ValueComponent object.
+     *
+     * @param condition ValueComponent representing the condition
+     */
+    appendHaving(condition: ValueComponent): void;
+    /**
+     * Appends an INNER JOIN clause to the query.
+     * @param joinSourceRawText The table source text to join (e.g., "my_table", "schema.my_table")
+     * @param alias The alias for the joined table
+     * @param columns The columns to use for the join condition (e.g. ["user_id"])
+     */
+    innerJoinRaw(joinSourceRawText: string, alias: string, columns: string[]): void;
+    /**
+     * Appends a LEFT JOIN clause to the query.
+     * @param joinSourceRawText The table source text to join
+     * @param alias The alias for the joined table
+     * @param columns The columns to use for the join condition
+     */
+    leftJoinRaw(joinSourceRawText: string, alias: string, columns: string[]): void;
+    /**
+     * Appends a RIGHT JOIN clause to the query.
+     * @param joinSourceRawText The table source text to join
+     * @param alias The alias for the joined table
+     * @param columns The columns to use for the join condition
+     */
+    rightJoinRaw(joinSourceRawText: string, alias: string, columns: string[]): void;
+    /**
+     * Appends an INNER JOIN clause to the query using a SourceExpression.
+     * @param sourceExpr The source expression to join
+     * @param columns The columns to use for the join condition
+     */
+    innerJoin(sourceExpr: SourceExpression, columns: string[]): void;
+    /**
+     * Appends a LEFT JOIN clause to the query using a SourceExpression.
+     * @param sourceExpr The source expression to join
+     * @param columns The columns to use for the join condition
+     */
+    leftJoin(sourceExpr: SourceExpression, columns: string[]): void;
+    /**
+     * Appends a RIGHT JOIN clause to the query using a SourceExpression.
+     * @param sourceExpr The source expression to join
+     * @param columns The columns to use for the join condition
+     */
+    rightJoin(sourceExpr: SourceExpression, columns: string[]): void;
+    /**
+     * Internal helper to append a JOIN clause.
+     * Parses the table source, finds the corresponding columns in the existing query context,
+     * and builds the JOIN condition.
+     * @param joinType Type of join (e.g., 'inner join', 'left join')
+     * @param joinSourceRawText Raw text for the table/source to join (e.g., "my_table", "schema.another_table")
+     * @param alias Alias for the table/source being joined
+     * @param columns Array of column names to join on
+     */
+    private joinSourceRaw;
+    private joinSource;
+    toSource(alias: string): SourceExpression;
+    appendWith(commonTable: CommonTable | CommonTable[]): void;
+    /**
+     * Appends a CommonTable (CTE) to the WITH clause from raw SQL text and alias.
+     * If alias is provided, it will be used as the CTE name.
+     *
+     * @param rawText Raw SQL string representing the CTE body (e.g. '(SELECT ...)')
+     * @param alias Optional alias for the CTE (e.g. 'cte_name')
+     */
+    appendWithRaw(rawText: string, alias: string): void;
+}

package/dist/models/SqlComponent.d.ts

@@ -0,0 +1,18 @@
+export declare abstract class SqlComponent {
+    static kind: symbol;
+    getKind(): symbol;
+    accept<T>(visitor: SqlComponentVisitor<T>): T;
+    toSqlString(formatter: SqlComponentVisitor<string>): string;
+    comments: string[] | null;
+}
+export interface SqlComponentVisitor<T> {
+    visit(expr: SqlComponent): T;
+}
+export declare class SqlDialectConfiguration {
+    parameterSymbol: string;
+    identifierEscape: {
+        start: string;
+        end: string;
+    };
+    exportComment: boolean;
+}

package/dist/models/ValueComponent.d.ts

@@ -0,0 +1,158 @@
+import { PartitionByClause, OrderByClause } from "./Clause";
+import { SelectQuery } from "./SelectQuery";
+import { SqlComponent } from "./SqlComponent";
+export type ValueComponent = ValueList | ColumnReference | FunctionCall | UnaryExpression | BinaryExpression | LiteralValue | ParameterExpression | SwitchCaseArgument | CaseKeyValuePair | RawString | IdentifierString | ParenExpression | CastExpression | CaseExpression | ArrayExpression | BetweenExpression | InlineQuery | StringSpecifierExpression | TypeValue | TupleExpression;
+export declare class InlineQuery extends SqlComponent {
+    static kind: symbol;
+    selectQuery: SelectQuery;
+    constructor(selectQuery: SelectQuery);
+}
+export declare class ValueList extends SqlComponent {
+    static kind: symbol;
+    values: ValueComponent[];
+    constructor(values: ValueComponent[]);
+}
+export declare class ColumnReference extends SqlComponent {
+    static kind: symbol;
+    namespaces: IdentifierString[] | null;
+    column: IdentifierString;
+    constructor(namespaces: string[] | null, column: string);
+    toString(): string;
+    getNamespace(): string;
+}
+export declare class FunctionCall extends SqlComponent {
+    static kind: symbol;
+    name: RawString;
+    argument: ValueComponent | null;
+    over: OverExpression | null;
+    constructor(name: string, argument: ValueComponent | null, over: OverExpression | null);
+}
+export type OverExpression = WindowFrameExpression | IdentifierString;
+export declare enum WindowFrameType {
+    Rows = "rows",
+    Range = "range",
+    Groups = "groups"
+}
+export declare enum WindowFrameBound {
+    UnboundedPreceding = "unbounded preceding",
+    UnboundedFollowing = "unbounded following",
+    CurrentRow = "current row"
+}
+export type FrameBoundaryComponent = WindowFrameBoundStatic | WindowFrameBoundaryValue;
+export declare class WindowFrameBoundStatic extends SqlComponent {
+    static kind: symbol;
+    bound: WindowFrameBound;
+    constructor(bound: WindowFrameBound);
+}
+export declare class WindowFrameBoundaryValue extends SqlComponent {
+    static kind: symbol;
+    value: ValueComponent;
+    isFollowing: boolean;
+    constructor(value: ValueComponent, isFollowing: boolean);
+}
+export declare class WindowFrameSpec extends SqlComponent {
+    static kind: symbol;
+    frameType: WindowFrameType;
+    startBound: FrameBoundaryComponent;
+    endBound: FrameBoundaryComponent | null;
+    constructor(frameType: WindowFrameType, startBound: FrameBoundaryComponent, endBound: FrameBoundaryComponent | null);
+}
+export declare class WindowFrameExpression extends SqlComponent {
+    static kind: symbol;
+    partition: PartitionByClause | null;
+    order: OrderByClause | null;
+    frameSpec: WindowFrameSpec | null;
+    constructor(partition: PartitionByClause | null, order: OrderByClause | null, frameSpec?: WindowFrameSpec | null);
+}
+export declare class UnaryExpression extends SqlComponent {
+    static kind: symbol;
+    operator: RawString;
+    expression: ValueComponent;
+    constructor(operator: string, expression: ValueComponent);
+}
+export declare class BinaryExpression extends SqlComponent {
+    static kind: symbol;
+    left: ValueComponent;
+    operator: RawString;
+    right: ValueComponent;
+    constructor(left: ValueComponent, operator: string, right: ValueComponent);
+}
+export declare class LiteralValue extends SqlComponent {
+    static kind: symbol;
+    value: string | number | boolean | null;
+    constructor(value: string | number | boolean | null);
+}
+export declare class ParameterExpression extends SqlComponent {
+    static kind: symbol;
+    name: RawString;
+    constructor(name: string);
+}
+export declare class SwitchCaseArgument extends SqlComponent {
+    static kind: symbol;
+    cases: CaseKeyValuePair[];
+    elseValue: ValueComponent | null;
+    constructor(cases: CaseKeyValuePair[], elseValue?: ValueComponent | null);
+}
+export declare class CaseKeyValuePair extends SqlComponent {
+    static kind: symbol;
+    key: ValueComponent;
+    value: ValueComponent;
+    constructor(key: ValueComponent, value: ValueComponent);
+}
+export declare class RawString extends SqlComponent {
+    static kind: symbol;
+    value: string;
+    constructor(value: string);
+}
+export declare class IdentifierString extends SqlComponent {
+    static kind: symbol;
+    name: string;
+    constructor(alias: string);
+}
+export declare class ParenExpression extends SqlComponent {
+    static kind: symbol;
+    expression: ValueComponent;
+    constructor(expression: ValueComponent);
+}
+export declare class CastExpression extends SqlComponent {
+    static kind: symbol;
+    input: ValueComponent;
+    castType: TypeValue;
+    constructor(input: ValueComponent, castType: TypeValue);
+}
+export declare class CaseExpression extends SqlComponent {
+    static kind: symbol;
+    condition: ValueComponent | null;
+    switchCase: SwitchCaseArgument;
+    constructor(condition: ValueComponent | null, switchCase: SwitchCaseArgument);
+}
+export declare class ArrayExpression extends SqlComponent {
+    static kind: symbol;
+    expression: ValueComponent;
+    constructor(expression: ValueComponent);
+}
+export declare class BetweenExpression extends SqlComponent {
+    static kind: symbol;
+    expression: ValueComponent;
+    lower: ValueComponent;
+    upper: ValueComponent;
+    negated: boolean;
+    constructor(expression: ValueComponent, lower: ValueComponent, upper: ValueComponent, negated: boolean);
+}
+export declare class StringSpecifierExpression extends SqlComponent {
+    static kind: symbol;
+    specifier: RawString;
+    value: ValueComponent;
+    constructor(specifier: string, value: string);
+}
+export declare class TypeValue extends SqlComponent {
+    static kind: symbol;
+    type: RawString;
+    argument: ValueComponent | null;
+    constructor(type: string, argument?: ValueComponent | null);
+}
+export declare class TupleExpression extends SqlComponent {
+    static kind: symbol;
+    values: ValueComponent[];
+    constructor(values: ValueComponent[]);
+}