Statement

interface Compiler {
  readonly compile: (statement: Fragment, withoutTransform: boolean) => readonly [string, readonly Array<unknown>];
  readonly dialect: Dialect;
  readonly withoutTransform: Compiler;
}

declare const makeCompiler: <C extends Custom<any, any, any, any> = any>(options: {
  readonly dialect: Dialect;
  readonly onCustom: (
    type: C,
    placeholder: (u: unknown) => string,
    withoutTransform: boolean,
  ) => readonly [sql: string, params: ReadonlyArray<unknown>];
  readonly onIdentifier: (value: string, withoutTransform: boolean) => string;
  readonly onInsert?: (
    columns: ReadonlyArray<string>,
    placeholders: string,
    values: ReadonlyArray<ReadonlyArray<unknown>>,
    returning: readonly [sql: string, params: ReadonlyArray<unknown>] | undefined,
  ) => readonly [sql: string, binds: ReadonlyArray<unknown>];
  readonly onRecordUpdate: (
    placeholders: string,
    alias: string,
    columns: string,
    values: ReadonlyArray<ReadonlyArray<unknown>>,
    returning: readonly [sql: string, params: ReadonlyArray<unknown>] | undefined,
  ) => readonly [sql: string, params: ReadonlyArray<unknown>];
  readonly onRecordUpdateSingle?: (
    columns: ReadonlyArray<string>,
    values: ReadonlyArray<unknown>,
    returning: readonly [sql: string, params: ReadonlyArray<unknown>] | undefined,
  ) => readonly [sql: string, params: ReadonlyArray<unknown>];
  readonly placeholder: (index: number, value: unknown) => string;
}) => Compiler;

declare const makeCompilerSqlite: (transform?: (_: string) => string) => Compiler;

declare const and: (clauses: ReadonlyArray<string | Fragment>) => Fragment;

declare const csv: {
  (values: readonly Array<string | Fragment>): Fragment;
  (prefix: string, values: readonly Array<string | Fragment>): Fragment;
}

declare const custom: <C extends Custom<any, any, any, any>>(
  kind: C["kind"],
) => (i0: C["i0"], i1: C["i1"], i2: C["i2"]) => Fragment;

declare const join: (
  literal: string,
  addParens?: boolean,
  fallback?: string,
) => (clauses: ReadonlyArray<string | Fragment>) => Fragment;

declare const make: (
  acquirer: Connection.Acquirer,
  compiler: Compiler,
  spanAttributes: ReadonlyArray<readonly [string, unknown]>,
  transformRows: <A extends object>(row: ReadonlyArray<A>) => ReadonlyArray<A> | undefined,
) => Constructor;

declare const or: (clauses: ReadonlyArray<string | Fragment>) => Fragment;

declare const unsafeFragment: (sql: string, params?: ReadonlyArray<unknown>) => Fragment;

declare const isCustom: <A extends Custom<any, any, any, any>>(
  kind: A["kind"],
) => (u: unknown) => u is A;

declare const isFragment: (u: unknown) => u is Fragment;

interface ArrayHelper {
  readonly _tag: "ArrayHelper";
  readonly value: readonly Array<unknown>;
}

interface Constructor {
  <A extends object = Row>(strings: TemplateStringsArray, ...args: Array<any>): Statement<A>;
  (value: string): Identifier;
  readonly and: (clauses: readonly Array<string | Fragment>) => Fragment;
  readonly csv: {
    (values: readonly Array<string | Fragment>): Fragment;
    (prefix: string, values: readonly Array<string | Fragment>): Fragment;
  };
  readonly in: {
    (value: readonly Array<unknown>): ArrayHelper;
    (column: string, value: readonly Array<unknown>): Fragment;
  };
  readonly insert: {
    (value: readonly Array<Record<string, unknown>>): RecordInsertHelper;
    (value: Record<string, unknown>): RecordInsertHelper;
  };
  readonly join: (literal: string, addParens?: boolean, fallback?: string) => (clauses: readonly Array<string | Fragment>) => Fragment;
  readonly literal: (sql: string) => Fragment;
  readonly onDialect: <A, B, C, D, E>(options: {
    readonly clickhouse: () => E;
    readonly mssql: () => D;
    readonly mysql: () => C;
    readonly pg: () => B;
    readonly sqlite: () => A;
  }) => A | B | C | D | E;
  readonly onDialectOrElse: <A, B = never, C = never, D = never, E = never, F = never>(options: {
    readonly clickhouse?: () => F;
    readonly mssql?: () => E;
    readonly mysql?: () => D;
    readonly orElse: () => A;
    readonly pg?: () => C;
    readonly sqlite?: () => B;
  }) => A | B | C | D | E | F;
  readonly or: (clauses: readonly Array<string | Fragment>) => Fragment;
  readonly unsafe: <A extends object>(sql: string, params?: readonly Array<any>) => Statement<A>;
  readonly update: <A extends Record<string, unknown>>(value: A, omit?: readonly Array<keyof A>) => RecordUpdateHelperSingle;
  readonly updateValues: (value: readonly Array<Record<string, unknown>>, alias: string) => RecordUpdateHelper;
}

interface Custom<T extends string = string, A = void, B = void, C = void> {
  readonly _tag: "Custom";
  readonly i0: A;
  readonly i1: B;
  readonly i2: C;
  readonly kind: T;
}

type Dialect = "sqlite" | "pg" | "mysql" | "mssql" | "clickhouse";

interface Fragment {
  readonly [FragmentId]: (_: never) => typeof FragmentId;
  readonly segments: readonly Array<Segment>;
}

type Helper =
  | ArrayHelper
  | RecordInsertHelper
  | RecordUpdateHelper
  | RecordUpdateHelperSingle
  | Identifier
  | Custom;

interface Identifier {
  readonly _tag: "Identifier";
  readonly value: string;
}

interface Literal {
  readonly _tag: "Literal";
  readonly params?: readonly Array<unknown>;
  readonly value: string;
}

interface Parameter {
  readonly _tag: "Parameter";
  readonly value: unknown;
}

type PrimitiveKind =
  | "string"
  | "number"
  | "bigint"
  | "boolean"
  | "Date"
  | "null"
  | "Int8Array"
  | "Uint8Array"
  | "object";

interface RecordInsertHelper {
  readonly _tag: "RecordInsertHelper";
  readonly returning: (sql: string | Fragment | Identifier) => RecordInsertHelper;
  readonly value: readonly Array<Record<string, unknown>>;
}

interface RecordUpdateHelper {
  readonly _tag: "RecordUpdateHelper";
  readonly alias: string;
  readonly returning: (sql: string | Fragment | Identifier) => RecordUpdateHelper;
  readonly value: readonly Array<Record<string, unknown>>;
}

interface RecordUpdateHelperSingle {
  readonly _tag: "RecordUpdateHelperSingle";
  readonly omit: readonly Array<string>;
  readonly returning: (sql: string | Fragment | Identifier) => RecordUpdateHelperSingle;
  readonly value: Record<string, unknown>;
}

type Segment =
  | Literal
  | Identifier
  | Parameter
  | ArrayHelper
  | RecordInsertHelper
  | RecordUpdateHelper
  | RecordUpdateHelperSingle
  | Custom;

interface Statement<A> extends Fragment, Effect<ReadonlyArray<A>, SqlError>, Pipeable {
  readonly compile: (withoutTransform?: boolean) => readonly [string, readonly Array<unknown>];
  readonly raw: Effect<unknown, SqlError>;
  readonly stream: Stream<A, SqlError>;
  readonly unprepared: Effect<readonly Array<A>, SqlError>;
  readonly values: Effect<readonly Array<readonly Array<unknown>>, SqlError>;
  readonly withoutTransform: Effect<readonly Array<A>, SqlError>;
}

declare const defaultEscape: (c: string) => (str: string) => string;

declare const defaultTransforms: (
  transformer: (str: string) => string,
  nested?: boolean,
) => {
  readonly array: <A extends object>(rows: ReadonlyArray<A>) => ReadonlyArray<A>;
  readonly object: (obj: Record<string, any>) => any;
  readonly value: (value: any) => any;
};

declare const primitiveKind: (value: unknown) => PrimitiveKind;

declare const currentTransformer: FiberRef.FiberRef<Option.Option<Statement.Transformer>>;

declare const setTransformer: (f: Statement.Transformer) => Layer.Layer<never, never, never>;

declare const withTransformer: {
  (f: Transformer): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
  <A, E, R>(effect: Effect<A, E, R>, f: Transformer): Effect<A, E, R>;
};

declare const withTransformerDisabled: <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;

declare const FragmentId: unique symbol;

type FragmentId = typeof FragmentId;