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