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

import "go:context"
import "go:reflect"

/// IsScanValue is equivalent to [IsValue].
/// It exists for compatibility.
pub fn IsScanValue(v: Unknown) -> bool

/// IsValue reports whether v is a valid [Value] parameter type.
pub fn IsValue(v: Unknown) -> bool

/// ColumnConverter may be optionally implemented by [Stmt] if the
/// statement is aware of its own columns' types and can convert from
/// any type to a driver [Value].
/// 
/// Deprecated: Drivers should implement [NamedValueChecker].
pub interface ColumnConverter {
  fn ColumnConverter(idx: int) -> Option<ValueConverter>
}

/// Conn is a connection to a database. It is not used concurrently
/// by multiple goroutines.
/// 
/// Conn is assumed to be stateful.
pub interface Conn {
  fn Begin() -> Result<Tx, error>
  fn Close() -> Result<(), error>
  fn Prepare(query: string) -> Result<Stmt, error>
}

/// ConnBeginTx enhances the [Conn] interface with context and [TxOptions].
pub interface ConnBeginTx {
  fn BeginTx(ctx: context.Context, opts: TxOptions) -> Result<Tx, error>
}

/// ConnPrepareContext enhances the [Conn] interface with context.
pub interface ConnPrepareContext {
  fn PrepareContext(ctx: context.Context, query: string) -> Result<Stmt, error>
}

/// A Connector represents a driver in a fixed configuration
/// and can create any number of equivalent Conns for use
/// by multiple goroutines.
/// 
/// A Connector can be passed to [database/sql.OpenDB], to allow drivers
/// to implement their own [database/sql.DB] constructors, or returned by
/// [DriverContext]'s OpenConnector method, to allow drivers
/// access to context and to avoid repeated parsing of driver
/// configuration.
/// 
/// If a Connector implements [io.Closer], the [database/sql.DB.Close]
/// method will call the Close method and return error (if any).
pub interface Connector {
  fn Connect(ctx: context.Context) -> Result<Conn, error>
  fn Driver() -> Option<Driver>
}

/// Driver is the interface that must be implemented by a database
/// driver.
/// 
/// Database drivers may implement [DriverContext] for access
/// to contexts and to parse the name only once for a pool of connections,
/// instead of once per connection.
pub interface Driver {
  fn Open(name: string) -> Result<Conn, error>
}

/// If a [Driver] implements DriverContext, then [database/sql.DB] will call
/// OpenConnector to obtain a [Connector] and then invoke
/// that [Connector]'s Connect method to obtain each needed connection,
/// instead of invoking the [Driver]'s Open method for each connection.
/// The two-step sequence allows drivers to parse the name just once
/// and also provides access to per-[Conn] contexts.
pub interface DriverContext {
  fn OpenConnector(name: string) -> Result<Connector, error>
}

/// Execer is an optional interface that may be implemented by a [Conn].
/// 
/// If a [Conn] implements neither [ExecerContext] nor [Execer],
/// the [database/sql.DB.Exec] will first prepare a query, execute the statement,
/// and then close the statement.
/// 
/// Exec may return [ErrSkip].
/// 
/// Deprecated: Drivers should implement [ExecerContext] instead.
pub interface Execer {
  fn Exec(query: string, args: Slice<Value>) -> Result<Result, error>
}

/// ExecerContext is an optional interface that may be implemented by a [Conn].
/// 
/// If a [Conn] does not implement [ExecerContext], the [database/sql.DB.Exec]
/// will fall back to [Execer]; if the Conn does not implement Execer either,
/// [database/sql.DB.Exec] will first prepare a query, execute the statement, and then
/// close the statement.
/// 
/// ExecContext may return [ErrSkip].
/// 
/// ExecContext must honor the context timeout and return when the context is canceled.
pub interface ExecerContext {
  fn ExecContext(ctx: context.Context, query: string, args: Slice<NamedValue>) -> Result<Result, error>
}

/// IsolationLevel is the transaction isolation level stored in [TxOptions].
/// 
/// This type should be considered identical to [database/sql.IsolationLevel] along
/// with any values defined on it.
pub struct IsolationLevel(int)

/// NamedValue holds both the value name and value.
pub struct NamedValue {
  pub Name: string,
  pub Ordinal: int,
  pub Value: Value,
}

/// NamedValueChecker may be optionally implemented by [Conn] or [Stmt]. It provides
/// the driver more control to handle Go and database types beyond the default
/// [Value] types allowed.
/// 
/// The [database/sql] package checks for value checkers in the following order,
/// stopping at the first found match: Stmt.NamedValueChecker, Conn.NamedValueChecker,
/// Stmt.ColumnConverter, [DefaultParameterConverter].
/// 
/// If CheckNamedValue returns [ErrRemoveArgument], the [NamedValue] will not be included in
/// the final query arguments. This may be used to pass special options to
/// the query itself.
/// 
/// If [ErrSkip] is returned the column converter error checking
/// path is used for the argument. Drivers may wish to return [ErrSkip] after
/// they have exhausted their own special cases.
pub interface NamedValueChecker {
  fn CheckNamedValue(namedValue: Ref<NamedValue>) -> Result<(), error>
}

/// NotNull is a type that implements [ValueConverter] by disallowing nil
/// values but otherwise delegating to another [ValueConverter].
pub struct NotNull {
  pub Converter: Option<ValueConverter>,
}

/// Null is a type that implements [ValueConverter] by allowing nil
/// values but otherwise delegating to another [ValueConverter].
pub struct Null {
  pub Converter: Option<ValueConverter>,
}

/// Pinger is an optional interface that may be implemented by a [Conn].
/// 
/// If a [Conn] does not implement Pinger, the [database/sql.DB.Ping] and
/// [database/sql.DB.PingContext] will check if there is at least one [Conn] available.
/// 
/// If Conn.Ping returns [ErrBadConn], [database/sql.DB.Ping] and [database/sql.DB.PingContext] will remove
/// the [Conn] from pool.
pub interface Pinger {
  fn Ping(ctx: context.Context) -> Result<(), error>
}

/// Queryer is an optional interface that may be implemented by a [Conn].
/// 
/// If a [Conn] implements neither [QueryerContext] nor [Queryer],
/// the [database/sql.DB.Query] will first prepare a query, execute the statement,
/// and then close the statement.
/// 
/// Query may return [ErrSkip].
/// 
/// Deprecated: Drivers should implement [QueryerContext] instead.
pub interface Queryer {
  fn Query(query: string, args: Slice<Value>) -> Result<Rows, error>
}

/// QueryerContext is an optional interface that may be implemented by a [Conn].
/// 
/// If a [Conn] does not implement QueryerContext, the [database/sql.DB.Query]
/// will fall back to [Queryer]; if the [Conn] does not implement [Queryer] either,
/// [database/sql.DB.Query] will first prepare a query, execute the statement, and then
/// close the statement.
/// 
/// QueryContext may return [ErrSkip].
/// 
/// QueryContext must honor the context timeout and return when the context is canceled.
pub interface QueryerContext {
  fn QueryContext(ctx: context.Context, query: string, args: Slice<NamedValue>) -> Result<Rows, error>
}

/// Result is the result of a query execution.
pub interface Result {
  fn LastInsertId() -> Result<int64, error>
  fn RowsAffected() -> Result<int64, error>
}

/// Rows is an iterator over an executed query's results.
pub interface Rows {
  fn Close() -> Result<(), error>
  fn Columns() -> Slice<string>
  fn Next(mut dest: Slice<Value>) -> Result<(), error>
}

/// RowsAffected implements [Result] for an INSERT or UPDATE operation
/// which mutates a number of rows.
pub struct RowsAffected(int64)

/// RowsColumnTypeDatabaseTypeName may be implemented by [Rows]. It should return the
/// database system type name without the length. Type names should be uppercase.
/// Examples of returned types: "VARCHAR", "NVARCHAR", "VARCHAR2", "CHAR", "TEXT",
/// "DECIMAL", "SMALLINT", "INT", "BIGINT", "BOOL", "[]BIGINT", "JSONB", "XML",
/// "TIMESTAMP".
pub interface RowsColumnTypeDatabaseTypeName {
  fn Close() -> Result<(), error>
  fn ColumnTypeDatabaseTypeName(index: int) -> string
  fn Columns() -> Slice<string>
  fn Next(mut dest: Slice<Value>) -> Result<(), error>
}

/// RowsColumnTypeLength may be implemented by [Rows]. It should return the length
/// of the column type if the column is a variable length type. If the column is
/// not a variable length type ok should return false.
/// If length is not limited other than system limits, it should return [math.MaxInt64].
/// The following are examples of returned values for various types:
/// 
/// 	TEXT          (math.MaxInt64, true)
/// 	varchar(10)   (10, true)
/// 	nvarchar(10)  (10, true)
/// 	decimal       (0, false)
/// 	int           (0, false)
/// 	bytea(30)     (30, true)
pub interface RowsColumnTypeLength {
  fn Close() -> Result<(), error>
  fn ColumnTypeLength(index: int) -> Option<int64>
  fn Columns() -> Slice<string>
  fn Next(mut dest: Slice<Value>) -> Result<(), error>
}

/// RowsColumnTypeNullable may be implemented by [Rows]. The nullable value should
/// be true if it is known the column may be null, or false if the column is known
/// to be not nullable.
/// If the column nullability is unknown, ok should be false.
pub interface RowsColumnTypeNullable {
  fn Close() -> Result<(), error>
  fn ColumnTypeNullable(index: int) -> Option<bool>
  fn Columns() -> Slice<string>
  fn Next(mut dest: Slice<Value>) -> Result<(), error>
}

/// RowsColumnTypePrecisionScale may be implemented by [Rows]. It should return
/// the precision and scale for decimal types. If not applicable, ok should be false.
/// The following are examples of returned values for various types:
/// 
/// 	decimal(38, 4)    (38, 4, true)
/// 	int               (0, 0, false)
/// 	decimal           (math.MaxInt64, math.MaxInt64, true)
pub interface RowsColumnTypePrecisionScale {
  fn Close() -> Result<(), error>
  fn ColumnTypePrecisionScale(index: int) -> Option<(int64, int64)>
  fn Columns() -> Slice<string>
  fn Next(mut dest: Slice<Value>) -> Result<(), error>
}

/// RowsColumnTypeScanType may be implemented by [Rows]. It should return
/// the value type that can be used to scan types into. For example, the database
/// column type "bigint" this should return "[reflect.TypeOf](int64(0))".
pub interface RowsColumnTypeScanType {
  fn Close() -> Result<(), error>
  fn ColumnTypeScanType(index: int) -> Option<reflect.Type>
  fn Columns() -> Slice<string>
  fn Next(mut dest: Slice<Value>) -> Result<(), error>
}

/// RowsNextResultSet extends the [Rows] interface by providing a way to signal
/// the driver to advance to the next result set.
pub interface RowsNextResultSet {
  fn Close() -> Result<(), error>
  fn Columns() -> Slice<string>
  fn HasNextResultSet() -> bool
  fn Next(mut dest: Slice<Value>) -> Result<(), error>
  fn NextResultSet() -> Result<(), error>
}

/// SessionResetter may be implemented by [Conn] to allow drivers to reset the
/// session state associated with the connection and to signal a bad connection.
pub interface SessionResetter {
  fn ResetSession(ctx: context.Context) -> Result<(), error>
}

/// Stmt is a prepared statement. It is bound to a [Conn] and not
/// used by multiple goroutines concurrently.
pub interface Stmt {
  fn Close() -> Result<(), error>
  fn Exec(args: Slice<Value>) -> Result<Result, error>
  fn NumInput() -> int
  fn Query(args: Slice<Value>) -> Result<Rows, error>
}

/// StmtExecContext enhances the [Stmt] interface by providing Exec with context.
pub interface StmtExecContext {
  fn ExecContext(ctx: context.Context, args: Slice<NamedValue>) -> Result<Result, error>
}

/// StmtQueryContext enhances the [Stmt] interface by providing Query with context.
pub interface StmtQueryContext {
  fn QueryContext(ctx: context.Context, args: Slice<NamedValue>) -> Result<Rows, error>
}

/// Tx is a transaction.
pub interface Tx {
  fn Commit() -> Result<(), error>
  fn Rollback() -> Result<(), error>
}

/// TxOptions holds the transaction options.
/// 
/// This type should be considered identical to [database/sql.TxOptions].
pub struct TxOptions {
  pub Isolation: IsolationLevel,
  pub ReadOnly: bool,
}

/// Validator may be implemented by [Conn] to allow drivers to
/// signal if a connection is valid or if it should be discarded.
/// 
/// If implemented, drivers may return the underlying error from queries,
/// even if the connection should be discarded by the connection pool.
pub interface Validator {
  fn IsValid() -> bool
}

/// Value is a value that drivers must be able to handle.
/// It is either nil, a type handled by a database driver's [NamedValueChecker]
/// interface, or an instance of one of these types:
/// 
/// 	int64
/// 	float64
/// 	bool
/// 	[]byte
/// 	string
/// 	time.Time
/// 
/// If the driver supports cursors, a returned Value may also implement the [Rows] interface
/// in this package. This is used, for example, when a user selects a cursor
/// such as "select cursor(select * from my_table) from dual". If the [Rows]
/// from the select is closed, the cursor [Rows] will also be closed.
pub type Value = Unknown

/// ValueConverter is the interface providing the ConvertValue method.
/// 
/// Various implementations of ValueConverter are provided by the
/// driver package to provide consistent implementations of conversions
/// between drivers. The ValueConverters have several uses:
/// 
///   - converting from the [Value] types as provided by the sql package
///     into a database table's specific column type and making sure it
///     fits, such as making sure a particular int64 fits in a
///     table's uint16 column.
/// 
///   - converting a value as given from the database into one of the
///     driver [Value] types.
/// 
///   - by the [database/sql] package, for converting from a driver's [Value] type
///     to a user's type in a scan.
pub interface ValueConverter {
  fn ConvertValue(v: Unknown) -> Result<Value, error>
}

/// Valuer is the interface providing the Value method.
/// 
/// Errors returned by the [Value] method are wrapped by the database/sql package.
/// This allows callers to use [errors.Is] for precise error handling after operations
/// like [database/sql.Query], [database/sql.Exec], or [database/sql.QueryRow].
/// 
/// Types implementing Valuer interface are able to convert
/// themselves to a driver [Value].
pub interface Valuer {
  fn Value() -> Result<Value, error>
}

pub var Bool: ()

pub var DefaultParameterConverter: ()

/// ErrBadConn should be returned by a driver to signal to the [database/sql]
/// package that a driver.[Conn] is in a bad state (such as the server
/// having earlier closed the connection) and the [database/sql] package should
/// retry on a new connection.
/// 
/// To prevent duplicate operations, ErrBadConn should NOT be returned
/// if there's a possibility that the database server might have
/// performed the operation. Even if the server sends back an error,
/// you shouldn't return ErrBadConn.
/// 
/// Errors will be checked using [errors.Is]. An error may
/// wrap ErrBadConn or implement the Is(error) bool method.
pub var ErrBadConn: error

/// ErrRemoveArgument may be returned from [NamedValueChecker] to instruct the
/// [database/sql] package to not pass the argument to the driver query interface.
/// Return when accepting query specific options or structures that aren't
/// SQL query arguments.
pub var ErrRemoveArgument: error

/// ErrSkip may be returned by some optional interfaces' methods to
/// indicate at runtime that the fast path is unavailable and the sql
/// package should continue as if the optional interface was not
/// implemented. ErrSkip is only supported where explicitly
/// documented.
pub var ErrSkip: error

pub var Int32: ()

pub var ResultNoRows: ()

pub var String: ()

impl NotNull {
  fn ConvertValue(self, v: Unknown) -> Result<Value, error>
}

impl Null {
  fn ConvertValue(self, v: Unknown) -> Result<Value, error>
}

impl RowsAffected {
  fn LastInsertId(self) -> Result<int64, error>

  fn RowsAffected(self) -> Result<int64, error>
}
