@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/dist/statements/CreateTableStatementTextRenderer.d.ts

@@ -0,0 +1,18 @@
+import type { Column } from "./Column.js";
+import type { CreateTableStatement } from "./CreateTableStatement.js";
+import type { ITableConstraint } from "./ITableConstraint.js";
+export declare class CreateTableStatementTextRenderer {
+    render(statement: CreateTableStatement): string;
+    protected quote(name: string): string;
+    protected suffix(): string;
+    protected typeName(column: Column): string;
+    protected columnDefault(column: Column): string;
+    protected identity(_column: Column): string;
+    protected column(column: Column): string;
+    protected constraint(constraint: ITableConstraint): string;
+    private parts;
+    private notNullSql;
+    private foreignKey;
+    private quoted;
+    private actionSql;
+}

package/dist/statements/DefaultStatementTextRenderer.d.ts

@@ -0,0 +1,5 @@
+import { StatementTextRenderer } from "./StatementTextRenderer.js";
+export declare class DefaultStatementTextRenderer extends StatementTextRenderer {
+    static readonly instance: DefaultStatementTextRenderer;
+    constructor();
+}

package/dist/statements/DeleteStatement.d.ts

@@ -0,0 +1,9 @@
+import type { IDeleteStatement } from "./IDeleteStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { IWhere } from "./IWhere.js";
+export declare class DeleteStatement implements IDeleteStatement {
+    readonly table: string;
+    readonly where?: IWhere;
+    constructor(table: string, where?: IWhere);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/DeleteStatementTextRenderer.d.ts

@@ -0,0 +1,7 @@
+import type { DeleteStatement } from "./DeleteStatement.js";
+import type { StatementTextRenderer } from "./StatementTextRenderer.js";
+export declare class DeleteStatementTextRenderer {
+    private readonly text;
+    constructor(text: StatementTextRenderer);
+    render(statement: DeleteStatement): string;
+}

package/dist/statements/ExecuteStoredProcedureStatement.d.ts

@@ -0,0 +1,9 @@
+import type { Parameter } from "../Parameter.js";
+import type { IExecuteStoredProcedureStatement } from "./IExecuteStoredProcedureStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export declare class ExecuteStoredProcedureStatement implements IExecuteStoredProcedureStatement {
+    readonly name: string;
+    readonly parameters: Parameter[];
+    constructor(name: string, parameters: Parameter[]);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/ExecuteStoredProcedureStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.js";
+export declare class ExecuteStoredProcedureStatementTextRenderer {
+    render(statement: ExecuteStoredProcedureStatement): string;
+}

package/dist/statements/ExpressionEvaluator.d.ts

@@ -0,0 +1,5 @@
+import type { Scalar } from "../builders/Scalar.js";
+import type { IExpression } from "./IExpression.js";
+export declare class ExpressionEvaluator {
+    evaluate: (expression: IExpression, parameters?: Record<string, Scalar>) => Scalar;
+}

package/dist/statements/ExpressionRenderer.d.ts

@@ -0,0 +1,8 @@
+import type { IExpression } from "./IExpression.js";
+import type { StatementTextRenderer } from "./StatementTextRenderer.js";
+export declare class ExpressionRenderer {
+    private readonly text;
+    constructor(text: StatementTextRenderer);
+    render: (expression: IExpression) => string;
+    private wrap;
+}

package/dist/statements/ForeignKey.d.ts

@@ -0,0 +1,19 @@
+import type { ITableConstraint } from "./ITableConstraint.js";
+export declare const ReferentialAction: {
+    readonly Cascade: "cascade";
+    readonly SetNull: "setNull";
+    readonly SetDefault: "setDefault";
+    readonly Restrict: "restrict";
+    readonly NoAction: "noAction";
+};
+export type ReferentialAction = (typeof ReferentialAction)[keyof typeof ReferentialAction];
+export declare class ForeignKey implements ITableConstraint {
+    readonly name: string;
+    readonly columns: string[];
+    readonly referencesTable: string;
+    readonly referencesColumns: string[];
+    readonly onDelete?: ReferentialAction | undefined;
+    readonly onUpdate?: ReferentialAction | undefined;
+    readonly kind: "foreignKey";
+    constructor(name: string, columns: string[], referencesTable: string, referencesColumns: string[], onDelete?: ReferentialAction | undefined, onUpdate?: ReferentialAction | undefined);
+}

package/dist/statements/IBulkDeleteStatement.d.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.js";
+export interface IBulkDeleteStatement extends IStatement {
+}

package/dist/statements/IBulkInsertStatement.d.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.js";
+export interface IBulkInsertStatement extends IStatement {
+}

package/dist/statements/IBulkUpdateStatement.d.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.js";
+export interface IBulkUpdateStatement extends IStatement {
+}

package/dist/statements/ICondition.d.ts

@@ -0,0 +1,4 @@
+import type { IConditionVisitor } from "./IConditionVisitor.js";
+export interface ICondition {
+    accept(visitor: IConditionVisitor): string;
+}

package/dist/statements/IConditionVisitor.d.ts

@@ -0,0 +1,6 @@
+import type { Where } from "./Where.js";
+import type { WhereText } from "./WhereText.js";
+export interface IConditionVisitor {
+    visit(where: Where): string;
+    visit(where: WhereText): string;
+}

package/dist/statements/ICreateIndexStatement.d.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.js";
+export interface ICreateIndexStatement extends IStatement {
+}

package/dist/statements/ICreateTableStatement.d.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.js";
+export interface ICreateTableStatement extends IStatement {
+}

package/dist/statements/IDeleteStatement.d.ts

@@ -0,0 +1,5 @@
+import type { IStatement } from "./IStatement.js";
+import type { IWhere } from "./IWhere.js";
+export interface IDeleteStatement extends IStatement {
+    readonly where?: IWhere;
+}

package/dist/statements/IExecuteStoredProcedureStatement.d.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.js";
+export interface IExecuteStoredProcedureStatement extends IStatement {
+}

package/dist/statements/IExpression.d.ts

@@ -0,0 +1,2 @@
+export interface IExpression {
+}

package/dist/statements/IInsertStatement.d.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.js";
+export interface IInsertStatement extends IStatement {
+}

package/dist/statements/IReturnStatement.d.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.js";
+export interface IReturnStatement extends IStatement {
+}

package/dist/statements/ISelectStatement.d.ts

@@ -0,0 +1,5 @@
+import type { IStatement } from "./IStatement.js";
+import type { IWhere } from "./IWhere.js";
+export interface ISelectStatement extends IStatement {
+    readonly where?: IWhere;
+}

package/dist/statements/IStatement.d.ts

@@ -0,0 +1,4 @@
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export interface IStatement {
+    accept(visitor: IStatementVisitor): string;
+}

package/dist/statements/IStatementVisitor.d.ts

@@ -0,0 +1,26 @@
+import type { BulkDeleteStatement } from "./BulkDeleteStatement.js";
+import type { BulkInsertStatement } from "./BulkInsertStatement.js";
+import type { BulkUpdateStatement } from "./BulkUpdateStatement.js";
+import type { CreateIndexStatement } from "./CreateIndexStatement.js";
+import type { CreateTableStatement } from "./CreateTableStatement.js";
+import type { DeleteStatement } from "./DeleteStatement.js";
+import type { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.js";
+import type { InsertStatement } from "./InsertStatement.js";
+import type { ReturnStatement } from "./ReturnStatement.js";
+import type { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.js";
+import type { SelectStatement } from "./SelectStatement.js";
+import type { UpdateStatement } from "./UpdateStatement.js";
+export interface IStatementVisitor {
+    visit(statement: SelectStatement): string;
+    visit(statement: InsertStatement): string;
+    visit(statement: UpdateStatement): string;
+    visit(statement: DeleteStatement): string;
+    visit(statement: CreateTableStatement): string;
+    visit(statement: CreateIndexStatement): string;
+    visit(statement: ExecuteStoredProcedureStatement): string;
+    visit(statement: ReturnStatement): string;
+    visit(statement: SelectInsertedIdStatement): string;
+    visit(statement: BulkInsertStatement): string;
+    visit(statement: BulkUpdateStatement): string;
+    visit(statement: BulkDeleteStatement): string;
+}

package/dist/statements/ITableConstraint.d.ts

@@ -0,0 +1,5 @@
+export type TableConstraintKind = "primaryKey" | "foreignKey" | "unique" | "check";
+export interface ITableConstraint {
+    readonly kind: TableConstraintKind;
+    readonly name: string;
+}

package/dist/statements/IUpdateStatement.d.ts

@@ -0,0 +1,5 @@
+import type { IStatement } from "./IStatement.js";
+import type { IWhere } from "./IWhere.js";
+export interface IUpdateStatement extends IStatement {
+    readonly where?: IWhere;
+}

package/dist/statements/IWhere.d.ts

@@ -0,0 +1,6 @@
+import type { Parameter } from "../Parameter.js";
+import type { ICondition } from "./ICondition.js";
+import type { IExpression } from "./IExpression.js";
+export interface IWhere extends IExpression, ICondition {
+    readonly parameters?: Parameter[];
+}

package/dist/statements/Identifier.d.ts

@@ -0,0 +1,5 @@
+import type { IExpression } from "./IExpression.js";
+export declare class Identifier implements IExpression {
+    readonly name: string;
+    constructor(name: string);
+}

package/dist/statements/InsertStatement.d.ts

@@ -0,0 +1,9 @@
+import type { Field } from "../builders/Field.js";
+import type { IInsertStatement } from "./IInsertStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export declare class InsertStatement implements IInsertStatement {
+    readonly table: string;
+    readonly fields: Field[];
+    constructor(table: string, fields: Field[]);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/InsertStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { InsertStatement } from "./InsertStatement.js";
+export declare class InsertStatementTextRenderer {
+    render(statement: InsertStatement): string;
+}

package/dist/statements/Join.d.ts

@@ -0,0 +1,14 @@
+import type { IExpression } from "./IExpression.js";
+export type JoinKind = "inner" | "left" | "right" | "full" | "cross";
+export type Join = {
+    kind: JoinKind;
+    table: string;
+    on?: IExpression;
+};
+export declare const Join: {
+    inner: (table: string, left: string, right: string) => Join;
+    left: (table: string, left: string, right: string) => Join;
+    right: (table: string, left: string, right: string) => Join;
+    full: (table: string, left: string, right: string) => Join;
+    cross: (table: string) => Join;
+};

package/dist/statements/Literal.d.ts

@@ -0,0 +1,6 @@
+import type { Cell } from "../converters/Cell.js";
+import type { IExpression } from "./IExpression.js";
+export declare class Literal implements IExpression {
+    readonly value: Cell;
+    constructor(value: Cell);
+}

package/dist/statements/Native.d.ts

@@ -0,0 +1,5 @@
+export declare class Native {
+    readonly text: string;
+    constructor(text: string);
+}
+export declare const n: (text: string) => Native;

package/dist/statements/NotNull.d.ts

@@ -0,0 +1,4 @@
+export declare class NotNull {
+    readonly name?: string | undefined;
+    constructor(name?: string | undefined);
+}

package/dist/statements/Operator.d.ts

@@ -0,0 +1,107 @@
+import type { Cell } from "../converters/Cell.js";
+import { Condition } from "./Condition.js";
+import type { IExpression } from "./IExpression.js";
+export declare abstract class Operator extends Condition {
+}
+export declare namespace Operator {
+    class Equals extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class NotEquals extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class GreaterThan extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class LessThan extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class GreaterThanOrEqual extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class LessThanOrEqual extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class And extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(left: IExpression, right: IExpression);
+    }
+    class Or extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(left: IExpression, right: IExpression);
+    }
+    class In extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, values: Cell[]);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class Not extends Operator {
+        readonly argument: IExpression;
+        constructor(argument: IExpression);
+    }
+    class IsNull extends Operator {
+        readonly argument: IExpression;
+        constructor(argument: IExpression);
+    }
+    class IsNotNull extends Operator {
+        readonly argument: IExpression;
+        constructor(argument: IExpression);
+    }
+    class Like extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class NotLike extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class Between extends Operator {
+        readonly value: IExpression;
+        readonly low: IExpression;
+        readonly high: IExpression;
+        constructor(field: string, low: Cell, high: Cell);
+        constructor(value: IExpression, low: IExpression, high: IExpression);
+    }
+    class NotBetween extends Operator {
+        readonly value: IExpression;
+        readonly low: IExpression;
+        readonly high: IExpression;
+        constructor(field: string, low: Cell, high: Cell);
+        constructor(value: IExpression, low: IExpression, high: IExpression);
+    }
+    class NotIn extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, values: Cell[]);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class Exists extends Operator {
+        readonly argument: IExpression;
+        constructor(argument: IExpression);
+    }
+}

package/dist/statements/OrderBy.d.ts

@@ -0,0 +1,10 @@
+export type SortDirection = "asc" | "desc";
+export type OrderBy = {
+    column: string;
+    direction: SortDirection;
+};
+export declare const OrderBy: {
+    asc: (column: string) => OrderBy;
+    desc: (column: string) => OrderBy;
+};
+export declare const orderText: (order: OrderBy) => string;

package/dist/statements/PrimaryKey.d.ts

@@ -0,0 +1,7 @@
+import type { ITableConstraint } from "./ITableConstraint.js";
+export declare class PrimaryKey implements ITableConstraint {
+    readonly name: string;
+    readonly columns: string[];
+    readonly kind: "primaryKey";
+    constructor(name: string, columns: string[]);
+}

package/dist/statements/ReturnStatement.d.ts

@@ -0,0 +1,9 @@
+import type { Parameter } from "../Parameter.js";
+import type { IReturnStatement } from "./IReturnStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export declare class ReturnStatement implements IReturnStatement {
+    readonly name: string;
+    readonly parameters: Parameter[];
+    constructor(name: string, parameters: Parameter[]);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/ReturnStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { ReturnStatement } from "./ReturnStatement.js";
+export declare class ReturnStatementTextRenderer {
+    render(statement: ReturnStatement): string;
+}

package/dist/statements/SelectInsertedIdStatement.d.ts

@@ -0,0 +1,8 @@
+import type { IStatement } from "./IStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export declare class SelectInsertedIdStatement implements IStatement {
+    readonly table: string;
+    readonly column: string;
+    constructor(table: string, column: string);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/SelectInsertedIdStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.js";
+export declare class SelectInsertedIdStatementTextRenderer {
+    render(_statement: SelectInsertedIdStatement): string;
+}

package/dist/statements/SelectStatement.d.ts

@@ -0,0 +1,20 @@
+import type { ISelectStatement } from "./ISelectStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { IWhere } from "./IWhere.js";
+import type { Join } from "./Join.js";
+import type { OrderBy } from "./OrderBy.js";
+import type { SelectStatementOptions } from "./SelectStatementOptions.js";
+export declare class SelectStatement implements ISelectStatement {
+    readonly where?: IWhere;
+    readonly distinct: boolean;
+    readonly table?: string;
+    readonly fields: string[];
+    readonly joins: Join[];
+    readonly groupBy: string[];
+    readonly having?: IWhere;
+    readonly orderBy: OrderBy[];
+    readonly limit?: number;
+    readonly offset?: number;
+    constructor(options: SelectStatementOptions);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/SelectStatementOptions.d.ts

@@ -0,0 +1,15 @@
+import type { Join } from "./Join.js";
+import type { IWhere } from "./IWhere.js";
+import type { OrderBy } from "./OrderBy.js";
+export type SelectStatementOptions = {
+    table?: string;
+    fields?: string[];
+    distinct?: boolean;
+    where?: IWhere;
+    joins?: Join[];
+    groupBy?: string[];
+    having?: IWhere;
+    orderBy?: OrderBy[];
+    limit?: number;
+    offset?: number;
+};

package/dist/statements/SelectStatementTextRenderer.d.ts

@@ -0,0 +1,19 @@
+import type { IWhere } from "./IWhere.js";
+import type { Join, JoinKind } from "./Join.js";
+import { type OrderBy } from "./OrderBy.js";
+import type { SelectStatement } from "./SelectStatement.js";
+import type { StatementTextRenderer } from "./StatementTextRenderer.js";
+export declare class SelectStatementTextRenderer {
+    private readonly text;
+    constructor(text: StatementTextRenderer);
+    render(statement: SelectStatement): string;
+    protected whereSql(where?: IWhere): string;
+    protected havingSql(having?: IWhere): string;
+    protected groupSql(columns?: string[]): string;
+    protected orderSql(order?: OrderBy[]): string;
+    protected limit(limit?: number): string;
+    protected offset(offset?: number): string;
+    protected bound(keyword: string, value?: number): string;
+    protected joinSql(joins?: Join[]): string;
+    protected keyword(kind: JoinKind): string;
+}

package/dist/statements/StatementEvaluator.d.ts

@@ -0,0 +1,4 @@
+import type { IStatement } from "./IStatement.js";
+export declare class StatementEvaluator {
+    evaluate: (_statement: IStatement) => void;
+}

package/dist/statements/StatementParser.d.ts

@@ -0,0 +1,4 @@
+import type { IStatement } from "./IStatement.js";
+export declare class StatementParser {
+    static parse(text: string): IStatement;
+}

package/dist/statements/StatementRenderer.d.ts

@@ -0,0 +1,42 @@
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import { BulkDeleteStatement } from "./BulkDeleteStatement.js";
+import { BulkInsertStatement } from "./BulkInsertStatement.js";
+import { BulkUpdateStatement } from "./BulkUpdateStatement.js";
+import { CreateIndexStatement } from "./CreateIndexStatement.js";
+import { CreateTableStatement } from "./CreateTableStatement.js";
+import { DeleteStatement } from "./DeleteStatement.js";
+import { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.js";
+import { InsertStatement } from "./InsertStatement.js";
+import { ReturnStatement } from "./ReturnStatement.js";
+import { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.js";
+import { SelectStatement } from "./SelectStatement.js";
+import type { StatementTextRenderer } from "./StatementTextRenderer.js";
+import { UpdateStatement } from "./UpdateStatement.js";
+export declare class StatementRenderer implements IStatementVisitor {
+    protected readonly text: StatementTextRenderer;
+    constructor(text: StatementTextRenderer);
+    visit(statement: SelectStatement): string;
+    visit(statement: InsertStatement): string;
+    visit(statement: UpdateStatement): string;
+    visit(statement: DeleteStatement): string;
+    visit(statement: CreateTableStatement): string;
+    visit(statement: CreateIndexStatement): string;
+    visit(statement: ExecuteStoredProcedureStatement): string;
+    visit(statement: ReturnStatement): string;
+    visit(statement: SelectInsertedIdStatement): string;
+    visit(statement: BulkInsertStatement): string;
+    visit(statement: BulkUpdateStatement): string;
+    visit(statement: BulkDeleteStatement): string;
+    protected visitSelect(statement: SelectStatement): string;
+    protected visitInsert(statement: InsertStatement): string;
+    protected visitUpdate(statement: UpdateStatement): string;
+    protected visitDelete(statement: DeleteStatement): string;
+    protected visitCreateTable(statement: CreateTableStatement): string;
+    protected visitCreateIndex(statement: CreateIndexStatement): string;
+    protected visitExecuteStoredProcedure(statement: ExecuteStoredProcedureStatement): string;
+    protected visitReturn(statement: ReturnStatement): string;
+    protected visitSelectInsertedId(statement: SelectInsertedIdStatement): string;
+    protected visitBulkInsert(statement: BulkInsertStatement): string;
+    protected visitBulkUpdate(statement: BulkUpdateStatement): string;
+    protected visitBulkDelete(statement: BulkDeleteStatement): string;
+}

package/dist/statements/StatementTextRenderer.d.ts

@@ -0,0 +1,14 @@
+import type { ICondition } from "./ICondition.js";
+import type { IConditionVisitor } from "./IConditionVisitor.js";
+import type { IStatement } from "./IStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import { ConditionRenderer } from "./ConditionRenderer.js";
+import { ExpressionRenderer } from "./ExpressionRenderer.js";
+import { StatementRenderer } from "./StatementRenderer.js";
+export declare class StatementTextRenderer {
+    protected readonly statements: IStatementVisitor;
+    protected readonly conditions: IConditionVisitor;
+    constructor(statements?: (text: StatementTextRenderer) => StatementRenderer, conditions?: (expressions: ExpressionRenderer) => ConditionRenderer, expressions?: (text: StatementTextRenderer) => ExpressionRenderer);
+    render(statement: IStatement): string;
+    render(condition: ICondition): string;
+}

package/dist/statements/Subquery.d.ts

@@ -0,0 +1,6 @@
+import type { IExpression } from "./IExpression.js";
+import type { SelectStatement } from "./SelectStatement.js";
+export declare class Subquery implements IExpression {
+    readonly query: SelectStatement;
+    constructor(query: SelectStatement);
+}

package/dist/statements/UniqueConstraint.d.ts

@@ -0,0 +1,7 @@
+import type { ITableConstraint } from "./ITableConstraint.js";
+export declare class UniqueConstraint implements ITableConstraint {
+    readonly name: string;
+    readonly columns: string[];
+    readonly kind: "unique";
+    constructor(name: string, columns: string[]);
+}

package/dist/statements/UpdateStatement.d.ts

@@ -0,0 +1,14 @@
+import type { Field } from "../builders/Field.js";
+import type { Parameter } from "../Parameter.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { IUpdateStatement } from "./IUpdateStatement.js";
+import type { IWhere } from "./IWhere.js";
+export declare class UpdateStatement implements IUpdateStatement {
+    readonly table: string;
+    readonly fields: Field[];
+    readonly where?: IWhere;
+    constructor(table: string, fields: Field[], where?: IWhere);
+    accept: (visitor: IStatementVisitor) => string;
+    get parameters(): Parameter[];
+    static parameterList: (fields: Field[], where?: IWhere) => Parameter[];
+}

package/dist/statements/UpdateStatementTextRenderer.d.ts

@@ -0,0 +1,14 @@
+import type { Field } from "../builders/Field.js";
+import type { Parameter } from "../Parameter.js";
+import type { IWhere } from "./IWhere.js";
+import type { StatementTextRenderer } from "./StatementTextRenderer.js";
+import type { UpdateStatement } from "./UpdateStatement.js";
+export declare class UpdateStatementTextRenderer {
+    private readonly text;
+    constructor(text: StatementTextRenderer);
+    render(statement: UpdateStatement): string;
+    compose(sql: string, where: IWhere | undefined, fields: Field[]): {
+        text: string;
+        parameters: Parameter[];
+    };
+}