// GENERATED — DO NOT EDIT

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

///|
pub(open) trait IResolver {
  fn as_resolver(Self) -> Resolver
  fn get_timeout(Self) -> UInt = _
  fn lookup_by_address(Self, &IInetAddress, &ICancellable?) -> String raise @glib.Error_ = _
  fn lookup_by_name(Self, String, &ICancellable?) -> Array[InetAddress] raise @glib.Error_ = _
  fn lookup_by_name_finish(Self, &IAsyncResult) -> Array[InetAddress] raise @glib.Error_ = _
  fn lookup_by_name_with_flags(
    Self,
    String,
    ResolverNameLookupFlags,
    &ICancellable?,
  ) -> Array[InetAddress] raise @glib.Error_ = _
  fn lookup_by_name_with_flags_finish(Self, &IAsyncResult) -> Array[InetAddress] raise @glib.Error_ = _
  fn lookup_records(Self, String, ResolverRecordType, &ICancellable?) -> Array[
    @glib.Variant,
  ] raise @glib.Error_ = _
  fn lookup_records_finish(Self, &IAsyncResult) -> Array[@glib.Variant] raise @glib.Error_ = _
  fn set_default(Self) -> Unit = _
  fn set_timeout(Self, UInt) -> Unit = _
  fn connect_reload(Self, (Resolver) -> Unit) -> UInt64 = _
  fn lookup_by_address_async(
    Self,
    &IInetAddress,
    &ICancellable?,
    (Result[String, @glib.Error_]) -> Unit,
  ) -> Unit = _
}

///|
pub impl IResolver for Resolver with fn as_resolver(self) {
  self
}

///|
/// Implementation contract for Resolver.reload. Self is the retained MoonBit state; the second parameter is the invoked Resolver object.
pub(open) trait VResolverReload {
  fn reload(Self, Resolver) -> Unit
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/type_func.Resolver.get_default.html).
pub extern "c" fn Resolver::get_default() -> Resolver = "moonbit_g_resolver_get_default"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Resolver.get_timeout.html).
#borrow(self)
pub extern "c" fn Resolver::get_timeout(self : Resolver) -> UInt = "moonbit_g_resolver_get_timeout"

///|
#borrow(self_, address, cancellable, error)
extern "c" fn moonbit_g_resolver_lookup_by_address(
  self_ : Resolver,
  address : InetAddress,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bytes = "moonbit_g_resolver_lookup_by_address"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Resolver.lookup_by_address.html).
pub fn Resolver::lookup_by_address(
  self : Resolver,
  address : &IInetAddress,
  cancellable : &ICancellable?,
) -> String raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result_ = moonbit_g_resolver_lookup_by_address(
    self,
    address.as_inet_address(),
    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 = @encoding/utf8.decode_lossy(result_)
  result
}

///|
#borrow(self_, hostname, cancellable, error, result)
extern "c" fn moonbit_g_resolver_lookup_by_name(
  self_ : Resolver,
  hostname : Bytes,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
  result : Ref[FixedArray[InetAddress]],
) = "moonbit_g_resolver_lookup_by_name"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Resolver.lookup_by_name.html).
pub fn Resolver::lookup_by_name(
  self : Resolver,
  hostname : String,
  cancellable : &ICancellable?,
) -> Array[InetAddress] raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result_ref : Ref[FixedArray[InetAddress]] = Ref([])
  moonbit_g_resolver_lookup_by_name(
    self,
    @encoding/utf8.encode(hostname),
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    error_,
    result_ref,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  let values : Array[InetAddress] = Array::new(capacity=result_ref.val.length())
  for value in result_ref.val {
    values.push(value)
  }
  values
}

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

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

///|
#borrow(self_, hostname, cancellable, error, result)
extern "c" fn moonbit_g_resolver_lookup_by_name_with_flags(
  self_ : Resolver,
  hostname : Bytes,
  flags : Int,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
  result : Ref[FixedArray[InetAddress]],
) = "moonbit_g_resolver_lookup_by_name_with_flags"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Resolver.lookup_by_name_with_flags.html).
pub fn Resolver::lookup_by_name_with_flags(
  self : Resolver,
  hostname : String,
  flags : ResolverNameLookupFlags,
  cancellable : &ICancellable?,
) -> Array[InetAddress] raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result_ref : Ref[FixedArray[InetAddress]] = Ref([])
  moonbit_g_resolver_lookup_by_name_with_flags(
    self,
    @encoding/utf8.encode(hostname),
    flags.to_int(),
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    error_,
    result_ref,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  let values : Array[InetAddress] = Array::new(capacity=result_ref.val.length())
  for value in result_ref.val {
    values.push(value)
  }
  values
}

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

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

///|
#borrow(self_, rrname, cancellable, error, result)
extern "c" fn moonbit_g_resolver_lookup_records(
  self_ : Resolver,
  rrname : Bytes,
  record_type : ResolverRecordType,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
  result : Ref[FixedArray[@glib.Variant]],
) = "moonbit_g_resolver_lookup_records"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Resolver.lookup_records.html).
pub fn Resolver::lookup_records(
  self : Resolver,
  rrname : String,
  record_type : ResolverRecordType,
  cancellable : &ICancellable?,
) -> Array[@glib.Variant] raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result_ref : Ref[FixedArray[@glib.Variant]] = Ref([])
  moonbit_g_resolver_lookup_records(
    self,
    @encoding/utf8.encode(rrname),
    record_type,
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    error_,
    result_ref,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  let values : Array[@glib.Variant] = Array::new(
    capacity=result_ref.val.length(),
  )
  for value in result_ref.val {
    values.push(value)
  }
  values
}

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

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

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Resolver.set_default.html).
#borrow(self)
pub extern "c" fn Resolver::set_default(self : Resolver) = "moonbit_g_resolver_set_default"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Resolver.set_timeout.html).
#borrow(self)
pub extern "c" fn Resolver::set_timeout(self : Resolver, timeout_ms : UInt) = "moonbit_g_resolver_set_timeout"

///|
#borrow(instance)
extern "c" fn g_resolver_connect_reload(
  instance : Resolver,
  function : FuncRef[(Resolver, (Resolver) -> Unit) -> Unit],
  closure : (Resolver) -> Unit,
) -> UInt64 = "moonbit_g_resolver_connect_reload"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/signal.Resolver.reload.html).
pub fn Resolver::connect_reload(
  self : Resolver,
  f : (Resolver) -> Unit,
) -> UInt64 {
  g_resolver_connect_reload(self, fn(instance_, f) { f(instance_) }, f)
}

///|
#borrow(self_, address, cancellable)
extern "c" fn g_resolver_lookup_by_address_async(
  self_ : Resolver,
  address : InetAddress,
  cancellable : @glib.Nullable[Cancellable],
  function : FuncRef[
    (
      @glib.Nullable[Bytes],
      @glib.Nullable[@glib.Error_],
      (@glib.Nullable[Bytes], @glib.Nullable[@glib.Error_]) -> Unit,
    ) -> Unit,
  ],
  closure : (@glib.Nullable[Bytes], @glib.Nullable[@glib.Error_]) -> Unit,
) = "moonbit_g_resolver_lookup_by_address_async"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Resolver.lookup_by_address_async.html).
pub fn Resolver::lookup_by_address_async(
  self : Resolver,
  address : &IInetAddress,
  cancellable : &ICancellable?,
  callback : (Result[String, @glib.Error_]) -> Unit,
) -> Unit {
  g_resolver_lookup_by_address_async(
    self,
    address.as_inet_address(),
    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(bytes) => callback(Ok(@encoding/utf8.decode_lossy(bytes)))
            None => ()
          }
      }
    },
  )
}

///|
impl IResolver with fn get_timeout(self) -> UInt {
  self.as_resolver().get_timeout()
}

///|
impl IResolver with fn lookup_by_address(self, address, cancellable) -> String raise @glib.Error_ {
  self.as_resolver().lookup_by_address(address, cancellable)
}

///|
impl IResolver with fn lookup_by_name(self, hostname, cancellable) -> Array[
  InetAddress,
] raise @glib.Error_ {
  self.as_resolver().lookup_by_name(hostname, cancellable)
}

///|
impl IResolver with fn lookup_by_name_finish(self, result) -> Array[InetAddress] raise @glib.Error_ {
  self.as_resolver().lookup_by_name_finish(result)
}

///|
impl IResolver with fn lookup_by_name_with_flags(
  self,
  hostname,
  flags,
  cancellable,
) -> Array[InetAddress] raise @glib.Error_ {
  self.as_resolver().lookup_by_name_with_flags(hostname, flags, cancellable)
}

///|
impl IResolver with fn lookup_by_name_with_flags_finish(self, result) -> Array[
  InetAddress,
] raise @glib.Error_ {
  self.as_resolver().lookup_by_name_with_flags_finish(result)
}

///|
impl IResolver with fn lookup_records(self, rrname, record_type, cancellable) -> Array[
  @glib.Variant,
] raise @glib.Error_ {
  self.as_resolver().lookup_records(rrname, record_type, cancellable)
}

///|
impl IResolver with fn lookup_records_finish(self, result) -> Array[
  @glib.Variant,
] raise @glib.Error_ {
  self.as_resolver().lookup_records_finish(result)
}

///|
impl IResolver with fn set_default(self) -> Unit {
  self.as_resolver().set_default()
}

///|
impl IResolver with fn set_timeout(self, timeout_ms) -> Unit {
  self.as_resolver().set_timeout(timeout_ms)
}

///|
impl IResolver with fn connect_reload(self, f) -> UInt64 {
  self.as_resolver().connect_reload(f)
}

///|
impl IResolver with fn lookup_by_address_async(
  self,
  address,
  cancellable,
  callback,
) -> Unit {
  self.as_resolver().lookup_by_address_async(address, cancellable, callback)
}

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

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