// GENERATED — DO NOT EDIT

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

///|
pub(open) trait INetworkMonitor {
  fn as_network_monitor(Self) -> NetworkMonitor
  fn can_reach(Self, &ISocketConnectable, &ICancellable?) -> Bool raise @glib.Error_ = _
  fn get_connectivity(Self) -> NetworkConnectivity = _
  fn get_network_available(Self) -> Bool = _
  fn get_network_metered(Self) -> Bool = _
  fn can_reach_async(
    Self,
    &ISocketConnectable,
    &ICancellable?,
    (Result[Bool, @glib.Error_]) -> Unit,
  ) -> Unit = _
}

///|
pub impl INetworkMonitor for NetworkMonitor with fn as_network_monitor(self) {
  self
}

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

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

///|
#borrow(self_, connectable, cancellable, error)
extern "c" fn moonbit_g_network_monitor_can_reach(
  self_ : NetworkMonitor,
  connectable : SocketConnectable,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_network_monitor_can_reach"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.NetworkMonitor.can_reach.html).
pub fn NetworkMonitor::can_reach(
  self : NetworkMonitor,
  connectable : &ISocketConnectable,
  cancellable : &ICancellable?,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_network_monitor_can_reach(
    self,
    connectable.as_socket_connectable(),
    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
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.NetworkMonitor.get_connectivity.html).
#borrow(self)
pub extern "c" fn NetworkMonitor::get_connectivity(
  self : NetworkMonitor,
) -> NetworkConnectivity = "moonbit_g_network_monitor_get_connectivity"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.NetworkMonitor.get_network_available.html).
#borrow(self)
pub extern "c" fn NetworkMonitor::get_network_available(
  self : NetworkMonitor,
) -> Bool = "moonbit_g_network_monitor_get_network_available"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.NetworkMonitor.get_network_metered.html).
#borrow(self)
pub extern "c" fn NetworkMonitor::get_network_metered(
  self : NetworkMonitor,
) -> Bool = "moonbit_g_network_monitor_get_network_metered"

///|
#borrow(self_, connectable, cancellable)
extern "c" fn g_network_monitor_can_reach_async(
  self_ : NetworkMonitor,
  connectable : SocketConnectable,
  cancellable : @glib.Nullable[Cancellable],
  function : FuncRef[
    (
      Bool,
      @glib.Nullable[@glib.Error_],
      (Bool, @glib.Nullable[@glib.Error_]) -> Unit,
    ) -> Unit,
  ],
  closure : (Bool, @glib.Nullable[@glib.Error_]) -> Unit,
) = "moonbit_g_network_monitor_can_reach_async"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.NetworkMonitor.can_reach_async.html).
pub fn NetworkMonitor::can_reach_async(
  self : NetworkMonitor,
  connectable : &ISocketConnectable,
  cancellable : &ICancellable?,
  callback : (Result[Bool, @glib.Error_]) -> Unit,
) -> Unit {
  g_network_monitor_can_reach_async(
    self,
    connectable.as_socket_connectable(),
    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(result))
      }
    },
  )
}

///|
impl INetworkMonitor with fn can_reach(self, connectable, cancellable) -> Bool raise @glib.Error_ {
  self.as_network_monitor().can_reach(connectable, cancellable)
}

///|
impl INetworkMonitor with fn get_connectivity(self) -> NetworkConnectivity {
  self.as_network_monitor().get_connectivity()
}

///|
impl INetworkMonitor with fn get_network_available(self) -> Bool {
  self.as_network_monitor().get_network_available()
}

///|
impl INetworkMonitor with fn get_network_metered(self) -> Bool {
  self.as_network_monitor().get_network_metered()
}

///|
impl INetworkMonitor with fn can_reach_async(
  self,
  connectable,
  cancellable,
  callback,
) -> Unit {
  self.as_network_monitor().can_reach_async(connectable, cancellable, callback)
}

///|
pub fn NetworkMonitor::as_initable(self : NetworkMonitor) -> Initable = "%identity"

///|
pub impl IInitable for NetworkMonitor with fn as_initable(self) {
  self.as_initable()
}