pub(open) trait Engine {
  async page(Self, query : &QueryBuilder, pageable : Pageable) -> QueryResult
  async page_raw(Self, sql : String, params : FixedArray[Param], pageable : Pageable) -> QueryResult
  async exec(Self, query : &QueryBuilder) -> QueryResult
  async exec_raw(Self, sql : String, params : FixedArray[Param]) -> QueryResult
  async migrate_table(Self, table_schema : 
@oboard/morm/table.Table
Table) -> QueryResult
  close(Self) -> Unit
}

pub(open) trait FromParam {
  from_param(Param) -> Self raise ParamDecodeError
}

pub(open) trait QueryBuilder {
  to_query(Self) -> Query
}

pub(open) trait ToParam {
  to_param(Self) -> Param
}

pub(all) suberror ParamDecodeError {
  ParamDecodeError(String)
} derive(Eq, ToJson)

pub(all) struct ConnectionPool[C] {
  idle : 
@moonbitlang/async/aqueue.Queue
Queue[C]
  permits : 
@moonbitlang/async/semaphore.Semaphore
Semaphore
  closed : Bool
}

pub(all) struct DeleteStatement {
  from : String
  where_ : FixedArray[Where]
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) struct InsertStatement {
  into : String
  columns : FixedArray[String]
  values : FixedArray[Param]
  rows : FixedArray[FixedArray[Param]]
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) enum OrderBy {
  Asc(String)
  Desc(String)
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) struct Page[T] {
  content : FixedArray[T]
  total_elements : Int
  total_pages : Int
  number : Int
  size : Int
  first : Bool
  last : Bool
  empty : Bool
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) struct Pageable {
  page : Int
  size : Int
  sort : Sort?
} derive(Eq, ToJson, 
@moonbitlang/core/debug.Debug
Debug, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) enum Param {
  Null
  Bool(Bool)
  Byte(Byte)
  Int(Int)
  Int16(Int16)
  UInt16(UInt16)
  UInt(UInt)
  UInt64(UInt64)
  Int64(Int64)
  BigInt(
@moonbitlang/core/bigint.BigInt
BigInt)
  Float(Float)
  Double(Double)
  Decimal(String)
  Date(
@oboard/morm/time.PlainDate
PlainDate, String?)
  Time(
@oboard/morm/time.PlainTime
PlainTime, String?)
  DateTime(
@oboard/morm/time.PlainDateTime
PlainDateTime, String?)
  Timestamp(
@oboard/morm/time.ZonedDateTime
ZonedDateTime, String?)
  Uuid(String)
  Object(Map[String, Param])
  Json(Json)
  String(String)
  Bytes(Bytes)
}

pub(all) enum Query {
  Statement(Statement)
  Raw(String, FixedArray[Param])
  Tx(TxOp)
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) struct QueryResult {
  ok : Bool
  rows_affected : Int
  rows : FixedArray[Map[String, Param]]
  error : String?
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) struct SelectStatement {
  select : String
  from : String
  joins : FixedArray[String]
  where_ : FixedArray[Where]
  order_by : FixedArray[OrderBy]
  limit : Int?
  offset : Int?
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) struct Set {
  col : String
  value : Param
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) struct Sort {
  property : String
  direction : SortDirection
} derive(Eq, ToJson, 
@moonbitlang/core/debug.Debug
Debug, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) enum SortDirection {
  Asc
  Desc
} derive(Eq, ToJson, 
@moonbitlang/core/debug.Debug
Debug, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) enum Statement {
  Select(SelectStatement)
  Insert(InsertStatement)
  Upsert(UpsertStatement)
  Update(UpdateStatement)
  Delete(DeleteStatement)
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) enum TxOp {
  Begin
  Commit
  Rollback
  Savepoint(String)
  RollbackToSavepoint(String)
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) struct UpdateStatement {
  table : String
  sets : FixedArray[Set]
  where_ : FixedArray[Where]
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) struct UpsertStatement {
  table : String
  sets : FixedArray[Set]
  conflict_target : FixedArray[String]
  update_sets : FixedArray[Set]
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) struct Where {
  col : String
  value : Param
  ty : WhereType
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

pub(all) enum WhereType {
  Eq
  Ne
  Gt
  Lt
  Gte
  Lte
  Like
} derive(Eq, ToJson, 
@moonbitlang/core/json.FromJson
FromJson)

fn bytes_to_hex(data : Bytes) -> String

fn decode_json_column(value : Json, storage : String) -> Json raise ParamDecodeError

fn[T : 
@moonbitlang/core/json.FromJson
FromJson] enum_from_param(value : Param) -> T raise ParamDecodeError

fn[T : ToJson] enum_to_param(value : T) -> Param raise ParamDecodeError

fn format_plain_date(value : 
@oboard/morm/time.PlainDate
PlainDate, format : String?) -> String

fn format_plain_date_time(value : 
@oboard/morm/time.PlainDateTime
PlainDateTime, format : String?) -> String

fn format_plain_time(value : 
@oboard/morm/time.PlainTime
PlainTime, format : String?) -> String

fn format_zoned_date_time(value : 
@oboard/morm/time.ZonedDateTime
ZonedDateTime, format : String?) -> String

fn[T : FromParam] from_param(value : Param) -> T raise ParamDecodeError

fn param_from_json_value(json : Json) -> Param

fn param_row_from_json(row : Json) -> Map[String, Param]

async fn[E : Engine] preload_belongs_to_default(engine : E, sql : String, target_key : String, key_params : FixedArray[Param]) -> Map[String, Json]

async fn[E : Engine] preload_has_many_default(engine : E, sql : String, target_key : String, key_params : FixedArray[Param]) -> Map[String, Array[Json]]

fn preload_in_sql_dollar(table : String, key_col : String, count : Int) -> String

fn preload_in_sql_qmark(table : String, key_col : String, count : Int) -> String

async fn[E : Engine] preload_many_to_many_default(engine : E, sql : String, key_params : FixedArray[Param]) -> Map[String, Array[Json]]

fn preload_many_to_many_sql_dollar(target_table : String, target_key : String, join_table : String, join_owner_key : String, join_target_key : String, count : Int) -> String

fn preload_many_to_many_sql_qmark(target_table : String, target_key : String, join_table : String, join_owner_key : String, join_target_key : String, count : Int) -> String

fn render_default_sql(stmt : Statement) -> (String, FixedArray[Param])

fn render_query_sql(query : &QueryBuilder) -> (String, FixedArray[Param])

fn[T : ToParam] to_param(value : T) -> Param