// GENERATED — DO NOT EDIT

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

///|
pub(open) trait IDBusInterfaceSkeleton {
  fn as_dbus_interface_skeleton(Self) -> DBusInterfaceSkeleton
  fn export_(Self, &IDBusConnection, String) -> Bool raise @glib.Error_ = _
  fn flush(Self) -> Unit = _
  fn get_connection(Self) -> DBusConnection? = _
  fn get_connections(Self) -> Array[DBusConnection] = _
  fn get_flags(Self) -> DBusInterfaceSkeletonFlags = _
  fn get_object_path(Self) -> String? = _
  fn get_properties(Self) -> @glib.Variant = _
  fn has_connection(Self, &IDBusConnection) -> Bool = _
  fn set_flags(Self, DBusInterfaceSkeletonFlags) -> Unit = _
  fn unexport(Self) -> Unit = _
  fn unexport_from_connection(Self, &IDBusConnection) -> Unit = _
  fn connect_g_authorize_method(
    Self,
    (DBusInterfaceSkeleton, DBusMethodInvocation) -> Bool,
  ) -> UInt64 = _
}

///|
pub impl IDBusInterfaceSkeleton for DBusInterfaceSkeleton with fn as_dbus_interface_skeleton(
  self,
) {
  self
}

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

///|
#borrow(self_, connection, object_path, error)
extern "c" fn moonbit_g_dbus_interface_skeleton_export(
  self_ : DBusInterfaceSkeleton,
  connection : DBusConnection,
  object_path : Bytes,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_dbus_interface_skeleton_export"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.DBusInterfaceSkeleton.export.html).
pub fn DBusInterfaceSkeleton::export_(
  self : DBusInterfaceSkeleton,
  connection : &IDBusConnection,
  object_path : String,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_dbus_interface_skeleton_export(
    self,
    connection.as_dbus_connection(),
    @encoding/utf8.encode(object_path),
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

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

///|
#borrow(self_)
extern "c" fn moonbit_g_dbus_interface_skeleton_get_connection(
  self_ : DBusInterfaceSkeleton,
) -> @glib.Nullable[DBusConnection] = "moonbit_g_dbus_interface_skeleton_get_connection"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.DBusInterfaceSkeleton.get_connection.html).
pub fn DBusInterfaceSkeleton::get_connection(
  self : DBusInterfaceSkeleton,
) -> DBusConnection? {
  let raw_result = moonbit_g_dbus_interface_skeleton_get_connection(self)
  raw_result.to_option()
}

///|
#borrow(self_, result)
extern "c" fn moonbit_g_dbus_interface_skeleton_get_connections(
  self_ : DBusInterfaceSkeleton,
  result : Ref[FixedArray[DBusConnection]],
) = "moonbit_g_dbus_interface_skeleton_get_connections"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.DBusInterfaceSkeleton.get_connections.html).
pub fn DBusInterfaceSkeleton::get_connections(
  self : DBusInterfaceSkeleton,
) -> Array[DBusConnection] {
  let result_ref : Ref[FixedArray[DBusConnection]] = Ref([])
  moonbit_g_dbus_interface_skeleton_get_connections(self, result_ref)
  let values : Array[DBusConnection] = Array::new(
    capacity=result_ref.val.length(),
  )
  for value in result_ref.val {
    values.push(value)
  }
  values
}

///|
#borrow(self_)
extern "c" fn moonbit_g_dbus_interface_skeleton_get_flags(
  self_ : DBusInterfaceSkeleton,
) -> Int = "moonbit_g_dbus_interface_skeleton_get_flags"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.DBusInterfaceSkeleton.get_flags.html).
pub fn DBusInterfaceSkeleton::get_flags(
  self : DBusInterfaceSkeleton,
) -> DBusInterfaceSkeletonFlags {
  DBusInterfaceSkeletonFlags::from_int(
    moonbit_g_dbus_interface_skeleton_get_flags(self),
  )
}

///|
#borrow(self_)
extern "c" fn moonbit_g_dbus_interface_skeleton_get_object_path(
  self_ : DBusInterfaceSkeleton,
) -> @glib.Nullable[Bytes] = "moonbit_g_dbus_interface_skeleton_get_object_path"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.DBusInterfaceSkeleton.get_object_path.html).
pub fn DBusInterfaceSkeleton::get_object_path(
  self : DBusInterfaceSkeleton,
) -> String? {
  let result = moonbit_g_dbus_interface_skeleton_get_object_path(self)
  match result.to_option() {
    Some(bytes) => Some(@encoding/utf8.decode_lossy(bytes))
    None => None
  }
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.DBusInterfaceSkeleton.get_properties.html).
#borrow(self)
pub extern "c" fn DBusInterfaceSkeleton::get_properties(
  self : DBusInterfaceSkeleton,
) -> @glib.Variant = "moonbit_g_dbus_interface_skeleton_get_properties"

///|
#borrow(self_, connection)
extern "c" fn moonbit_g_dbus_interface_skeleton_has_connection(
  self_ : DBusInterfaceSkeleton,
  connection : DBusConnection,
) -> Bool = "moonbit_g_dbus_interface_skeleton_has_connection"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.DBusInterfaceSkeleton.has_connection.html).
pub fn DBusInterfaceSkeleton::has_connection(
  self : DBusInterfaceSkeleton,
  connection : &IDBusConnection,
) -> Bool {
  moonbit_g_dbus_interface_skeleton_has_connection(
    self,
    connection.as_dbus_connection(),
  )
}

///|
#borrow(self_)
extern "c" fn moonbit_g_dbus_interface_skeleton_set_flags(
  self_ : DBusInterfaceSkeleton,
  flags : Int,
) = "moonbit_g_dbus_interface_skeleton_set_flags"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.DBusInterfaceSkeleton.set_flags.html).
pub fn DBusInterfaceSkeleton::set_flags(
  self : DBusInterfaceSkeleton,
  flags : DBusInterfaceSkeletonFlags,
) -> Unit {
  moonbit_g_dbus_interface_skeleton_set_flags(self, flags.to_int())
}

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

///|
#borrow(self_, connection)
extern "c" fn moonbit_g_dbus_interface_skeleton_unexport_from_connection(
  self_ : DBusInterfaceSkeleton,
  connection : DBusConnection,
) = "moonbit_g_dbus_interface_skeleton_unexport_from_connection"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.DBusInterfaceSkeleton.unexport_from_connection.html).
pub fn DBusInterfaceSkeleton::unexport_from_connection(
  self : DBusInterfaceSkeleton,
  connection : &IDBusConnection,
) -> Unit {
  moonbit_g_dbus_interface_skeleton_unexport_from_connection(
    self,
    connection.as_dbus_connection(),
  )
}

///|
#borrow(instance)
extern "c" fn gd_bus_interface_skeleton_connect_g_authorize_method(
  instance : DBusInterfaceSkeleton,
  function : FuncRef[
    (
      DBusInterfaceSkeleton,
      DBusMethodInvocation,
      (DBusInterfaceSkeleton, DBusMethodInvocation) -> Bool,
    ) -> Bool,
  ],
  closure : (DBusInterfaceSkeleton, DBusMethodInvocation) -> Bool,
) -> UInt64 = "moonbit_gd_bus_interface_skeleton_connect_g_authorize_method"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/signal.DBusInterfaceSkeleton.g-authorize-method.html).
pub fn DBusInterfaceSkeleton::connect_g_authorize_method(
  self : DBusInterfaceSkeleton,
  f : (DBusInterfaceSkeleton, DBusMethodInvocation) -> Bool,
) -> UInt64 {
  gd_bus_interface_skeleton_connect_g_authorize_method(
    self,
    fn(instance_, invocation, f) { f(instance_, invocation) },
    f,
  )
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/property.DBusInterfaceSkeleton.g-flags.html).
#borrow(self_)
extern "c" fn __ffi_moonbit_gd_bus_interface_skeleton_get_g_flags(
  self_ : DBusInterfaceSkeleton,
) -> Int = "moonbit_gd_bus_interface_skeleton_get_g_flags"

///|
pub fn DBusInterfaceSkeleton::get_g_flags(
  self : DBusInterfaceSkeleton,
) -> DBusInterfaceSkeletonFlags {
  DBusInterfaceSkeletonFlags::from_int(
    __ffi_moonbit_gd_bus_interface_skeleton_get_g_flags(self),
  )
}

///|
#borrow(self_)
extern "c" fn __ffi_moonbit_gd_bus_interface_skeleton_set_g_flags(
  self_ : DBusInterfaceSkeleton,
  value : Int,
) -> Unit = "moonbit_gd_bus_interface_skeleton_set_g_flags"

///|
pub fn DBusInterfaceSkeleton::set_g_flags(
  self : DBusInterfaceSkeleton,
  value : DBusInterfaceSkeletonFlags,
) -> Unit {
  __ffi_moonbit_gd_bus_interface_skeleton_set_g_flags(self, value.to_int())
}

///|
impl IDBusInterfaceSkeleton with fn export_(self, connection, object_path) -> Bool raise @glib.Error_ {
  self.as_dbus_interface_skeleton().export_(connection, object_path)
}

///|
impl IDBusInterfaceSkeleton with fn flush(self) -> Unit {
  self.as_dbus_interface_skeleton().flush()
}

///|
impl IDBusInterfaceSkeleton with fn get_connection(self) -> DBusConnection? {
  self.as_dbus_interface_skeleton().get_connection()
}

///|
impl IDBusInterfaceSkeleton with fn get_connections(self) -> Array[
  DBusConnection,
] {
  self.as_dbus_interface_skeleton().get_connections()
}

///|
impl IDBusInterfaceSkeleton with fn get_flags(self) -> DBusInterfaceSkeletonFlags {
  self.as_dbus_interface_skeleton().get_flags()
}

///|
impl IDBusInterfaceSkeleton with fn get_object_path(self) -> String? {
  self.as_dbus_interface_skeleton().get_object_path()
}

///|
impl IDBusInterfaceSkeleton with fn get_properties(self) -> @glib.Variant {
  self.as_dbus_interface_skeleton().get_properties()
}

///|
impl IDBusInterfaceSkeleton with fn has_connection(self, connection) -> Bool {
  self.as_dbus_interface_skeleton().has_connection(connection)
}

///|
impl IDBusInterfaceSkeleton with fn set_flags(self, flags) -> Unit {
  self.as_dbus_interface_skeleton().set_flags(flags)
}

///|
impl IDBusInterfaceSkeleton with fn unexport(self) -> Unit {
  self.as_dbus_interface_skeleton().unexport()
}

///|
impl IDBusInterfaceSkeleton with fn unexport_from_connection(self, connection) -> Unit {
  self.as_dbus_interface_skeleton().unexport_from_connection(connection)
}

///|
impl IDBusInterfaceSkeleton with fn connect_g_authorize_method(self, f) -> UInt64 {
  self.as_dbus_interface_skeleton().connect_g_authorize_method(f)
}

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

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

///|
pub fn DBusInterfaceSkeleton::as_dbus_interface(
  self : DBusInterfaceSkeleton,
) -> DBusInterface = "%identity"

///|
pub impl IDBusInterface for DBusInterfaceSkeleton with fn as_dbus_interface(
  self,
) {
  self.as_dbus_interface()
}