// GENERATED — DO NOT EDIT

///|
/// [Upstream documentation](https://docs.gtk.org/gio/class.TlsDatabase.html).
pub type TlsDatabase

///|
pub(open) trait ITlsDatabase {
  fn as_tls_database(Self) -> TlsDatabase
  fn create_certificate_handle(Self, &ITlsCertificate) -> String? = _
  fn lookup_certificate_for_handle(
    Self,
    String,
    &ITlsInteraction?,
    TlsDatabaseLookupFlags,
    &ICancellable?,
  ) -> TlsCertificate? raise @glib.Error_ = _
  fn lookup_certificate_issuer(
    Self,
    &ITlsCertificate,
    &ITlsInteraction?,
    TlsDatabaseLookupFlags,
    &ICancellable?,
  ) -> TlsCertificate raise @glib.Error_ = _
  fn lookup_certificates_issued_by_finish(Self, &IAsyncResult) -> Array[
    TlsCertificate,
  ] raise @glib.Error_ = _
  fn verify_chain(
    Self,
    &ITlsCertificate,
    String,
    &ISocketConnectable?,
    &ITlsInteraction?,
    TlsDatabaseVerifyFlags,
    &ICancellable?,
  ) -> TlsCertificateFlags raise @glib.Error_ = _
  fn lookup_certificate_for_handle_async(
    Self,
    String,
    &ITlsInteraction?,
    TlsDatabaseLookupFlags,
    &ICancellable?,
    (Result[TlsCertificate, @glib.Error_]) -> Unit,
  ) -> Unit = _
  fn lookup_certificate_issuer_async(
    Self,
    &ITlsCertificate,
    &ITlsInteraction?,
    TlsDatabaseLookupFlags,
    &ICancellable?,
    (Result[TlsCertificate, @glib.Error_]) -> Unit,
  ) -> Unit = _
  fn verify_chain_async(
    Self,
    &ITlsCertificate,
    String,
    &ISocketConnectable?,
    &ITlsInteraction?,
    TlsDatabaseVerifyFlags,
    &ICancellable?,
    (Result[TlsCertificateFlags, @glib.Error_]) -> Unit,
  ) -> Unit = _
}

///|
pub impl ITlsDatabase for TlsDatabase with fn as_tls_database(self) {
  self
}

///|
#borrow(self_, certificate)
extern "c" fn moonbit_g_tls_database_create_certificate_handle(
  self_ : TlsDatabase,
  certificate : TlsCertificate,
) -> @glib.Nullable[Bytes] = "moonbit_g_tls_database_create_certificate_handle"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.TlsDatabase.create_certificate_handle.html).
pub fn TlsDatabase::create_certificate_handle(
  self : TlsDatabase,
  certificate : &ITlsCertificate,
) -> String? {
  let result = moonbit_g_tls_database_create_certificate_handle(
    self,
    certificate.as_tls_certificate(),
  )
  match result.to_option() {
    Some(bytes) => Some(@encoding/utf8.decode_lossy(bytes))
    None => None
  }
}

///|
#borrow(self_, handle, interaction, cancellable, error)
extern "c" fn moonbit_g_tls_database_lookup_certificate_for_handle(
  self_ : TlsDatabase,
  handle : Bytes,
  interaction : @glib.Nullable[TlsInteraction],
  flags : Int,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> @glib.Nullable[TlsCertificate] = "moonbit_g_tls_database_lookup_certificate_for_handle"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.TlsDatabase.lookup_certificate_for_handle.html).
pub fn TlsDatabase::lookup_certificate_for_handle(
  self : TlsDatabase,
  handle : String,
  interaction : &ITlsInteraction?,
  flags : TlsDatabaseLookupFlags,
  cancellable : &ICancellable?,
) -> TlsCertificate? raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let raw_result = moonbit_g_tls_database_lookup_certificate_for_handle(
    self,
    @encoding/utf8.encode(handle),
    match interaction {
      Some(v) => @glib.Nullable::some(v.as_tls_interaction())
      None => @glib.Nullable::null()
    },
    flags.to_int(),
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  let result = raw_result.to_option()
  result
}

///|
#borrow(self_, certificate, interaction, cancellable, error)
extern "c" fn moonbit_g_tls_database_lookup_certificate_issuer(
  self_ : TlsDatabase,
  certificate : TlsCertificate,
  interaction : @glib.Nullable[TlsInteraction],
  flags : Int,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> TlsCertificate = "moonbit_g_tls_database_lookup_certificate_issuer"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.TlsDatabase.lookup_certificate_issuer.html).
pub fn TlsDatabase::lookup_certificate_issuer(
  self : TlsDatabase,
  certificate : &ITlsCertificate,
  interaction : &ITlsInteraction?,
  flags : TlsDatabaseLookupFlags,
  cancellable : &ICancellable?,
) -> TlsCertificate raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_tls_database_lookup_certificate_issuer(
    self,
    certificate.as_tls_certificate(),
    match interaction {
      Some(v) => @glib.Nullable::some(v.as_tls_interaction())
      None => @glib.Nullable::null()
    },
    flags.to_int(),
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
#borrow(self_, result, error, result_2)
extern "c" fn moonbit_g_tls_database_lookup_certificates_issued_by_finish(
  self_ : TlsDatabase,
  result : AsyncResult,
  error : Ref[@glib.Nullable[@glib.Error_]],
  result_2 : Ref[FixedArray[TlsCertificate]],
) = "moonbit_g_tls_database_lookup_certificates_issued_by_finish"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.TlsDatabase.lookup_certificates_issued_by_finish.html).
pub fn TlsDatabase::lookup_certificates_issued_by_finish(
  self : TlsDatabase,
  result : &IAsyncResult,
) -> Array[TlsCertificate] raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result_ref : Ref[FixedArray[TlsCertificate]] = Ref([])
  moonbit_g_tls_database_lookup_certificates_issued_by_finish(
    self,
    result.as_async_result(),
    error_,
    result_ref,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  let values : Array[TlsCertificate] = Array::new(
    capacity=result_ref.val.length(),
  )
  for value in result_ref.val {
    values.push(value)
  }
  values
}

///|
#borrow(self_, chain, purpose, identity, interaction, cancellable, error)
extern "c" fn moonbit_g_tls_database_verify_chain(
  self_ : TlsDatabase,
  chain : TlsCertificate,
  purpose : Bytes,
  identity : @glib.Nullable[SocketConnectable],
  interaction : @glib.Nullable[TlsInteraction],
  flags : Int,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Int = "moonbit_g_tls_database_verify_chain"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.TlsDatabase.verify_chain.html).
pub fn TlsDatabase::verify_chain(
  self : TlsDatabase,
  chain : &ITlsCertificate,
  purpose : String,
  identity : &ISocketConnectable?,
  interaction : &ITlsInteraction?,
  flags : TlsDatabaseVerifyFlags,
  cancellable : &ICancellable?,
) -> TlsCertificateFlags raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result_ = moonbit_g_tls_database_verify_chain(
    self,
    chain.as_tls_certificate(),
    @encoding/utf8.encode(purpose),
    match identity {
      Some(v) => @glib.Nullable::some(v.as_socket_connectable())
      None => @glib.Nullable::null()
    },
    match interaction {
      Some(v) => @glib.Nullable::some(v.as_tls_interaction())
      None => @glib.Nullable::null()
    },
    flags.to_int(),
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  let result = TlsCertificateFlags::from_int(result_)
  result
}

///|
#borrow(self_, handle, interaction, cancellable)
extern "c" fn g_tls_database_lookup_certificate_for_handle_async(
  self_ : TlsDatabase,
  handle : Bytes,
  interaction : @glib.Nullable[TlsInteraction],
  flags : Int,
  cancellable : @glib.Nullable[Cancellable],
  function : FuncRef[
    (
      @glib.Nullable[TlsCertificate],
      @glib.Nullable[@glib.Error_],
      (@glib.Nullable[TlsCertificate], @glib.Nullable[@glib.Error_]) -> Unit,
    ) -> Unit,
  ],
  closure : (@glib.Nullable[TlsCertificate], @glib.Nullable[@glib.Error_]) -> Unit,
) = "moonbit_g_tls_database_lookup_certificate_for_handle_async"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.TlsDatabase.lookup_certificate_for_handle_async.html).
pub fn TlsDatabase::lookup_certificate_for_handle_async(
  self : TlsDatabase,
  handle : String,
  interaction : &ITlsInteraction?,
  flags : TlsDatabaseLookupFlags,
  cancellable : &ICancellable?,
  callback : (Result[TlsCertificate, @glib.Error_]) -> Unit,
) -> Unit {
  g_tls_database_lookup_certificate_for_handle_async(
    self,
    @encoding/utf8.encode(handle),
    match interaction {
      Some(v) => @glib.Nullable::some(v.as_tls_interaction())
      None => @glib.Nullable::null()
    },
    flags.to_int(),
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    fn(result, error, f) { f(result, error) },
    fn(result, error) {
      match error.to_option() {
        Some(e) => callback(Err(e))
        None =>
          match result.to_option() {
            Some(v) => callback(Ok(v))
            None => ()
          }
      }
    },
  )
}

///|
#borrow(self_, certificate, interaction, cancellable)
extern "c" fn g_tls_database_lookup_certificate_issuer_async(
  self_ : TlsDatabase,
  certificate : TlsCertificate,
  interaction : @glib.Nullable[TlsInteraction],
  flags : Int,
  cancellable : @glib.Nullable[Cancellable],
  function : FuncRef[
    (
      @glib.Nullable[TlsCertificate],
      @glib.Nullable[@glib.Error_],
      (@glib.Nullable[TlsCertificate], @glib.Nullable[@glib.Error_]) -> Unit,
    ) -> Unit,
  ],
  closure : (@glib.Nullable[TlsCertificate], @glib.Nullable[@glib.Error_]) -> Unit,
) = "moonbit_g_tls_database_lookup_certificate_issuer_async"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.TlsDatabase.lookup_certificate_issuer_async.html).
pub fn TlsDatabase::lookup_certificate_issuer_async(
  self : TlsDatabase,
  certificate : &ITlsCertificate,
  interaction : &ITlsInteraction?,
  flags : TlsDatabaseLookupFlags,
  cancellable : &ICancellable?,
  callback : (Result[TlsCertificate, @glib.Error_]) -> Unit,
) -> Unit {
  g_tls_database_lookup_certificate_issuer_async(
    self,
    certificate.as_tls_certificate(),
    match interaction {
      Some(v) => @glib.Nullable::some(v.as_tls_interaction())
      None => @glib.Nullable::null()
    },
    flags.to_int(),
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    fn(result, error, f) { f(result, error) },
    fn(result, error) {
      match error.to_option() {
        Some(e) => callback(Err(e))
        None =>
          match result.to_option() {
            Some(v) => callback(Ok(v))
            None => ()
          }
      }
    },
  )
}

///|
#borrow(self_, chain, purpose, identity, interaction, cancellable)
extern "c" fn g_tls_database_verify_chain_async(
  self_ : TlsDatabase,
  chain : TlsCertificate,
  purpose : Bytes,
  identity : @glib.Nullable[SocketConnectable],
  interaction : @glib.Nullable[TlsInteraction],
  flags : Int,
  cancellable : @glib.Nullable[Cancellable],
  function : FuncRef[
    (
      Int,
      @glib.Nullable[@glib.Error_],
      (Int, @glib.Nullable[@glib.Error_]) -> Unit,
    ) -> Unit,
  ],
  closure : (Int, @glib.Nullable[@glib.Error_]) -> Unit,
) = "moonbit_g_tls_database_verify_chain_async"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.TlsDatabase.verify_chain_async.html).
pub fn TlsDatabase::verify_chain_async(
  self : TlsDatabase,
  chain : &ITlsCertificate,
  purpose : String,
  identity : &ISocketConnectable?,
  interaction : &ITlsInteraction?,
  flags : TlsDatabaseVerifyFlags,
  cancellable : &ICancellable?,
  callback : (Result[TlsCertificateFlags, @glib.Error_]) -> Unit,
) -> Unit {
  g_tls_database_verify_chain_async(
    self,
    chain.as_tls_certificate(),
    @encoding/utf8.encode(purpose),
    match identity {
      Some(v) => @glib.Nullable::some(v.as_socket_connectable())
      None => @glib.Nullable::null()
    },
    match interaction {
      Some(v) => @glib.Nullable::some(v.as_tls_interaction())
      None => @glib.Nullable::null()
    },
    flags.to_int(),
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    fn(result, error, f) { f(result, error) },
    fn(result, error) {
      match error.to_option() {
        Some(e) => callback(Err(e))
        None => callback(Ok(TlsCertificateFlags::from_int(result)))
      }
    },
  )
}

///|
impl ITlsDatabase with fn create_certificate_handle(self, certificate) -> String? {
  self.as_tls_database().create_certificate_handle(certificate)
}

///|
impl ITlsDatabase with fn lookup_certificate_for_handle(
  self,
  handle,
  interaction,
  flags,
  cancellable,
) -> TlsCertificate? raise @glib.Error_ {
  self
  .as_tls_database()
  .lookup_certificate_for_handle(handle, interaction, flags, cancellable)
}

///|
impl ITlsDatabase with fn lookup_certificate_issuer(
  self,
  certificate,
  interaction,
  flags,
  cancellable,
) -> TlsCertificate raise @glib.Error_ {
  self
  .as_tls_database()
  .lookup_certificate_issuer(certificate, interaction, flags, cancellable)
}

///|
impl ITlsDatabase with fn lookup_certificates_issued_by_finish(self, result) -> Array[
  TlsCertificate,
] raise @glib.Error_ {
  self.as_tls_database().lookup_certificates_issued_by_finish(result)
}

///|
impl ITlsDatabase with fn verify_chain(
  self,
  chain,
  purpose,
  identity,
  interaction,
  flags,
  cancellable,
) -> TlsCertificateFlags raise @glib.Error_ {
  self
  .as_tls_database()
  .verify_chain(chain, purpose, identity, interaction, flags, cancellable)
}

///|
impl ITlsDatabase with fn lookup_certificate_for_handle_async(
  self,
  handle,
  interaction,
  flags,
  cancellable,
  callback,
) -> Unit {
  self
  .as_tls_database()
  .lookup_certificate_for_handle_async(
    handle, interaction, flags, cancellable, callback,
  )
}

///|
impl ITlsDatabase with fn lookup_certificate_issuer_async(
  self,
  certificate,
  interaction,
  flags,
  cancellable,
  callback,
) -> Unit {
  self
  .as_tls_database()
  .lookup_certificate_issuer_async(
    certificate, interaction, flags, cancellable, callback,
  )
}

///|
impl ITlsDatabase with fn verify_chain_async(
  self,
  chain,
  purpose,
  identity,
  interaction,
  flags,
  cancellable,
  callback,
) -> Unit {
  self
  .as_tls_database()
  .verify_chain_async(
    chain, purpose, identity, interaction, flags, cancellable, callback,
  )
}

///|
pub fn TlsDatabase::as_gobject_object(self : TlsDatabase) -> @gobject.Object = "%identity"

///|
pub impl @gobject.IObject for TlsDatabase with fn as_object(self) {
  self.as_gobject_object()
}