// Generated by Lisette bindgen
// Source: database/sql (Go stdlib)
// Go: 1.25.10
// Lisette: 0.2.1

import "go:context"
import "go:database/sql/driver"
import "go:reflect"
import "go:time"

pub enum IsolationLevel: int {
  LevelDefault = 0,
  LevelLinearizable = 7,
  LevelReadCommitted = 2,
  LevelReadUncommitted = 1,
  LevelRepeatableRead = 4,
  LevelSerializable = 6,
  LevelSnapshot = 5,
  LevelWriteCommitted = 3,
}

pub const LevelDefault: IsolationLevel = 0

pub const LevelLinearizable: IsolationLevel = 7

pub const LevelReadCommitted: IsolationLevel = 2

pub const LevelReadUncommitted: IsolationLevel = 1

pub const LevelRepeatableRead: IsolationLevel = 4

pub const LevelSerializable: IsolationLevel = 6

pub const LevelSnapshot: IsolationLevel = 5

pub const LevelWriteCommitted: IsolationLevel = 3

/// Drivers returns a sorted list of the names of the registered drivers.
pub fn Drivers() -> Slice<string>

/// Named provides a more concise way to create [NamedArg] values.
/// 
/// Example usage:
/// 
/// 	db.ExecContext(ctx, `
/// 	    delete from Invoice
/// 	    where
/// 	        TimeCreated < @end
/// 	        and TimeCreated >= @start;`,
/// 	    sql.Named("start", startTime),
/// 	    sql.Named("end", endTime),
/// 	)
pub fn Named(name: string, value: Unknown) -> NamedArg

/// Open opens a database specified by its database driver name and a
/// driver-specific data source name, usually consisting of at least a
/// database name and connection information.
/// 
/// Most users will open a database via a driver-specific connection
/// helper function that returns a [*DB]. No database drivers are included
/// in the Go standard library. See https://golang.org/s/sqldrivers for
/// a list of third-party drivers.
/// 
/// Open may just validate its arguments without creating a connection
/// to the database. To verify that the data source name is valid, call
/// [DB.Ping].
/// 
/// The returned [DB] is safe for concurrent use by multiple goroutines
/// and maintains its own pool of idle connections. Thus, the Open
/// function should be called just once. It is rarely necessary to
/// close a [DB].
pub fn Open(driverName: string, dataSourceName: string) -> Result<Ref<DB>, error>

/// OpenDB opens a database using a [driver.Connector], allowing drivers to
/// bypass a string based data source name.
/// 
/// Most users will open a database via a driver-specific connection
/// helper function that returns a [*DB]. No database drivers are included
/// in the Go standard library. See https://golang.org/s/sqldrivers for
/// a list of third-party drivers.
/// 
/// OpenDB may just validate its arguments without creating a connection
/// to the database. To verify that the data source name is valid, call
/// [DB.Ping].
/// 
/// The returned [DB] is safe for concurrent use by multiple goroutines
/// and maintains its own pool of idle connections. Thus, the OpenDB
/// function should be called just once. It is rarely necessary to
/// close a [DB].
pub fn OpenDB(c: driver.Connector) -> Ref<DB>

/// Register makes a database driver available by the provided name.
/// If Register is called twice with the same name or if driver is nil,
/// it panics.
pub fn Register(name: string, driver: driver.Driver)

/// ColumnType contains the name and type of a column.
pub type ColumnType

/// Conn represents a single database connection rather than a pool of database
/// connections. Prefer running queries from [DB] unless there is a specific
/// need for a continuous single database connection.
/// 
/// A Conn must call [Conn.Close] to return the connection to the database pool
/// and may do so concurrently with a running query.
/// 
/// After a call to [Conn.Close], all operations on the
/// connection fail with [ErrConnDone].
pub type Conn

/// DB is a database handle representing a pool of zero or more
/// underlying connections. It's safe for concurrent use by multiple
/// goroutines.
/// 
/// The sql package creates and frees connections automatically; it
/// also maintains a free pool of idle connections. If the database has
/// a concept of per-connection state, such state can be reliably observed
/// within a transaction ([Tx]) or connection ([Conn]). Once [DB.Begin] is called, the
/// returned [Tx] is bound to a single connection. Once [Tx.Commit] or
/// [Tx.Rollback] is called on the transaction, that transaction's
/// connection is returned to [DB]'s idle connection pool. The pool size
/// can be controlled with [DB.SetMaxIdleConns].
pub type DB

/// DBStats contains database statistics.
pub struct DBStats {
  pub MaxOpenConnections: int,
  pub OpenConnections: int,
  pub InUse: int,
  pub Idle: int,
  pub WaitCount: int64,
  pub WaitDuration: time.Duration,
  pub MaxIdleClosed: int64,
  pub MaxIdleTimeClosed: int64,
  pub MaxLifetimeClosed: int64,
}

/// A NamedArg is a named argument. NamedArg values may be used as
/// arguments to [DB.Query] or [DB.Exec] and bind to the corresponding named
/// parameter in the SQL statement.
/// 
/// For a more concise way to create NamedArg values, see
/// the [Named] function.
pub struct NamedArg {
  pub Name: string,
  pub Value: Unknown,
}

/// Null represents a value that may be null.
/// Null implements the [Scanner] interface so
/// it can be used as a scan destination:
/// 
/// 	var s Null[string]
/// 	err := db.QueryRow("SELECT name FROM foo WHERE id=?", id).Scan(&s)
/// 	...
/// 	if s.Valid {
/// 	   // use s.V
/// 	} else {
/// 	   // NULL value
/// 	}
/// 
/// T should be one of the types accepted by [driver.Value].
pub struct Null<T> {
  pub V: T,
  pub Valid: bool,
}

/// NullBool represents a bool that may be null.
/// NullBool implements the [Scanner] interface so
/// it can be used as a scan destination, similar to [NullString].
pub struct NullBool {
  pub Bool: bool,
  pub Valid: bool,
}

/// NullByte represents a byte that may be null.
/// NullByte implements the [Scanner] interface so
/// it can be used as a scan destination, similar to [NullString].
pub struct NullByte {
  pub Byte: byte,
  pub Valid: bool,
}

/// NullFloat64 represents a float64 that may be null.
/// NullFloat64 implements the [Scanner] interface so
/// it can be used as a scan destination, similar to [NullString].
pub struct NullFloat64 {
  pub Float64: float64,
  pub Valid: bool,
}

/// NullInt16 represents an int16 that may be null.
/// NullInt16 implements the [Scanner] interface so
/// it can be used as a scan destination, similar to [NullString].
pub struct NullInt16 {
  pub Int16: int16,
  pub Valid: bool,
}

/// NullInt32 represents an int32 that may be null.
/// NullInt32 implements the [Scanner] interface so
/// it can be used as a scan destination, similar to [NullString].
pub struct NullInt32 {
  pub Int32: int32,
  pub Valid: bool,
}

/// NullInt64 represents an int64 that may be null.
/// NullInt64 implements the [Scanner] interface so
/// it can be used as a scan destination, similar to [NullString].
pub struct NullInt64 {
  pub Int64: int64,
  pub Valid: bool,
}

/// NullString represents a string that may be null.
/// NullString implements the [Scanner] interface so
/// it can be used as a scan destination:
/// 
/// 	var s NullString
/// 	err := db.QueryRow("SELECT name FROM foo WHERE id=?", id).Scan(&s)
/// 	...
/// 	if s.Valid {
/// 	   // use s.String
/// 	} else {
/// 	   // NULL value
/// 	}
pub struct NullString {
  pub String: string,
  pub Valid: bool,
}

/// NullTime represents a [time.Time] that may be null.
/// NullTime implements the [Scanner] interface so
/// it can be used as a scan destination, similar to [NullString].
pub struct NullTime {
  pub Time: time.Time,
  pub Valid: bool,
}

/// Out may be used to retrieve OUTPUT value parameters from stored procedures.
/// 
/// Not all drivers and databases support OUTPUT value parameters.
/// 
/// Example usage:
/// 
/// 	var outArg string
/// 	_, err := db.ExecContext(ctx, "ProcName", sql.Named("Arg1", sql.Out{Dest: &outArg}))
pub struct Out {
  pub Dest: Unknown,
  pub In: bool,
}

/// RawBytes is a byte slice that holds a reference to memory owned by
/// the database itself. After a [Rows.Scan] into a RawBytes, the slice is only
/// valid until the next call to [Rows.Next], [Rows.Scan], or [Rows.Close].
pub struct RawBytes(Slice<byte>)

/// A Result summarizes an executed SQL command.
pub interface Result {
  fn LastInsertId() -> Result<int64, error>
  fn RowsAffected() -> Result<int64, error>
}

/// Row is the result of calling [DB.QueryRow] to select a single row.
pub type Row

/// Rows is the result of a query. Its cursor starts before the first row
/// of the result set. Use [Rows.Next] to advance from row to row.
pub type Rows

/// Scanner is an interface used by [Rows.Scan].
pub interface Scanner {
  fn Scan(src: Unknown) -> Result<(), error>
}

/// Stmt is a prepared statement.
/// A Stmt is safe for concurrent use by multiple goroutines.
/// 
/// If a Stmt is prepared on a [Tx] or [Conn], it will be bound to a single
/// underlying connection forever. If the [Tx] or [Conn] closes, the Stmt will
/// become unusable and all operations will return an error.
/// If a Stmt is prepared on a [DB], it will remain usable for the lifetime of the
/// [DB]. When the Stmt needs to execute on a new underlying connection, it will
/// prepare itself on the new connection automatically.
pub type Stmt

/// Tx is an in-progress database transaction.
/// 
/// A transaction must end with a call to [Tx.Commit] or [Tx.Rollback].
/// 
/// After a call to [Tx.Commit] or [Tx.Rollback], all operations on the
/// transaction fail with [ErrTxDone].
/// 
/// The statements prepared for a transaction by calling
/// the transaction's [Tx.Prepare] or [Tx.Stmt] methods are closed
/// by the call to [Tx.Commit] or [Tx.Rollback].
pub type Tx

/// TxOptions holds the transaction options to be used in [DB.BeginTx].
pub struct TxOptions {
  pub Isolation: IsolationLevel,
  pub ReadOnly: bool,
}

/// ErrConnDone is returned by any operation that is performed on a connection
/// that has already been returned to the connection pool.
pub var ErrConnDone: error

/// ErrNoRows is returned by [Row.Scan] when [DB.QueryRow] doesn't return a
/// row. In such a case, QueryRow returns a placeholder [*Row] value that
/// defers this error until a Scan.
pub var ErrNoRows: error

/// ErrTxDone is returned by any operation that is performed on a transaction
/// that has already been committed or rolled back.
pub var ErrTxDone: error

impl ColumnType {
  /// DatabaseTypeName returns the database system name of the column type. If an empty
  /// string is returned, then the driver type name is not supported.
  /// Consult your driver documentation for a list of driver data types. [ColumnType.Length] specifiers
  /// are not included.
  /// Common type names include "VARCHAR", "TEXT", "NVARCHAR", "DECIMAL", "BOOL",
  /// "INT", and "BIGINT".
  fn DatabaseTypeName(self: Ref<ColumnType>) -> string

  /// DecimalSize returns the scale and precision of a decimal type.
  /// If not applicable or if not supported ok is false.
  fn DecimalSize(self: Ref<ColumnType>) -> Option<(int64, int64)>

  /// Length returns the column type length for variable length column types such
  /// as text and binary field types. If the type length is unbounded the value will
  /// be [math.MaxInt64] (any database limits will still apply).
  /// If the column type is not variable length, such as an int, or if not supported
  /// by the driver ok is false.
  fn Length(self: Ref<ColumnType>) -> Option<int64>

  /// Name returns the name or alias of the column.
  fn Name(self: Ref<ColumnType>) -> string

  /// Nullable reports whether the column may be null.
  /// If a driver does not support this property ok will be false.
  fn Nullable(self: Ref<ColumnType>) -> Option<bool>

  /// ScanType returns a Go type suitable for scanning into using [Rows.Scan].
  /// If a driver does not support this property ScanType will return
  /// the type of an empty interface.
  fn ScanType(self: Ref<ColumnType>) -> Option<reflect.Type>
}

impl Conn {
  /// BeginTx starts a transaction.
  /// 
  /// The provided context is used until the transaction is committed or rolled back.
  /// If the context is canceled, the sql package will roll back
  /// the transaction. [Tx.Commit] will return an error if the context provided to
  /// BeginTx is canceled.
  /// 
  /// The provided [TxOptions] is optional and may be nil if defaults should be used.
  /// If a non-default isolation level is used that the driver doesn't support,
  /// an error will be returned.
  fn BeginTx(self: Ref<Conn>, ctx: context.Context, opts: Ref<TxOptions>) -> Result<Ref<Tx>, error>

  /// Close returns the connection to the connection pool.
  /// All operations after a Close will return with [ErrConnDone].
  /// Close is safe to call concurrently with other operations and will
  /// block until all other operations finish. It may be useful to first
  /// cancel any used context and then call close directly after.
  #[allow(unused_result)]
  fn Close(self: Ref<Conn>) -> Result<(), error>

  /// ExecContext executes a query without returning any rows.
  /// The args are for any placeholder parameters in the query.
  fn ExecContext(
    self: Ref<Conn>,
    ctx: context.Context,
    query: string,
    args: VarArgs<Unknown>,
  ) -> Result<Result, error>

  /// PingContext verifies the connection to the database is still alive.
  fn PingContext(self: Ref<Conn>, ctx: context.Context) -> Result<(), error>

  /// PrepareContext creates a prepared statement for later queries or executions.
  /// Multiple queries or executions may be run concurrently from the
  /// returned statement.
  /// The caller must call the statement's [*Stmt.Close] method
  /// when the statement is no longer needed.
  /// 
  /// The provided context is used for the preparation of the statement, not for the
  /// execution of the statement.
  fn PrepareContext(self: Ref<Conn>, ctx: context.Context, query: string) -> Result<Ref<Stmt>, error>

  /// QueryContext executes a query that returns rows, typically a SELECT.
  /// The args are for any placeholder parameters in the query.
  fn QueryContext(
    self: Ref<Conn>,
    ctx: context.Context,
    query: string,
    args: VarArgs<Unknown>,
  ) -> Result<Ref<Rows>, error>

  /// QueryRowContext executes a query that is expected to return at most one row.
  /// QueryRowContext always returns a non-nil value. Errors are deferred until
  /// the [*Row.Scan] method is called.
  /// If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
  /// Otherwise, the [*Row.Scan] scans the first selected row and discards
  /// the rest.
  fn QueryRowContext(
    self: Ref<Conn>,
    ctx: context.Context,
    query: string,
    args: VarArgs<Unknown>,
  ) -> Ref<Row>

  /// Raw executes f exposing the underlying driver connection for the
  /// duration of f. The driverConn must not be used outside of f.
  /// 
  /// Once f returns and err is not [driver.ErrBadConn], the [Conn] will continue to be usable
  /// until [Conn.Close] is called.
  fn Raw(self: Ref<Conn>, f: fn(Unknown) -> Result<(), error>) -> Result<(), error>
}

impl DB {
  /// Begin starts a transaction. The default isolation level is dependent on
  /// the driver.
  /// 
  /// Begin uses [context.Background] internally; to specify the context, use
  /// [DB.BeginTx].
  fn Begin(self: Ref<DB>) -> Result<Ref<Tx>, error>

  /// BeginTx starts a transaction.
  /// 
  /// The provided context is used until the transaction is committed or rolled back.
  /// If the context is canceled, the sql package will roll back
  /// the transaction. [Tx.Commit] will return an error if the context provided to
  /// BeginTx is canceled.
  /// 
  /// The provided [TxOptions] is optional and may be nil if defaults should be used.
  /// If a non-default isolation level is used that the driver doesn't support,
  /// an error will be returned.
  fn BeginTx(self: Ref<DB>, ctx: context.Context, opts: Ref<TxOptions>) -> Result<Ref<Tx>, error>

  /// Close closes the database and prevents new queries from starting.
  /// Close then waits for all queries that have started processing on the server
  /// to finish.
  /// 
  /// It is rare to Close a [DB], as the [DB] handle is meant to be
  /// long-lived and shared between many goroutines.
  #[allow(unused_result)]
  fn Close(self: Ref<DB>) -> Result<(), error>

  /// Conn returns a single connection by either opening a new connection
  /// or returning an existing connection from the connection pool. Conn will
  /// block until either a connection is returned or ctx is canceled.
  /// Queries run on the same Conn will be run in the same database session.
  /// 
  /// Every Conn must be returned to the database pool after use by
  /// calling [Conn.Close].
  fn Conn(self: Ref<DB>, ctx: context.Context) -> Result<Ref<Conn>, error>

  /// Driver returns the database's underlying driver.
  fn Driver(self: Ref<DB>) -> Option<driver.Driver>

  /// Exec executes a query without returning any rows.
  /// The args are for any placeholder parameters in the query.
  /// 
  /// Exec uses [context.Background] internally; to specify the context, use
  /// [DB.ExecContext].
  fn Exec(self: Ref<DB>, query: string, args: VarArgs<Unknown>) -> Result<Result, error>

  /// ExecContext executes a query without returning any rows.
  /// The args are for any placeholder parameters in the query.
  fn ExecContext(
    self: Ref<DB>,
    ctx: context.Context,
    query: string,
    args: VarArgs<Unknown>,
  ) -> Result<Result, error>

  /// Ping verifies a connection to the database is still alive,
  /// establishing a connection if necessary.
  /// 
  /// Ping uses [context.Background] internally; to specify the context, use
  /// [DB.PingContext].
  fn Ping(self: Ref<DB>) -> Result<(), error>

  /// PingContext verifies a connection to the database is still alive,
  /// establishing a connection if necessary.
  fn PingContext(self: Ref<DB>, ctx: context.Context) -> Result<(), error>

  /// Prepare creates a prepared statement for later queries or executions.
  /// Multiple queries or executions may be run concurrently from the
  /// returned statement.
  /// The caller must call the statement's [*Stmt.Close] method
  /// when the statement is no longer needed.
  /// 
  /// Prepare uses [context.Background] internally; to specify the context, use
  /// [DB.PrepareContext].
  fn Prepare(self: Ref<DB>, query: string) -> Result<Ref<Stmt>, error>

  /// PrepareContext creates a prepared statement for later queries or executions.
  /// Multiple queries or executions may be run concurrently from the
  /// returned statement.
  /// The caller must call the statement's [*Stmt.Close] method
  /// when the statement is no longer needed.
  /// 
  /// The provided context is used for the preparation of the statement, not for the
  /// execution of the statement.
  fn PrepareContext(self: Ref<DB>, ctx: context.Context, query: string) -> Result<Ref<Stmt>, error>

  /// Query executes a query that returns rows, typically a SELECT.
  /// The args are for any placeholder parameters in the query.
  /// 
  /// Query uses [context.Background] internally; to specify the context, use
  /// [DB.QueryContext].
  fn Query(self: Ref<DB>, query: string, args: VarArgs<Unknown>) -> Result<Ref<Rows>, error>

  /// QueryContext executes a query that returns rows, typically a SELECT.
  /// The args are for any placeholder parameters in the query.
  fn QueryContext(
    self: Ref<DB>,
    ctx: context.Context,
    query: string,
    args: VarArgs<Unknown>,
  ) -> Result<Ref<Rows>, error>

  /// QueryRow executes a query that is expected to return at most one row.
  /// QueryRow always returns a non-nil value. Errors are deferred until
  /// [Row]'s Scan method is called.
  /// If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
  /// Otherwise, [*Row.Scan] scans the first selected row and discards
  /// the rest.
  /// 
  /// QueryRow uses [context.Background] internally; to specify the context, use
  /// [DB.QueryRowContext].
  fn QueryRow(self: Ref<DB>, query: string, args: VarArgs<Unknown>) -> Ref<Row>

  /// QueryRowContext executes a query that is expected to return at most one row.
  /// QueryRowContext always returns a non-nil value. Errors are deferred until
  /// [Row]'s Scan method is called.
  /// If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
  /// Otherwise, [*Row.Scan] scans the first selected row and discards
  /// the rest.
  fn QueryRowContext(
    self: Ref<DB>,
    ctx: context.Context,
    query: string,
    args: VarArgs<Unknown>,
  ) -> Ref<Row>

  /// SetConnMaxIdleTime sets the maximum amount of time a connection may be idle.
  /// 
  /// Expired connections may be closed lazily before reuse.
  /// 
  /// If d <= 0, connections are not closed due to a connection's idle time.
  fn SetConnMaxIdleTime(self: Ref<DB>, d: time.Duration)

  /// SetConnMaxLifetime sets the maximum amount of time a connection may be reused.
  /// 
  /// Expired connections may be closed lazily before reuse.
  /// 
  /// If d <= 0, connections are not closed due to a connection's age.
  fn SetConnMaxLifetime(self: Ref<DB>, d: time.Duration)

  /// SetMaxIdleConns sets the maximum number of connections in the idle
  /// connection pool.
  /// 
  /// If MaxOpenConns is greater than 0 but less than the new MaxIdleConns,
  /// then the new MaxIdleConns will be reduced to match the MaxOpenConns limit.
  /// 
  /// If n <= 0, no idle connections are retained.
  /// 
  /// The default max idle connections is currently 2. This may change in
  /// a future release.
  fn SetMaxIdleConns(self: Ref<DB>, n: int)

  /// SetMaxOpenConns sets the maximum number of open connections to the database.
  /// 
  /// If MaxIdleConns is greater than 0 and the new MaxOpenConns is less than
  /// MaxIdleConns, then MaxIdleConns will be reduced to match the new
  /// MaxOpenConns limit.
  /// 
  /// If n <= 0, then there is no limit on the number of open connections.
  /// The default is 0 (unlimited).
  fn SetMaxOpenConns(self: Ref<DB>, n: int)

  /// Stats returns database statistics.
  fn Stats(self: Ref<DB>) -> DBStats
}

impl IsolationLevel {
  /// String returns the name of the transaction isolation level.
  fn String(self) -> string
}

impl<T> Null<T> {
  fn Scan(self: Ref<Null<T>>, value: Unknown) -> Result<(), error>

  fn Value(self) -> Result<driver.Value, error>
}

impl NullBool {
  /// Scan implements the [Scanner] interface.
  fn Scan(self: Ref<NullBool>, value: Unknown) -> Result<(), error>

  /// Value implements the [driver.Valuer] interface.
  fn Value(self) -> Result<driver.Value, error>
}

impl NullByte {
  /// Scan implements the [Scanner] interface.
  fn Scan(self: Ref<NullByte>, value: Unknown) -> Result<(), error>

  /// Value implements the [driver.Valuer] interface.
  fn Value(self) -> Result<driver.Value, error>
}

impl NullFloat64 {
  /// Scan implements the [Scanner] interface.
  fn Scan(self: Ref<NullFloat64>, value: Unknown) -> Result<(), error>

  /// Value implements the [driver.Valuer] interface.
  fn Value(self) -> Result<driver.Value, error>
}

impl NullInt16 {
  /// Scan implements the [Scanner] interface.
  fn Scan(self: Ref<NullInt16>, value: Unknown) -> Result<(), error>

  /// Value implements the [driver.Valuer] interface.
  fn Value(self) -> Result<driver.Value, error>
}

impl NullInt32 {
  /// Scan implements the [Scanner] interface.
  fn Scan(self: Ref<NullInt32>, value: Unknown) -> Result<(), error>

  /// Value implements the [driver.Valuer] interface.
  fn Value(self) -> Result<driver.Value, error>
}

impl NullInt64 {
  /// Scan implements the [Scanner] interface.
  fn Scan(self: Ref<NullInt64>, value: Unknown) -> Result<(), error>

  /// Value implements the [driver.Valuer] interface.
  fn Value(self) -> Result<driver.Value, error>
}

impl NullString {
  /// Scan implements the [Scanner] interface.
  fn Scan(self: Ref<NullString>, value: Unknown) -> Result<(), error>

  /// Value implements the [driver.Valuer] interface.
  fn Value(self) -> Result<driver.Value, error>
}

impl NullTime {
  /// Scan implements the [Scanner] interface.
  fn Scan(self: Ref<NullTime>, value: Unknown) -> Result<(), error>

  /// Value implements the [driver.Valuer] interface.
  fn Value(self) -> Result<driver.Value, error>
}

impl Row {
  /// Err provides a way for wrapping packages to check for
  /// query errors without calling [Row.Scan].
  /// Err returns the error, if any, that was encountered while running the query.
  /// If this error is not nil, this error will also be returned from [Row.Scan].
  fn Err(self: Ref<Row>) -> Option<error>

  /// Scan copies the columns from the matched row into the values
  /// pointed at by dest. See the documentation on [Rows.Scan] for details.
  /// If more than one row matches the query,
  /// Scan uses the first row and discards the rest. If no row matches
  /// the query, Scan returns [ErrNoRows].
  fn Scan(self: Ref<Row>, dest: VarArgs<Unknown>) -> Result<(), error>
}

impl Rows {
  /// Close closes the [Rows], preventing further enumeration. If [Rows.Next] is called
  /// and returns false and there are no further result sets,
  /// the [Rows] are closed automatically and it will suffice to check the
  /// result of [Rows.Err]. Close is idempotent and does not affect the result of [Rows.Err].
  #[allow(unused_result)]
  fn Close(self: Ref<Rows>) -> Result<(), error>

  /// ColumnTypes returns column information such as column type, length,
  /// and nullable. Some information may not be available from some drivers.
  fn ColumnTypes(self: Ref<Rows>) -> Result<Slice<Ref<ColumnType>>, error>

  /// Columns returns the column names.
  /// Columns returns an error if the rows are closed.
  fn Columns(self: Ref<Rows>) -> Result<Slice<string>, error>

  /// Err returns the error, if any, that was encountered during iteration.
  /// Err may be called after an explicit or implicit [Rows.Close].
  fn Err(self: Ref<Rows>) -> Option<error>

  /// Next prepares the next result row for reading with the [Rows.Scan] method. It
  /// returns true on success, or false if there is no next result row or an error
  /// happened while preparing it. [Rows.Err] should be consulted to distinguish between
  /// the two cases.
  /// 
  /// Every call to [Rows.Scan], even the first one, must be preceded by a call to [Rows.Next].
  fn Next(self: Ref<Rows>) -> bool

  /// NextResultSet prepares the next result set for reading. It reports whether
  /// there is further result sets, or false if there is no further result set
  /// or if there is an error advancing to it. The [Rows.Err] method should be consulted
  /// to distinguish between the two cases.
  /// 
  /// After calling NextResultSet, the [Rows.Next] method should always be called before
  /// scanning. If there are further result sets they may not have rows in the result
  /// set.
  fn NextResultSet(self: Ref<Rows>) -> bool

  /// Scan copies the columns in the current row into the values pointed
  /// at by dest. The number of values in dest must be the same as the
  /// number of columns in [Rows].
  /// 
  /// Scan converts columns read from the database into the following
  /// common Go types and special types provided by the sql package:
  /// 
  /// 	*string
  /// 	*[]byte
  /// 	*int, *int8, *int16, *int32, *int64
  /// 	*uint, *uint8, *uint16, *uint32, *uint64
  /// 	*bool
  /// 	*float32, *float64
  /// 	*interface{}
  /// 	*RawBytes
  /// 	*Rows (cursor value)
  /// 	any type implementing Scanner (see Scanner docs)
  /// 
  /// In the most simple case, if the type of the value from the source
  /// column is an integer, bool or string type T and dest is of type *T,
  /// Scan simply assigns the value through the pointer.
  /// 
  /// Scan also converts between string and numeric types, as long as no
  /// information would be lost. While Scan stringifies all numbers
  /// scanned from numeric database columns into *string, scans into
  /// numeric types are checked for overflow. For example, a float64 with
  /// value 300 or a string with value "300" can scan into a uint16, but
  /// not into a uint8, though float64(255) or "255" can scan into a
  /// uint8. One exception is that scans of some float64 numbers to
  /// strings may lose information when stringifying. In general, scan
  /// floating point columns into *float64.
  /// 
  /// If a dest argument has type *[]byte, Scan saves in that argument a
  /// copy of the corresponding data. The copy is owned by the caller and
  /// can be modified and held indefinitely. The copy can be avoided by
  /// using an argument of type [*RawBytes] instead; see the documentation
  /// for [RawBytes] for restrictions on its use.
  /// 
  /// If an argument has type *interface{}, Scan copies the value
  /// provided by the underlying driver without conversion. When scanning
  /// from a source value of type []byte to *interface{}, a copy of the
  /// slice is made and the caller owns the result.
  /// 
  /// Source values of type [time.Time] may be scanned into values of type
  /// *time.Time, *interface{}, *string, or *[]byte. When converting to
  /// the latter two, [time.RFC3339Nano] is used.
  /// 
  /// Source values of type bool may be scanned into types *bool,
  /// *interface{}, *string, *[]byte, or [*RawBytes].
  /// 
  /// For scanning into *bool, the source may be true, false, 1, 0, or
  /// string inputs parseable by [strconv.ParseBool].
  /// 
  /// Scan can also convert a cursor returned from a query, such as
  /// "select cursor(select * from my_table) from dual", into a
  /// [*Rows] value that can itself be scanned from. The parent
  /// select query will close any cursor [*Rows] if the parent [*Rows] is closed.
  /// 
  /// If any of the first arguments implementing [Scanner] returns an error,
  /// that error will be wrapped in the returned error.
  fn Scan(self: Ref<Rows>, dest: VarArgs<Unknown>) -> Result<(), error>
}

impl Stmt {
  /// Close closes the statement.
  #[allow(unused_result)]
  fn Close(self: Ref<Stmt>) -> Result<(), error>

  /// Exec executes a prepared statement with the given arguments and
  /// returns a [Result] summarizing the effect of the statement.
  /// 
  /// Exec uses [context.Background] internally; to specify the context, use
  /// [Stmt.ExecContext].
  fn Exec(self: Ref<Stmt>, args: VarArgs<Unknown>) -> Result<Result, error>

  /// ExecContext executes a prepared statement with the given arguments and
  /// returns a [Result] summarizing the effect of the statement.
  fn ExecContext(self: Ref<Stmt>, ctx: context.Context, args: VarArgs<Unknown>) -> Result<Result, error>

  /// Query executes a prepared query statement with the given arguments
  /// and returns the query results as a *Rows.
  /// 
  /// Query uses [context.Background] internally; to specify the context, use
  /// [Stmt.QueryContext].
  fn Query(self: Ref<Stmt>, args: VarArgs<Unknown>) -> Result<Ref<Rows>, error>

  /// QueryContext executes a prepared query statement with the given arguments
  /// and returns the query results as a [*Rows].
  fn QueryContext(self: Ref<Stmt>, ctx: context.Context, args: VarArgs<Unknown>) -> Result<Ref<Rows>, error>

  /// QueryRow executes a prepared query statement with the given arguments.
  /// If an error occurs during the execution of the statement, that error will
  /// be returned by a call to Scan on the returned [*Row], which is always non-nil.
  /// If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
  /// Otherwise, the [*Row.Scan] scans the first selected row and discards
  /// the rest.
  /// 
  /// Example usage:
  /// 
  /// 	var name string
  /// 	err := nameByUseridStmt.QueryRow(id).Scan(&name)
  /// 
  /// QueryRow uses [context.Background] internally; to specify the context, use
  /// [Stmt.QueryRowContext].
  fn QueryRow(self: Ref<Stmt>, args: VarArgs<Unknown>) -> Ref<Row>

  /// QueryRowContext executes a prepared query statement with the given arguments.
  /// If an error occurs during the execution of the statement, that error will
  /// be returned by a call to Scan on the returned [*Row], which is always non-nil.
  /// If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
  /// Otherwise, the [*Row.Scan] scans the first selected row and discards
  /// the rest.
  fn QueryRowContext(
    self: Ref<Stmt>,
    ctx: context.Context,
    args: VarArgs<Unknown>,
  ) -> Ref<Row>
}

impl Tx {
  /// Commit commits the transaction.
  fn Commit(self: Ref<Tx>) -> Result<(), error>

  /// Exec executes a query that doesn't return rows.
  /// For example: an INSERT and UPDATE.
  /// 
  /// Exec uses [context.Background] internally; to specify the context, use
  /// [Tx.ExecContext].
  fn Exec(self: Ref<Tx>, query: string, args: VarArgs<Unknown>) -> Result<Result, error>

  /// ExecContext executes a query that doesn't return rows.
  /// For example: an INSERT and UPDATE.
  fn ExecContext(
    self: Ref<Tx>,
    ctx: context.Context,
    query: string,
    args: VarArgs<Unknown>,
  ) -> Result<Result, error>

  /// Prepare creates a prepared statement for use within a transaction.
  /// 
  /// The returned statement operates within the transaction and will be closed
  /// when the transaction has been committed or rolled back.
  /// 
  /// To use an existing prepared statement on this transaction, see [Tx.Stmt].
  /// 
  /// Prepare uses [context.Background] internally; to specify the context, use
  /// [Tx.PrepareContext].
  fn Prepare(self: Ref<Tx>, query: string) -> Result<Ref<Stmt>, error>

  /// PrepareContext creates a prepared statement for use within a transaction.
  /// 
  /// The returned statement operates within the transaction and will be closed
  /// when the transaction has been committed or rolled back.
  /// 
  /// To use an existing prepared statement on this transaction, see [Tx.Stmt].
  /// 
  /// The provided context will be used for the preparation of the context, not
  /// for the execution of the returned statement. The returned statement
  /// will run in the transaction context.
  fn PrepareContext(self: Ref<Tx>, ctx: context.Context, query: string) -> Result<Ref<Stmt>, error>

  /// Query executes a query that returns rows, typically a SELECT.
  /// 
  /// Query uses [context.Background] internally; to specify the context, use
  /// [Tx.QueryContext].
  fn Query(self: Ref<Tx>, query: string, args: VarArgs<Unknown>) -> Result<Ref<Rows>, error>

  /// QueryContext executes a query that returns rows, typically a SELECT.
  fn QueryContext(
    self: Ref<Tx>,
    ctx: context.Context,
    query: string,
    args: VarArgs<Unknown>,
  ) -> Result<Ref<Rows>, error>

  /// QueryRow executes a query that is expected to return at most one row.
  /// QueryRow always returns a non-nil value. Errors are deferred until
  /// [Row]'s Scan method is called.
  /// If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
  /// Otherwise, the [*Row.Scan] scans the first selected row and discards
  /// the rest.
  /// 
  /// QueryRow uses [context.Background] internally; to specify the context, use
  /// [Tx.QueryRowContext].
  fn QueryRow(self: Ref<Tx>, query: string, args: VarArgs<Unknown>) -> Ref<Row>

  /// QueryRowContext executes a query that is expected to return at most one row.
  /// QueryRowContext always returns a non-nil value. Errors are deferred until
  /// [Row]'s Scan method is called.
  /// If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
  /// Otherwise, the [*Row.Scan] scans the first selected row and discards
  /// the rest.
  fn QueryRowContext(
    self: Ref<Tx>,
    ctx: context.Context,
    query: string,
    args: VarArgs<Unknown>,
  ) -> Ref<Row>

  /// Rollback aborts the transaction.
  fn Rollback(self: Ref<Tx>) -> Result<(), error>

  /// Stmt returns a transaction-specific prepared statement from
  /// an existing statement.
  /// 
  /// Example:
  /// 
  /// 	updateMoney, err := db.Prepare("UPDATE balance SET money=money+? WHERE id=?")
  /// 	...
  /// 	tx, err := db.Begin()
  /// 	...
  /// 	res, err := tx.Stmt(updateMoney).Exec(123.45, 98293203)
  /// 
  /// The returned statement operates within the transaction and will be closed
  /// when the transaction has been committed or rolled back.
  /// 
  /// Stmt uses [context.Background] internally; to specify the context, use
  /// [Tx.StmtContext].
  fn Stmt(self: Ref<Tx>, stmt: Ref<Stmt>) -> Ref<Stmt>

  /// StmtContext returns a transaction-specific prepared statement from
  /// an existing statement.
  /// 
  /// Example:
  /// 
  /// 	updateMoney, err := db.Prepare("UPDATE balance SET money=money+? WHERE id=?")
  /// 	...
  /// 	tx, err := db.Begin()
  /// 	...
  /// 	res, err := tx.StmtContext(ctx, updateMoney).Exec(123.45, 98293203)
  /// 
  /// The provided context is used for the preparation of the statement, not for the
  /// execution of the statement.
  /// 
  /// The returned statement operates within the transaction and will be closed
  /// when the transaction has been committed or rolled back.
  fn StmtContext(self: Ref<Tx>, ctx: context.Context, stmt: Ref<Stmt>) -> Ref<Stmt>
}
