// GENERATED — DO NOT EDIT

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

///|
pub(open) trait ISocket {
  fn as_socket(Self) -> Socket
  fn accept(Self, &ICancellable?) -> Socket raise @glib.Error_ = _
  fn bind(Self, &ISocketAddress, Bool) -> Bool raise @glib.Error_ = _
  fn check_connect_result(Self) -> Bool raise @glib.Error_ = _
  fn close(Self) -> Bool raise @glib.Error_ = _
  fn condition_check(Self, @glib.IOCondition) -> @glib.IOCondition = _
  fn condition_timed_wait(Self, @glib.IOCondition, Int64, &ICancellable?) -> Bool raise @glib.Error_ = _
  fn condition_wait(Self, @glib.IOCondition, &ICancellable?) -> Bool raise @glib.Error_ = _
  fn connect(Self, &ISocketAddress, &ICancellable?) -> Bool raise @glib.Error_ = _
  fn connection_factory_create_connection(Self) -> SocketConnection = _
  fn get_available_bytes(Self) -> Int64 = _
  fn get_blocking(Self) -> Bool = _
  fn get_broadcast(Self) -> Bool = _
  fn get_credentials(Self) -> Credentials raise @glib.Error_ = _
  fn get_family(Self) -> SocketFamily = _
  fn get_fd(Self) -> Int = _
  fn get_keepalive(Self) -> Bool = _
  fn get_listen_backlog(Self) -> Int = _
  fn get_local_address(Self) -> SocketAddress raise @glib.Error_ = _
  fn get_multicast_loopback(Self) -> Bool = _
  fn get_multicast_ttl(Self) -> UInt = _
  fn get_option(Self, Int, Int) -> (Bool, Int) raise @glib.Error_ = _
  fn get_remote_address(Self) -> SocketAddress raise @glib.Error_ = _
  fn get_socket_type(Self) -> SocketType = _
  fn get_timeout(Self) -> UInt = _
  fn get_ttl(Self) -> UInt = _
  fn is_closed(Self) -> Bool = _
  fn is_connected(Self) -> Bool = _
  fn join_multicast_group(Self, &IInetAddress, Bool, String?) -> Bool raise @glib.Error_ = _
  fn join_multicast_group_ssm(Self, &IInetAddress, &IInetAddress?, String?) -> Bool raise @glib.Error_ = _
  fn leave_multicast_group(Self, &IInetAddress, Bool, String?) -> Bool raise @glib.Error_ = _
  fn leave_multicast_group_ssm(Self, &IInetAddress, &IInetAddress?, String?) -> Bool raise @glib.Error_ = _
  fn listen(Self) -> Bool raise @glib.Error_ = _
  fn receive_bytes(Self, UInt64, Int64, &ICancellable?) -> Bytes raise @glib.Error_ = _
  fn set_blocking(Self, Bool) -> Unit = _
  fn set_broadcast(Self, Bool) -> Unit = _
  fn set_keepalive(Self, Bool) -> Unit = _
  fn set_listen_backlog(Self, Int) -> Unit = _
  fn set_multicast_loopback(Self, Bool) -> Unit = _
  fn set_multicast_ttl(Self, UInt) -> Unit = _
  fn set_option(Self, Int, Int, Int) -> Bool raise @glib.Error_ = _
  fn set_timeout(Self, UInt) -> Unit = _
  fn set_ttl(Self, UInt) -> Unit = _
  fn shutdown(Self, Bool, Bool) -> Bool raise @glib.Error_ = _
  fn speaks_ipv4(Self) -> Bool = _
}

///|
pub impl ISocket for Socket with fn as_socket(self) {
  self
}

///|
#borrow(error)
extern "c" fn moonbit_g_socket_new_from_fd(
  fd : Int,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Socket = "moonbit_g_socket_new_from_fd"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/ctor.Socket.new_from_fd.html).
pub fn Socket::new_from_fd(fd : Int) -> Socket raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_new_from_fd(fd, error_)
  match error_.val.to_option() {
    Some(e) => raise e
    None => result
  }
}

///|
#borrow(self_, cancellable, error)
extern "c" fn moonbit_g_socket_accept(
  self_ : Socket,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Socket = "moonbit_g_socket_accept"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.accept.html).
pub fn Socket::accept(
  self : Socket,
  cancellable : &ICancellable?,
) -> Socket raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_accept(
    self,
    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_, address, error)
extern "c" fn moonbit_g_socket_bind(
  self_ : Socket,
  address : SocketAddress,
  allow_reuse : Bool,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_bind"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.bind.html).
pub fn Socket::bind(
  self : Socket,
  address : &ISocketAddress,
  allow_reuse : Bool,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_bind(
    self,
    address.as_socket_address(),
    allow_reuse,
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
#borrow(self_, error)
extern "c" fn moonbit_g_socket_check_connect_result(
  self_ : Socket,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_check_connect_result"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.check_connect_result.html).
pub fn Socket::check_connect_result(self : Socket) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_check_connect_result(self, error_)
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
#borrow(self_, error)
extern "c" fn moonbit_g_socket_close(
  self_ : Socket,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_close"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.close.html).
pub fn Socket::close(self : Socket) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_close(self, error_)
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
#borrow(self_)
extern "c" fn moonbit_g_socket_condition_check(
  self_ : Socket,
  condition : Int,
) -> Int = "moonbit_g_socket_condition_check"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.condition_check.html).
pub fn Socket::condition_check(
  self : Socket,
  condition : @glib.IOCondition,
) -> @glib.IOCondition {
  @glib.IOCondition::from_int(
    moonbit_g_socket_condition_check(self, condition.to_int()),
  )
}

///|
#borrow(self_, cancellable, error)
extern "c" fn moonbit_g_socket_condition_timed_wait(
  self_ : Socket,
  condition : Int,
  timeout_us : Int64,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_condition_timed_wait"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.condition_timed_wait.html).
pub fn Socket::condition_timed_wait(
  self : Socket,
  condition : @glib.IOCondition,
  timeout_us : Int64,
  cancellable : &ICancellable?,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_condition_timed_wait(
    self,
    condition.to_int(),
    timeout_us,
    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_, cancellable, error)
extern "c" fn moonbit_g_socket_condition_wait(
  self_ : Socket,
  condition : Int,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_condition_wait"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.condition_wait.html).
pub fn Socket::condition_wait(
  self : Socket,
  condition : @glib.IOCondition,
  cancellable : &ICancellable?,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_condition_wait(
    self,
    condition.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_, address, cancellable, error)
extern "c" fn moonbit_g_socket_connect(
  self_ : Socket,
  address : SocketAddress,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_connect"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.connect.html).
pub fn Socket::connect(
  self : Socket,
  address : &ISocketAddress,
  cancellable : &ICancellable?,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_connect(
    self,
    address.as_socket_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 => ()
  }
  result
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.connection_factory_create_connection.html).
#borrow(self)
pub extern "c" fn Socket::connection_factory_create_connection(
  self : Socket,
) -> SocketConnection = "moonbit_g_socket_connection_factory_create_connection"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.get_available_bytes.html).
#borrow(self)
pub extern "c" fn Socket::get_available_bytes(self : Socket) -> Int64 = "moonbit_g_socket_get_available_bytes"

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

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

///|
#borrow(self_, error)
extern "c" fn moonbit_g_socket_get_credentials(
  self_ : Socket,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Credentials = "moonbit_g_socket_get_credentials"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.get_credentials.html).
pub fn Socket::get_credentials(self : Socket) -> Credentials raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_get_credentials(self, error_)
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.get_family.html).
#borrow(self)
pub extern "c" fn Socket::get_family(self : Socket) -> SocketFamily = "moonbit_g_socket_get_family"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.get_fd.html).
#borrow(self)
pub extern "c" fn Socket::get_fd(self : Socket) -> Int = "moonbit_g_socket_get_fd"

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

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.get_listen_backlog.html).
#borrow(self)
pub extern "c" fn Socket::get_listen_backlog(self : Socket) -> Int = "moonbit_g_socket_get_listen_backlog"

///|
#borrow(self_, error)
extern "c" fn moonbit_g_socket_get_local_address(
  self_ : Socket,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> SocketAddress = "moonbit_g_socket_get_local_address"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.get_local_address.html).
pub fn Socket::get_local_address(
  self : Socket,
) -> SocketAddress raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_get_local_address(self, error_)
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

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

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

///|
#borrow(self_, value, error)
extern "c" fn moonbit_g_socket_get_option(
  self_ : Socket,
  level : Int,
  optname : Int,
  value : Ref[Int],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_get_option"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.get_option.html).
pub fn Socket::get_option(
  self : Socket,
  level : Int,
  optname : Int,
) -> (Bool, Int) raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let value = Ref(0)
  let result = moonbit_g_socket_get_option(self, level, optname, value, error_)
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  (result, value.val)
}

///|
#borrow(self_, error)
extern "c" fn moonbit_g_socket_get_remote_address(
  self_ : Socket,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> SocketAddress = "moonbit_g_socket_get_remote_address"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.get_remote_address.html).
pub fn Socket::get_remote_address(
  self : Socket,
) -> SocketAddress raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_get_remote_address(self, error_)
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.get_socket_type.html).
#borrow(self)
pub extern "c" fn Socket::get_socket_type(self : Socket) -> SocketType = "moonbit_g_socket_get_socket_type"

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

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

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

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

///|
#borrow(self_, group, iface, error)
extern "c" fn moonbit_g_socket_join_multicast_group(
  self_ : Socket,
  group : InetAddress,
  source_specific : Bool,
  iface : @glib.Nullable[Bytes],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_join_multicast_group"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.join_multicast_group.html).
pub fn Socket::join_multicast_group(
  self : Socket,
  group : &IInetAddress,
  source_specific : Bool,
  iface : String?,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_join_multicast_group(
    self,
    group.as_inet_address(),
    source_specific,
    match iface {
      Some(s) => @glib.Nullable::some(@encoding/utf8.encode(s))
      None => @glib.Nullable::null()
    },
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
#borrow(self_, group, source_specific, iface, error)
extern "c" fn moonbit_g_socket_join_multicast_group_ssm(
  self_ : Socket,
  group : InetAddress,
  source_specific : @glib.Nullable[InetAddress],
  iface : @glib.Nullable[Bytes],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_join_multicast_group_ssm"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.join_multicast_group_ssm.html).
pub fn Socket::join_multicast_group_ssm(
  self : Socket,
  group : &IInetAddress,
  source_specific : &IInetAddress?,
  iface : String?,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_join_multicast_group_ssm(
    self,
    group.as_inet_address(),
    match source_specific {
      Some(v) => @glib.Nullable::some(v.as_inet_address())
      None => @glib.Nullable::null()
    },
    match iface {
      Some(s) => @glib.Nullable::some(@encoding/utf8.encode(s))
      None => @glib.Nullable::null()
    },
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
#borrow(self_, group, iface, error)
extern "c" fn moonbit_g_socket_leave_multicast_group(
  self_ : Socket,
  group : InetAddress,
  source_specific : Bool,
  iface : @glib.Nullable[Bytes],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_leave_multicast_group"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.leave_multicast_group.html).
pub fn Socket::leave_multicast_group(
  self : Socket,
  group : &IInetAddress,
  source_specific : Bool,
  iface : String?,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_leave_multicast_group(
    self,
    group.as_inet_address(),
    source_specific,
    match iface {
      Some(s) => @glib.Nullable::some(@encoding/utf8.encode(s))
      None => @glib.Nullable::null()
    },
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
#borrow(self_, group, source_specific, iface, error)
extern "c" fn moonbit_g_socket_leave_multicast_group_ssm(
  self_ : Socket,
  group : InetAddress,
  source_specific : @glib.Nullable[InetAddress],
  iface : @glib.Nullable[Bytes],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_leave_multicast_group_ssm"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.leave_multicast_group_ssm.html).
pub fn Socket::leave_multicast_group_ssm(
  self : Socket,
  group : &IInetAddress,
  source_specific : &IInetAddress?,
  iface : String?,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_leave_multicast_group_ssm(
    self,
    group.as_inet_address(),
    match source_specific {
      Some(v) => @glib.Nullable::some(v.as_inet_address())
      None => @glib.Nullable::null()
    },
    match iface {
      Some(s) => @glib.Nullable::some(@encoding/utf8.encode(s))
      None => @glib.Nullable::null()
    },
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
#borrow(self_, error)
extern "c" fn moonbit_g_socket_listen(
  self_ : Socket,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_listen"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.listen.html).
pub fn Socket::listen(self : Socket) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_listen(self, error_)
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
#borrow(self_, cancellable, error)
extern "c" fn moonbit_g_socket_receive_bytes(
  self_ : Socket,
  size : UInt64,
  timeout_us : Int64,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bytes = "moonbit_g_socket_receive_bytes"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.receive_bytes.html).
pub fn Socket::receive_bytes(
  self : Socket,
  size : UInt64,
  timeout_us : Int64,
  cancellable : &ICancellable?,
) -> Bytes raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_receive_bytes(
    self,
    size,
    timeout_us,
    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.Socket.set_blocking.html).
#borrow(self)
pub extern "c" fn Socket::set_blocking(self : Socket, blocking : Bool) = "moonbit_g_socket_set_blocking"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.set_broadcast.html).
#borrow(self)
pub extern "c" fn Socket::set_broadcast(self : Socket, broadcast : Bool) = "moonbit_g_socket_set_broadcast"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.set_keepalive.html).
#borrow(self)
pub extern "c" fn Socket::set_keepalive(self : Socket, keepalive : Bool) = "moonbit_g_socket_set_keepalive"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.set_listen_backlog.html).
#borrow(self)
pub extern "c" fn Socket::set_listen_backlog(self : Socket, backlog : Int) = "moonbit_g_socket_set_listen_backlog"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.set_multicast_loopback.html).
#borrow(self)
pub extern "c" fn Socket::set_multicast_loopback(
  self : Socket,
  loopback : Bool,
) = "moonbit_g_socket_set_multicast_loopback"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.set_multicast_ttl.html).
#borrow(self)
pub extern "c" fn Socket::set_multicast_ttl(self : Socket, ttl : UInt) = "moonbit_g_socket_set_multicast_ttl"

///|
#borrow(self_, error)
extern "c" fn moonbit_g_socket_set_option(
  self_ : Socket,
  level : Int,
  optname : Int,
  value : Int,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_set_option"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.set_option.html).
pub fn Socket::set_option(
  self : Socket,
  level : Int,
  optname : Int,
  value : Int,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_set_option(self, level, optname, value, error_)
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

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

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.set_ttl.html).
#borrow(self)
pub extern "c" fn Socket::set_ttl(self : Socket, ttl : UInt) = "moonbit_g_socket_set_ttl"

///|
#borrow(self_, error)
extern "c" fn moonbit_g_socket_shutdown(
  self_ : Socket,
  shutdown_read : Bool,
  shutdown_write : Bool,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_socket_shutdown"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Socket.shutdown.html).
pub fn Socket::shutdown(
  self : Socket,
  shutdown_read : Bool,
  shutdown_write : Bool,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_socket_shutdown(
    self, shutdown_read, shutdown_write, error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

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

///|
/// [Upstream documentation](https://docs.gtk.org/gio/property.Socket.type.html).
#borrow(self_)
pub extern "c" fn Socket::get_type(self_ : Socket) -> SocketType = "moonbit_g_socket_get_type"

///|
impl ISocket with fn accept(self, cancellable) -> Socket raise @glib.Error_ {
  self.as_socket().accept(cancellable)
}

///|
impl ISocket with fn bind(self, address, allow_reuse) -> Bool raise @glib.Error_ {
  self.as_socket().bind(address, allow_reuse)
}

///|
impl ISocket with fn check_connect_result(self) -> Bool raise @glib.Error_ {
  self.as_socket().check_connect_result()
}

///|
impl ISocket with fn close(self) -> Bool raise @glib.Error_ {
  self.as_socket().close()
}

///|
impl ISocket with fn condition_check(self, condition) -> @glib.IOCondition {
  self.as_socket().condition_check(condition)
}

///|
impl ISocket with fn condition_timed_wait(
  self,
  condition,
  timeout_us,
  cancellable,
) -> Bool raise @glib.Error_ {
  self.as_socket().condition_timed_wait(condition, timeout_us, cancellable)
}

///|
impl ISocket with fn condition_wait(self, condition, cancellable) -> Bool raise @glib.Error_ {
  self.as_socket().condition_wait(condition, cancellable)
}

///|
impl ISocket with fn connect(self, address, cancellable) -> Bool raise @glib.Error_ {
  self.as_socket().connect(address, cancellable)
}

///|
impl ISocket with fn connection_factory_create_connection(self) -> SocketConnection {
  self.as_socket().connection_factory_create_connection()
}

///|
impl ISocket with fn get_available_bytes(self) -> Int64 {
  self.as_socket().get_available_bytes()
}

///|
impl ISocket with fn get_blocking(self) -> Bool {
  self.as_socket().get_blocking()
}

///|
impl ISocket with fn get_broadcast(self) -> Bool {
  self.as_socket().get_broadcast()
}

///|
impl ISocket with fn get_credentials(self) -> Credentials raise @glib.Error_ {
  self.as_socket().get_credentials()
}

///|
impl ISocket with fn get_family(self) -> SocketFamily {
  self.as_socket().get_family()
}

///|
impl ISocket with fn get_fd(self) -> Int {
  self.as_socket().get_fd()
}

///|
impl ISocket with fn get_keepalive(self) -> Bool {
  self.as_socket().get_keepalive()
}

///|
impl ISocket with fn get_listen_backlog(self) -> Int {
  self.as_socket().get_listen_backlog()
}

///|
impl ISocket with fn get_local_address(self) -> SocketAddress raise @glib.Error_ {
  self.as_socket().get_local_address()
}

///|
impl ISocket with fn get_multicast_loopback(self) -> Bool {
  self.as_socket().get_multicast_loopback()
}

///|
impl ISocket with fn get_multicast_ttl(self) -> UInt {
  self.as_socket().get_multicast_ttl()
}

///|
impl ISocket with fn get_option(self, level, optname) -> (Bool, Int) raise @glib.Error_ {
  self.as_socket().get_option(level, optname)
}

///|
impl ISocket with fn get_remote_address(self) -> SocketAddress raise @glib.Error_ {
  self.as_socket().get_remote_address()
}

///|
impl ISocket with fn get_socket_type(self) -> SocketType {
  self.as_socket().get_socket_type()
}

///|
impl ISocket with fn get_timeout(self) -> UInt {
  self.as_socket().get_timeout()
}

///|
impl ISocket with fn get_ttl(self) -> UInt {
  self.as_socket().get_ttl()
}

///|
impl ISocket with fn is_closed(self) -> Bool {
  self.as_socket().is_closed()
}

///|
impl ISocket with fn is_connected(self) -> Bool {
  self.as_socket().is_connected()
}

///|
impl ISocket with fn join_multicast_group(self, group, source_specific, iface) -> Bool raise @glib.Error_ {
  self.as_socket().join_multicast_group(group, source_specific, iface)
}

///|
impl ISocket with fn join_multicast_group_ssm(
  self,
  group,
  source_specific,
  iface,
) -> Bool raise @glib.Error_ {
  self.as_socket().join_multicast_group_ssm(group, source_specific, iface)
}

///|
impl ISocket with fn leave_multicast_group(self, group, source_specific, iface) -> Bool raise @glib.Error_ {
  self.as_socket().leave_multicast_group(group, source_specific, iface)
}

///|
impl ISocket with fn leave_multicast_group_ssm(
  self,
  group,
  source_specific,
  iface,
) -> Bool raise @glib.Error_ {
  self.as_socket().leave_multicast_group_ssm(group, source_specific, iface)
}

///|
impl ISocket with fn listen(self) -> Bool raise @glib.Error_ {
  self.as_socket().listen()
}

///|
impl ISocket with fn receive_bytes(self, size, timeout_us, cancellable) -> Bytes raise @glib.Error_ {
  self.as_socket().receive_bytes(size, timeout_us, cancellable)
}

///|
impl ISocket with fn set_blocking(self, blocking) -> Unit {
  self.as_socket().set_blocking(blocking)
}

///|
impl ISocket with fn set_broadcast(self, broadcast) -> Unit {
  self.as_socket().set_broadcast(broadcast)
}

///|
impl ISocket with fn set_keepalive(self, keepalive) -> Unit {
  self.as_socket().set_keepalive(keepalive)
}

///|
impl ISocket with fn set_listen_backlog(self, backlog) -> Unit {
  self.as_socket().set_listen_backlog(backlog)
}

///|
impl ISocket with fn set_multicast_loopback(self, loopback) -> Unit {
  self.as_socket().set_multicast_loopback(loopback)
}

///|
impl ISocket with fn set_multicast_ttl(self, ttl) -> Unit {
  self.as_socket().set_multicast_ttl(ttl)
}

///|
impl ISocket with fn set_option(self, level, optname, value) -> Bool raise @glib.Error_ {
  self.as_socket().set_option(level, optname, value)
}

///|
impl ISocket with fn set_timeout(self, timeout) -> Unit {
  self.as_socket().set_timeout(timeout)
}

///|
impl ISocket with fn set_ttl(self, ttl) -> Unit {
  self.as_socket().set_ttl(ttl)
}

///|
impl ISocket with fn shutdown(self, shutdown_read, shutdown_write) -> Bool raise @glib.Error_ {
  self.as_socket().shutdown(shutdown_read, shutdown_write)
}

///|
impl ISocket with fn speaks_ipv4(self) -> Bool {
  self.as_socket().speaks_ipv4()
}

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

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

///|
pub fn Socket::as_datagram_based(self : Socket) -> DatagramBased = "%identity"

///|
pub impl IDatagramBased for Socket with fn as_datagram_based(self) {
  self.as_datagram_based()
}

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

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