export interface Compiler {
  readonly dialect: Dialect
  readonly compile: (
    statement: Fragment,
    withoutTransform: boolean
  ) => readonly [sql: string, params: ReadonlyArray<Primitive>]
}

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

export declare const makeCompilerSqlite: (transform?: ((_: string) => string) | undefined) => Compiler

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

export declare const csv: {
  (values: ReadonlyArray<string | Fragment>): Fragment
  (prefix: string, values: ReadonlyArray<string | Fragment>): Fragment
}

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

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

export declare const make: (
  acquirer: Effect<Connection, SqlError, Scope>,
  compiler: Compiler,
  spanAttributes?: ReadonlyArray<readonly [string, unknown]>
) => Constructor

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

export declare const unsafeFragment: (sql: string, params?: ReadonlyArray<Primitive> | undefined) => Fragment

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

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

export type Argument = Primitive | Helper | Fragment

export interface ArrayHelper {
  readonly _tag: "ArrayHelper"
  readonly value: ReadonlyArray<Primitive | Fragment>
}

export interface Constructor {
  <A extends object = Row>(strings: TemplateStringsArray, ...args: Array<Argument>): Statement<A>

  (value: string): Identifier

  /**
   * Create unsafe SQL query
   */
  readonly unsafe: <A extends object>(sql: string, params?: ReadonlyArray<Primitive> | undefined) => Statement<A>

  readonly literal: (sql: string) => Fragment

  readonly in: {
    (value: ReadonlyArray<Primitive>): ArrayHelper
    (column: string, value: ReadonlyArray<Primitive>): Fragment
  }

  readonly insert: {
    (value: ReadonlyArray<Record<string, Primitive | Fragment>>): RecordInsertHelper
    (value: Record<string, Primitive | Fragment>): RecordInsertHelper
  }

  /** Update a single row */
  readonly update: <A extends Record<string, Primitive | Fragment>>(
    value: A,
    omit?: ReadonlyArray<keyof A>
  ) => RecordUpdateHelperSingle

  /**
   * Update multiple rows
   *
   * **Note:** Not supported in sqlite
   */
  readonly updateValues: (
    value: ReadonlyArray<Record<string, Primitive | Fragment>>,
    alias: string
  ) => RecordUpdateHelper

  /**
   * Create an `AND` chain for a where clause
   */
  readonly and: (clauses: ReadonlyArray<string | Fragment>) => Fragment

  /**
   * Create an `OR` chain for a where clause
   */
  readonly or: (clauses: ReadonlyArray<string | Fragment>) => Fragment

  /**
   * Create comma seperated values, with an optional prefix
   *
   * Useful for `ORDER BY` and `GROUP BY` clauses
   */
  readonly csv: {
    (values: ReadonlyArray<string | Fragment>): Fragment
    (prefix: string, values: ReadonlyArray<string | Fragment>): Fragment
  }

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

  readonly onDialect: <A, B, C, D>(options: {
    readonly sqlite: () => A
    readonly pg: () => B
    readonly mysql: () => C
    readonly mssql: () => D
  }) => A | B | C | D

  readonly onDialectOrElse: <A, B = never, C = never, D = never, E = never>(options: {
    readonly orElse: () => A
    readonly sqlite?: () => B
    readonly pg?: () => C
    readonly mysql?: () => D
    readonly mssql?: () => E
  }) => A | B | C | D | E
}

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

export type Dialect = "sqlite" | "pg" | "mysql" | "mssql"

export interface Fragment {
  readonly [FragmentId]: (_: never) => FragmentId
  readonly segments: ReadonlyArray<Segment>
}

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

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

export interface Literal {
  readonly _tag: "Literal"
  readonly value: string
  readonly params?: ReadonlyArray<Primitive> | undefined
}

export interface Parameter {
  readonly _tag: "Parameter"
  readonly value: Primitive
}

export type Primitive = string | number | bigint | boolean | Date | null | Int8Array | Uint8Array

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

export interface RecordInsertHelper {
  readonly _tag: "RecordInsertHelper"
  readonly value: ReadonlyArray<Record<string, Primitive | Fragment>>
  readonly returningIdentifier: string | Fragment | undefined
  readonly returning: (sql: string | Identifier | Fragment) => RecordInsertHelper
}

export interface RecordUpdateHelper {
  readonly _tag: "RecordUpdateHelper"
  readonly value: ReadonlyArray<Record<string, Primitive | Fragment>>
  readonly alias: string
  readonly returningIdentifier: string | Fragment | undefined
  readonly returning: (sql: string | Identifier | Fragment) => RecordUpdateHelper
}

export interface RecordUpdateHelperSingle {
  readonly _tag: "RecordUpdateHelperSingle"
  readonly value: Record<string, Primitive | Fragment>
  readonly omit: ReadonlyArray<string>
  readonly returningIdentifier: string | Fragment | undefined
  readonly returning: (sql: string | Identifier | Fragment) => RecordUpdateHelperSingle
}

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

export interface Statement<A> extends Fragment, Effect<ReadonlyArray<A>, SqlError>, Pipeable {
  readonly withoutTransform: Effect<ReadonlyArray<A>, SqlError>
  readonly stream: Stream.Stream<A, SqlError>
  readonly values: Effect<ReadonlyArray<ReadonlyArray<Primitive>>, SqlError>
  readonly unprepared: Effect<ReadonlyArray<A>, SqlError>
  readonly compile: (withoutTransform?: boolean | undefined) => readonly [sql: string, params: ReadonlyArray<Primitive>]
}

export type Transformer = (
  self: Statement<unknown>,
  sql: Constructor,
  context: FiberRefs.FiberRefs,
  span: Tracer.Span
) => Statement<unknown>

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

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

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

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

export declare const FragmentId: typeof FragmentId

export type FragmentId = typeof FragmentId

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

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

export declare const primitiveKind: (value: Primitive) => PrimitiveKind