// Generated by gir (https://github.com/gtk-rs/gir @ 5223ce91b97a)
// from ../.. (@ 1f5526ec167d+)
// from ../../gir-files (@ 6cd7b656acd6)
// DO NOT EDIT

#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(clippy::approx_constant, clippy::type_complexity, clippy::unreadable_literal, clippy::upper_case_acronyms)]
#![cfg_attr(docsrs, feature(doc_cfg))]

use glib_sys as glib;
use gobject_sys as gobject;
use gio_sys as gio;
use gtk_sys as gtk;
use gdk_sys as gdk;
use gdk_pixbuf_sys as gdk_pixbuf;
use pango_sys as pango;
use handy_sys as handy;

#[allow(unused_imports)]
use libc::{c_int, c_char, c_uchar, c_float, c_uint, c_double,
    c_short, c_ushort, c_long, c_ulong,
    c_void, size_t, ssize_t, time_t, off_t, intptr_t, uintptr_t, FILE};
#[cfg(unix)]
#[allow(unused_imports)]
use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};

// Enums
pub type PhoshAnimationType = c_int;
pub const PHOSH_ANIMATION_TYPE_EASE_OUT_CUBIC: PhoshAnimationType = 0;
pub const PHOSH_ANIMATION_TYPE_EASE_IN_QUINTIC: PhoshAnimationType = 1;
pub const PHOSH_ANIMATION_TYPE_EASE_OUT_QUINTIC: PhoshAnimationType = 2;
pub const PHOSH_ANIMATION_TYPE_EASE_OUT_BOUNCE: PhoshAnimationType = 3;

pub type PhoshAppGridButtonMode = c_int;
pub const PHOSH_APP_GRID_BUTTON_LAUNCHER: PhoshAppGridButtonMode = 0;
pub const PHOSH_APP_GRID_BUTTON_FAVORITES: PhoshAppGridButtonMode = 1;

pub type PhoshCallState = c_int;

pub type PhoshDragSurfaceDragMode = c_int;
pub const PHOSH_DRAG_SURFACE_DRAG_MODE_FULL: PhoshDragSurfaceDragMode = 0;
pub const PHOSH_DRAG_SURFACE_DRAG_MODE_HANDLE: PhoshDragSurfaceDragMode = 1;
pub const PHOSH_DRAG_SURFACE_DRAG_MODE_NONE: PhoshDragSurfaceDragMode = 2;

pub type PhoshDragSurfaceState = c_int;
pub const PHOSH_DRAG_SURFACE_STATE_FOLDED: PhoshDragSurfaceState = 0;
pub const PHOSH_DRAG_SURFACE_STATE_UNFOLDED: PhoshDragSurfaceState = 1;
pub const PHOSH_DRAG_SURFACE_STATE_DRAGGED: PhoshDragSurfaceState = 2;

pub type PhoshHksDeviceType = c_int;
pub const PHOSH_HKS_TYPE_MIC: PhoshHksDeviceType = 10;

pub type PhoshHomeState = c_int;
pub const PHOSH_HOME_STATE_FOLDED: PhoshHomeState = 0;
pub const PHOSH_HOME_STATE_UNFOLDED: PhoshHomeState = 1;

pub type PhoshLayoutClockPosition = c_int;
pub const PHOSH_LAYOUT_CLOCK_POS_CENTER: PhoshLayoutClockPosition = 0;
pub const PHOSH_LAYOUT_CLOCK_POS_LEFT: PhoshLayoutClockPosition = 1;
pub const PHOSH_LAYOUT_CLOCK_POS_RIGHT: PhoshLayoutClockPosition = 2;

pub type PhoshLockscreenPage = c_int;
pub const PHOSH_LOCKSCREEN_PAGE_INFO: PhoshLockscreenPage = 0;
pub const PHOSH_LOCKSCREEN_PAGE_EXTRA: PhoshLockscreenPage = 1;
pub const PHOSH_LOCKSCREEN_PAGE_UNLOCK: PhoshLockscreenPage = 2;

pub type PhoshLogoutAction = c_int;
pub const PHOSH_END_SESSION_ACTION_LOGOUT: PhoshLogoutAction = 0;
pub const PHOSH_END_SESSION_ACTION_SHUTDOWN: PhoshLogoutAction = 1;
pub const PHOSH_END_SESSION_ACTION_REBOOT: PhoshLogoutAction = 2;

pub type PhoshMediaPlayerStatus = c_int;
pub const PHOSH_MEDIA_PLAYER_STATUS_STOPPED: PhoshMediaPlayerStatus = 0;
pub const PHOSH_MEDIA_PLAYER_STATUS_PAUSED: PhoshMediaPlayerStatus = 1;
pub const PHOSH_MEDIA_PLAYER_STATUS_PLAYING: PhoshMediaPlayerStatus = 2;

pub type PhoshMonitorConnectorType = c_int;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_Unknown: PhoshMonitorConnectorType = 0;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_VGA: PhoshMonitorConnectorType = 1;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_DVII: PhoshMonitorConnectorType = 2;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_DVID: PhoshMonitorConnectorType = 3;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_DVIA: PhoshMonitorConnectorType = 4;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_Composite: PhoshMonitorConnectorType = 5;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_SVIDEO: PhoshMonitorConnectorType = 6;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_LVDS: PhoshMonitorConnectorType = 7;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_Component: PhoshMonitorConnectorType = 8;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_9PinDIN: PhoshMonitorConnectorType = 9;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_DisplayPort: PhoshMonitorConnectorType = 10;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_HDMIA: PhoshMonitorConnectorType = 11;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_HDMIB: PhoshMonitorConnectorType = 12;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_TV: PhoshMonitorConnectorType = 13;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_eDP: PhoshMonitorConnectorType = 14;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_VIRTUAL: PhoshMonitorConnectorType = 15;
pub const PHOSH_MONITOR_CONNECTOR_TYPE_DSI: PhoshMonitorConnectorType = 16;

pub type PhoshMonitorManagerConfigMethod = c_int;
pub const PHOSH_MONITOR_MANAGER_CONFIG_METHOD_VERIFY: PhoshMonitorManagerConfigMethod = 0;
pub const PHOSH_MONITOR_MANAGER_CONFIG_METHOD_TEMPORARY: PhoshMonitorManagerConfigMethod = 1;
pub const PHOSH_MONITOR_MANAGER_CONFIG_METHOD_PERSISTENT: PhoshMonitorManagerConfigMethod = 2;

pub type PhoshMonitorPowerSaveMode = c_int;
pub const PHOSH_MONITOR_POWER_SAVE_MODE_OFF: PhoshMonitorPowerSaveMode = 0;
pub const PHOSH_MONITOR_POWER_SAVE_MODE_ON: PhoshMonitorPowerSaveMode = 1;

pub type PhoshMonitorTransform = c_int;
pub const PHOSH_MONITOR_TRANSFORM_NORMAL: PhoshMonitorTransform = 0;
pub const PHOSH_MONITOR_TRANSFORM_90: PhoshMonitorTransform = 1;
pub const PHOSH_MONITOR_TRANSFORM_180: PhoshMonitorTransform = 2;
pub const PHOSH_MONITOR_TRANSFORM_270: PhoshMonitorTransform = 3;
pub const PHOSH_MONITOR_TRANSFORM_FLIPPED: PhoshMonitorTransform = 4;
pub const PHOSH_MONITOR_TRANSFORM_FLIPPED_90: PhoshMonitorTransform = 5;
pub const PHOSH_MONITOR_TRANSFORM_FLIPPED_180: PhoshMonitorTransform = 6;
pub const PHOSH_MONITOR_TRANSFORM_FLIPPED_270: PhoshMonitorTransform = 7;

pub type PhoshNotificationReason = c_int;
pub const PHOSH_NOTIFICATION_REASON_EXPIRED: PhoshNotificationReason = 1;
pub const PHOSH_NOTIFICATION_REASON_DISMISSED: PhoshNotificationReason = 2;
pub const PHOSH_NOTIFICATION_REASON_CLOSED: PhoshNotificationReason = 3;
pub const PHOSH_NOTIFICATION_REASON_UNDEFINED: PhoshNotificationReason = 4;

pub type PhoshNotificationUrgency = c_int;
pub const PHOSH_NOTIFICATION_URGENCY_LOW: PhoshNotificationUrgency = 0;
pub const PHOSH_NOTIFICATION_URGENCY_NORMAL: PhoshNotificationUrgency = 1;
pub const PHOSH_NOTIFICATION_URGENCY_CRITICAL: PhoshNotificationUrgency = 2;

pub type PhoshRotateInfoMode = c_int;
pub const PHOSH_ROTATE_INFO_MODE_LOCK: PhoshRotateInfoMode = 0;
pub const PHOSH_ROTATE_INFO_MODE_TOGGLE: PhoshRotateInfoMode = 1;

pub type PhoshRotationManagerMode = c_int;
pub const PHOSH_ROTATION_MANAGER_MODE_OFF: PhoshRotationManagerMode = 0;
pub const PHOSH_ROTATION_MANAGER_MODE_SENSOR: PhoshRotationManagerMode = 1;

pub type PhoshSessionPresenceStatus = c_int;

pub type PhoshShellLayout = c_int;
pub const PHOSH_SHELL_LAYOUT_NONE: PhoshShellLayout = 0;
pub const PHOSH_SHELL_LAYOUT_DEVICE: PhoshShellLayout = 1;

pub type PhoshTopPanelState = c_int;
pub const PHOSH_TOP_PANEL_STATE_FOLDED: PhoshTopPanelState = 0;
pub const PHOSH_TOP_PANEL_STATE_UNFOLDED: PhoshTopPanelState = 1;

pub type PhoshWWanBackend = c_int;
pub const PHOSH_WWAN_BACKEND_MM: PhoshWWanBackend = 0;
pub const PHOSH_WWAN_BACKEND_OFONO: PhoshWWanBackend = 1;

// Constants
pub const PHOSH_APP_AUTH_PROMPT_CHOICES_FORMAT: &[u8] = b"a(ssa(ss)s)\0";
pub const PHOSH_APP_UNKNOWN_ICON: &[u8] = b"app-icon-unknown\0";
pub const PHOSH_EXTENSION_POINT_LOCKSCREEN_WIDGET: &[u8] = b"phosh-lockscreen-widget\0";
pub const PHOSH_EXTENSION_POINT_QUICK_SETTING_WIDGET: &[u8] = b"phosh-quick-setting-widget\0";
pub const PHOSH_FOLDERS_SCHEMA_ID: &[u8] = b"org.gnome.desktop.app-folders\0";
pub const PHOSH_HOME_BAR_HEIGHT: c_int = 15;
pub const PHOSH_MODE_DOCKED_PHONE_MASK: c_int = 10;
pub const PHOSH_NOTIFICATIONS_SCHEMA_ID: &[u8] = b"org.gnome.desktop.notifications\0";
pub const PHOSH_NOTIFICATION_DEFAULT_ACTION: &[u8] = b"default\0";
pub const PHOSH_TOP_BAR_HEIGHT: c_int = 32;
pub const PHOSH_TOP_BAR_MIN_PADDING: c_int = 9;

// Flags
pub type PhoshAppFilterModeFlags = c_uint;
pub const PHOSH_APP_FILTER_MODE_FLAGS_NONE: PhoshAppFilterModeFlags = 0;
pub const PHOSH_APP_FILTER_MODE_FLAGS_ADAPTIVE: PhoshAppFilterModeFlags = 1;

pub type PhoshModeHwFlags = c_uint;
pub const PHOSH_MODE_HW_NONE: PhoshModeHwFlags = 0;
pub const PHOSH_MODE_HW_EXT_DISPLAY: PhoshModeHwFlags = 2;
pub const PHOSH_MODE_HW_KEYBOARD: PhoshModeHwFlags = 4;
pub const PHOSH_MODE_HW_POINTER: PhoshModeHwFlags = 8;

pub type PhoshNotifyScreenWakeupFlags = c_uint;
pub const PHOSH_NOTIFY_SCREEN_WAKEUP_FLAG_ANY: PhoshNotifyScreenWakeupFlags = 1;
pub const PHOSH_NOTIFY_SCREEN_WAKEUP_FLAG_URGENCY: PhoshNotifyScreenWakeupFlags = 2;
pub const PHOSH_NOTIFY_SCREEN_WAKEUP_FLAG_CATEGORY: PhoshNotifyScreenWakeupFlags = 4;

pub type PhoshSessionManagerFlags = c_uint;
pub const PHOSH_SESSION_INHIBIT_LOGOUT: PhoshSessionManagerFlags = 1;
pub const PHOSH_SESSION_INHIBIT_USER_SWITCH: PhoshSessionManagerFlags = 2;
pub const PHOSH_SESSION_INHIBIT_SUSPEND: PhoshSessionManagerFlags = 4;
pub const PHOSH_SESSION_INHIBIT_IDLE: PhoshSessionManagerFlags = 8;
pub const PHOSH_SESSION_INHIBIT_AUTOMOUNT: PhoshSessionManagerFlags = 16;

pub type PhoshShellActionMode = c_uint;
pub const PHOSH_SHELL_ACTION_MODE_NONE: PhoshShellActionMode = 0;
pub const PHOSH_SHELL_ACTION_MODE_NORMAL: PhoshShellActionMode = 1;
pub const PHOSH_SHELL_ACTION_MODE_OVERVIEW: PhoshShellActionMode = 2;
pub const PHOSH_SHELL_ACTION_MODE_LOCK_SCREEN: PhoshShellActionMode = 4;
pub const PHOSH_SHELL_ACTION_MODE_UNLOCK_SCREEN: PhoshShellActionMode = 8;
pub const PHOSH_SHELL_ACTION_MODE_LOGIN_SCREEN: PhoshShellActionMode = 16;
pub const PHOSH_SHELL_ACTION_MODE_SYSTEM_MODAL: PhoshShellActionMode = 32;
pub const PHOSH_SHELL_ACTION_MODE_LOOKING_GLASS: PhoshShellActionMode = 64;
pub const PHOSH_SHELL_ACTION_MODE_POPUP: PhoshShellActionMode = 128;
pub const PHOSH_SHELL_ACTION_MODE_ALL: PhoshShellActionMode = 4294967295;

pub type PhoshShellDebugFlags = c_uint;
pub const PHOSH_SHELL_DEBUG_FLAG_NONE: PhoshShellDebugFlags = 0;
pub const PHOSH_SHELL_DEBUG_FLAG_ALWAYS_SPLASH: PhoshShellDebugFlags = 1;
pub const PHOSH_SHELL_DEBUG_FLAG_FAKE_BUILTIN: PhoshShellDebugFlags = 2;

pub type PhoshShellKeyBindingFlags = c_uint;
pub const PHOSH_SHELL_KEY_BINDING_NONE: PhoshShellKeyBindingFlags = 0;
pub const PHOSH_SHELL_KEY_BINDING_PER_WINDOW: PhoshShellKeyBindingFlags = 1;
pub const PHOSH_SHELL_KEY_BINDING_BUILTIN: PhoshShellKeyBindingFlags = 2;
pub const PHOSH_SHELL_KEY_BINDING_IS_REVERSED: PhoshShellKeyBindingFlags = 4;
pub const PHOSH_SHELL_KEY_BINDING_NON_MASKABLE: PhoshShellKeyBindingFlags = 8;
pub const PHOSH_SHELL_KEY_BINDING_NO_AUTO_GRAB: PhoshShellKeyBindingFlags = 32;
pub const PHOSH_SHELL_KEY_BINDING_IGNORE_AUTOREPEAT: PhoshShellKeyBindingFlags = 16;

pub type PhoshShellStateFlags = c_uint;
pub const PHOSH_STATE_NONE: PhoshShellStateFlags = 0;
pub const PHOSH_STATE_MODAL_SYSTEM_PROMPT: PhoshShellStateFlags = 1;
pub const PHOSH_STATE_BLANKED: PhoshShellStateFlags = 2;
pub const PHOSH_STATE_LOCKED: PhoshShellStateFlags = 4;
pub const PHOSH_STATE_SETTINGS: PhoshShellStateFlags = 8;
pub const PHOSH_STATE_OVERVIEW: PhoshShellStateFlags = 16;

pub type PhoshWaylandSeatCapabilities = c_uint;
pub const PHOSH_WAYLAND_SEAT_CAPABILITY_NONE: PhoshWaylandSeatCapabilities = 0;
pub const PHOSH_WAYLAND_SEAT_CAPABILITY_POINTER: PhoshWaylandSeatCapabilities = 1;
pub const PHOSH_WAYLAND_SEAT_CAPABILITY_KEYBOARD: PhoshWaylandSeatCapabilities = 2;
pub const PHOSH_WAYLAND_SEAT_CAPABILITY_TOUCH: PhoshWaylandSeatCapabilities = 4;
pub const PHOSH_WAYLAND_SEAT_CAPABILITY_TABLET_MODE_SWITCH: PhoshWaylandSeatCapabilities = 256;
pub const PHOSH_WAYLAND_SEAT_CAPABILITY_LID_SWITCH: PhoshWaylandSeatCapabilities = 512;

// Callbacks
pub type PhoshAnimationDoneCallback = Option<unsafe extern "C" fn(gpointer)>;
pub type PhoshAnimationValueCallback = Option<unsafe extern "C" fn(c_double, gpointer)>;

// Records
#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshActivityClass {
    pub parent_class: gtk::GtkEventBoxClass,
}

impl ::std::fmt::Debug for PhoshActivityClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshActivityClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshAmbientClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshAmbientClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAmbientClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct PhoshAnimation {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshAnimation {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAnimation @ {self:p}"))
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshAppAuthPromptClass {
    pub parent_class: PhoshSystemModalDialogClass,
}

impl ::std::fmt::Debug for PhoshAppAuthPromptClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAppAuthPromptClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshAppGridBaseButtonClass {
    pub parent_class: gtk::GtkFlowBoxChildClass,
}

impl ::std::fmt::Debug for PhoshAppGridBaseButtonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAppGridBaseButtonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshAppGridButtonClass {
    pub parent_class: PhoshAppGridBaseButtonClass,
}

impl ::std::fmt::Debug for PhoshAppGridButtonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAppGridButtonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshAppGridClass {
    pub parent_class: gtk::GtkBoxClass,
}

impl ::std::fmt::Debug for PhoshAppGridClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAppGridClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshAppGridFolderButtonClass {
    pub parent_class: PhoshAppGridBaseButtonClass,
}

impl ::std::fmt::Debug for PhoshAppGridFolderButtonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAppGridFolderButtonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshAppListModelClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshAppListModelClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAppListModelClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshAppTrackerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshAppTrackerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAppTrackerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshArrowClass {
    pub parent_class: gtk::GtkDrawingAreaClass,
}

impl ::std::fmt::Debug for PhoshArrowClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshArrowClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshAudioDeviceClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshAudioDeviceClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAudioDeviceClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshAudioDeviceRowClass {
    pub parent_class: gtk::GtkListBoxRowClass,
}

impl ::std::fmt::Debug for PhoshAudioDeviceRowClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAudioDeviceRowClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshAudioSettingsClass {
    pub parent_class: gtk::GtkBinClass,
}

impl ::std::fmt::Debug for PhoshAudioSettingsClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAudioSettingsClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshAuthClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshAuthClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAuthClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshAuthPromptOptionClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshAuthPromptOptionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshAuthPromptOptionClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshBackgroundCacheClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshBackgroundCacheClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshBackgroundCacheClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshBackgroundClass {
    pub parent_class: PhoshLayerSurfaceClass,
}

impl ::std::fmt::Debug for PhoshBackgroundClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshBackgroundClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshBackgroundImageClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshBackgroundImageClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshBackgroundImageClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshBatteryInfoClass {
    pub parent_class: PhoshStatusIconClass,
}

impl ::std::fmt::Debug for PhoshBatteryInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshBatteryInfoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshBtInfoClass {
    pub parent_class: PhoshStatusIconClass,
}

impl ::std::fmt::Debug for PhoshBtInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshBtInfoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshCallClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshCallClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshCallClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshCallNotificationClass {
    pub parent_class: gtk::GtkListBoxRowClass,
}

impl ::std::fmt::Debug for PhoshCallNotificationClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshCallNotificationClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshCallsDBusCallsCallIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_accept: Option<unsafe extern "C" fn(*mut PhoshCallsDBusCallsCall, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_hangup: Option<unsafe extern "C" fn(*mut PhoshCallsDBusCallsCall, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_send_dtmf: Option<unsafe extern "C" fn(*mut PhoshCallsDBusCallsCall, *mut gio::GDBusMethodInvocation, *const c_char) -> gboolean>,
    pub get_can_dtmf: Option<unsafe extern "C" fn(*mut PhoshCallsDBusCallsCall) -> gboolean>,
    pub get_display_name: Option<unsafe extern "C" fn(*mut PhoshCallsDBusCallsCall) -> *const c_char>,
    pub get_encrypted: Option<unsafe extern "C" fn(*mut PhoshCallsDBusCallsCall) -> gboolean>,
    pub get_id: Option<unsafe extern "C" fn(*mut PhoshCallsDBusCallsCall) -> *const c_char>,
    pub get_image_path: Option<unsafe extern "C" fn(*mut PhoshCallsDBusCallsCall) -> *const c_char>,
    pub get_inbound: Option<unsafe extern "C" fn(*mut PhoshCallsDBusCallsCall) -> gboolean>,
    pub get_protocol: Option<unsafe extern "C" fn(*mut PhoshCallsDBusCallsCall) -> *const c_char>,
    pub get_state: Option<unsafe extern "C" fn(*mut PhoshCallsDBusCallsCall) -> c_uint>,
}

impl ::std::fmt::Debug for PhoshCallsDBusCallsCallIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshCallsDBusCallsCallIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_accept", &self.handle_accept)
         .field("handle_hangup", &self.handle_hangup)
         .field("handle_send_dtmf", &self.handle_send_dtmf)
         .field("get_can_dtmf", &self.get_can_dtmf)
         .field("get_display_name", &self.get_display_name)
         .field("get_encrypted", &self.get_encrypted)
         .field("get_id", &self.get_id)
         .field("get_image_path", &self.get_image_path)
         .field("get_inbound", &self.get_inbound)
         .field("get_protocol", &self.get_protocol)
         .field("get_state", &self.get_state)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshCallsDBusCallsCallProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshCallsDBusCallsCallProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshCallsDBusCallsCallProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshCallsDBusCallsCallProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshCallsDBusCallsCallProxyPrivate = _PhoshCallsDBusCallsCallProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshCallsDBusCallsCallSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshCallsDBusCallsCallSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshCallsDBusCallsCallSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshCallsDBusCallsCallSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshCallsDBusCallsCallSkeletonPrivate = _PhoshCallsDBusCallsCallSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshCallsDBusObjectIface {
    pub parent_iface: gobject::GTypeInterface,
}

impl ::std::fmt::Debug for PhoshCallsDBusObjectIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshCallsDBusObjectIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshCallsDBusObjectManagerClientClass {
    pub parent_class: gio::GDBusObjectManagerClientClass,
}

impl ::std::fmt::Debug for PhoshCallsDBusObjectManagerClientClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshCallsDBusObjectManagerClientClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshCallsDBusObjectManagerClientPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshCallsDBusObjectManagerClientPrivate = _PhoshCallsDBusObjectManagerClientPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshCallsDBusObjectProxyClass {
    pub parent_class: gio::GDBusObjectProxyClass,
}

impl ::std::fmt::Debug for PhoshCallsDBusObjectProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshCallsDBusObjectProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshCallsDBusObjectProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshCallsDBusObjectProxyPrivate = _PhoshCallsDBusObjectProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshCallsDBusObjectSkeletonClass {
    pub parent_class: gio::GDBusObjectSkeletonClass,
}

impl ::std::fmt::Debug for PhoshCallsDBusObjectSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshCallsDBusObjectSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshCallsDBusObjectSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshCallsDBusObjectSkeletonPrivate = _PhoshCallsDBusObjectSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshClampClass {
    pub parent_class: gtk::GtkBinClass,
}

impl ::std::fmt::Debug for PhoshClampClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshClampClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshConnectivityInfoClass {
    pub parent_class: PhoshStatusIconClass,
}

impl ::std::fmt::Debug for PhoshConnectivityInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshConnectivityInfoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusColorIface {
    pub parent_iface: gobject::GTypeInterface,
    pub get_night_light_active: Option<unsafe extern "C" fn(*mut PhoshDBusColor) -> gboolean>,
    pub get_temperature: Option<unsafe extern "C" fn(*mut PhoshDBusColor) -> c_uint>,
}

impl ::std::fmt::Debug for PhoshDBusColorIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusColorIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("get_night_light_active", &self.get_night_light_active)
         .field("get_temperature", &self.get_temperature)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusColorProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusColorProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusColorProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusColorProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusColorProxyPrivate = _PhoshDBusColorProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusColorSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusColorSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusColorSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusColorSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusColorSkeletonPrivate = _PhoshDBusColorSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusDisplayConfigIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_apply_configuration: Option<unsafe extern "C" fn(*mut PhoshDBusDisplayConfig, *mut gio::GDBusMethodInvocation, c_uint, gboolean, *mut glib::GVariant, *mut glib::GVariant) -> gboolean>,
    pub handle_apply_monitors_config: Option<unsafe extern "C" fn(*mut PhoshDBusDisplayConfig, *mut gio::GDBusMethodInvocation, c_uint, c_uint, *mut glib::GVariant, *mut glib::GVariant) -> gboolean>,
    pub handle_change_backlight: Option<unsafe extern "C" fn(*mut PhoshDBusDisplayConfig, *mut gio::GDBusMethodInvocation, c_uint, c_uint, c_int) -> gboolean>,
    pub handle_get_crtc_gamma: Option<unsafe extern "C" fn(*mut PhoshDBusDisplayConfig, *mut gio::GDBusMethodInvocation, c_uint, c_uint) -> gboolean>,
    pub handle_get_current_state: Option<unsafe extern "C" fn(*mut PhoshDBusDisplayConfig, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_get_resources: Option<unsafe extern "C" fn(*mut PhoshDBusDisplayConfig, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_set_crtc_gamma: Option<unsafe extern "C" fn(*mut PhoshDBusDisplayConfig, *mut gio::GDBusMethodInvocation, c_uint, c_uint, *mut glib::GVariant, *mut glib::GVariant, *mut glib::GVariant) -> gboolean>,
    pub handle_set_output_ctm: Option<unsafe extern "C" fn(*mut PhoshDBusDisplayConfig, *mut gio::GDBusMethodInvocation, c_uint, c_uint, *mut glib::GVariant) -> gboolean>,
    pub get_apply_monitors_config_allowed: Option<unsafe extern "C" fn(*mut PhoshDBusDisplayConfig) -> gboolean>,
    pub get_night_light_supported: Option<unsafe extern "C" fn(*mut PhoshDBusDisplayConfig) -> gboolean>,
    pub get_panel_orientation_managed: Option<unsafe extern "C" fn(*mut PhoshDBusDisplayConfig) -> gboolean>,
    pub get_power_save_mode: Option<unsafe extern "C" fn(*mut PhoshDBusDisplayConfig) -> c_int>,
    pub monitors_changed: Option<unsafe extern "C" fn(*mut PhoshDBusDisplayConfig)>,
}

impl ::std::fmt::Debug for PhoshDBusDisplayConfigIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusDisplayConfigIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_apply_configuration", &self.handle_apply_configuration)
         .field("handle_apply_monitors_config", &self.handle_apply_monitors_config)
         .field("handle_change_backlight", &self.handle_change_backlight)
         .field("handle_get_crtc_gamma", &self.handle_get_crtc_gamma)
         .field("handle_get_current_state", &self.handle_get_current_state)
         .field("handle_get_resources", &self.handle_get_resources)
         .field("handle_set_crtc_gamma", &self.handle_set_crtc_gamma)
         .field("handle_set_output_ctm", &self.handle_set_output_ctm)
         .field("get_apply_monitors_config_allowed", &self.get_apply_monitors_config_allowed)
         .field("get_night_light_supported", &self.get_night_light_supported)
         .field("get_panel_orientation_managed", &self.get_panel_orientation_managed)
         .field("get_power_save_mode", &self.get_power_save_mode)
         .field("monitors_changed", &self.monitors_changed)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusDisplayConfigProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusDisplayConfigProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusDisplayConfigProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusDisplayConfigProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusDisplayConfigProxyPrivate = _PhoshDBusDisplayConfigProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusDisplayConfigSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusDisplayConfigSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusDisplayConfigSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusDisplayConfigSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusDisplayConfigSkeletonPrivate = _PhoshDBusDisplayConfigSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusEndSessionDialogIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_open: Option<unsafe extern "C" fn(*mut PhoshDBusEndSessionDialog, *mut gio::GDBusMethodInvocation, c_uint, c_uint, c_uint, *const *const c_char) -> gboolean>,
    pub canceled: Option<unsafe extern "C" fn(*mut PhoshDBusEndSessionDialog)>,
    pub closed: Option<unsafe extern "C" fn(*mut PhoshDBusEndSessionDialog)>,
    pub confirmed_hibernate: Option<unsafe extern "C" fn(*mut PhoshDBusEndSessionDialog)>,
    pub confirmed_hybrid_sleep: Option<unsafe extern "C" fn(*mut PhoshDBusEndSessionDialog)>,
    pub confirmed_logout: Option<unsafe extern "C" fn(*mut PhoshDBusEndSessionDialog)>,
    pub confirmed_reboot: Option<unsafe extern "C" fn(*mut PhoshDBusEndSessionDialog)>,
    pub confirmed_shutdown: Option<unsafe extern "C" fn(*mut PhoshDBusEndSessionDialog)>,
    pub confirmed_suspend: Option<unsafe extern "C" fn(*mut PhoshDBusEndSessionDialog)>,
}

impl ::std::fmt::Debug for PhoshDBusEndSessionDialogIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusEndSessionDialogIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_open", &self.handle_open)
         .field("canceled", &self.canceled)
         .field("closed", &self.closed)
         .field("confirmed_hibernate", &self.confirmed_hibernate)
         .field("confirmed_hybrid_sleep", &self.confirmed_hybrid_sleep)
         .field("confirmed_logout", &self.confirmed_logout)
         .field("confirmed_reboot", &self.confirmed_reboot)
         .field("confirmed_shutdown", &self.confirmed_shutdown)
         .field("confirmed_suspend", &self.confirmed_suspend)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusEndSessionDialogProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusEndSessionDialogProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusEndSessionDialogProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusEndSessionDialogProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusEndSessionDialogProxyPrivate = _PhoshDBusEndSessionDialogProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusEndSessionDialogSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusEndSessionDialogSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusEndSessionDialogSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusEndSessionDialogSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusEndSessionDialogSkeletonPrivate = _PhoshDBusEndSessionDialogSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusGnomeShellIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_grab_accelerator: Option<unsafe extern "C" fn(*mut PhoshDBusGnomeShell, *mut gio::GDBusMethodInvocation, *const c_char, c_uint, c_uint) -> gboolean>,
    pub handle_grab_accelerators: Option<unsafe extern "C" fn(*mut PhoshDBusGnomeShell, *mut gio::GDBusMethodInvocation, *mut glib::GVariant) -> gboolean>,
    pub handle_hide_monitor_labels: Option<unsafe extern "C" fn(*mut PhoshDBusGnomeShell, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_show_monitor_labels: Option<unsafe extern "C" fn(*mut PhoshDBusGnomeShell, *mut gio::GDBusMethodInvocation, *mut glib::GVariant) -> gboolean>,
    pub handle_show_osd: Option<unsafe extern "C" fn(*mut PhoshDBusGnomeShell, *mut gio::GDBusMethodInvocation, *mut glib::GVariant) -> gboolean>,
    pub handle_ungrab_accelerator: Option<unsafe extern "C" fn(*mut PhoshDBusGnomeShell, *mut gio::GDBusMethodInvocation, c_uint) -> gboolean>,
    pub handle_ungrab_accelerators: Option<unsafe extern "C" fn(*mut PhoshDBusGnomeShell, *mut gio::GDBusMethodInvocation, *mut glib::GVariant) -> gboolean>,
    pub get_overview_active: Option<unsafe extern "C" fn(*mut PhoshDBusGnomeShell) -> gboolean>,
    pub get_shell_version: Option<unsafe extern "C" fn(*mut PhoshDBusGnomeShell) -> *const c_char>,
    pub accelerator_activated: Option<unsafe extern "C" fn(*mut PhoshDBusGnomeShell, c_uint, *mut glib::GVariant)>,
}

impl ::std::fmt::Debug for PhoshDBusGnomeShellIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusGnomeShellIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_grab_accelerator", &self.handle_grab_accelerator)
         .field("handle_grab_accelerators", &self.handle_grab_accelerators)
         .field("handle_hide_monitor_labels", &self.handle_hide_monitor_labels)
         .field("handle_show_monitor_labels", &self.handle_show_monitor_labels)
         .field("handle_show_osd", &self.handle_show_osd)
         .field("handle_ungrab_accelerator", &self.handle_ungrab_accelerator)
         .field("handle_ungrab_accelerators", &self.handle_ungrab_accelerators)
         .field("get_overview_active", &self.get_overview_active)
         .field("get_shell_version", &self.get_shell_version)
         .field("accelerator_activated", &self.accelerator_activated)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusGnomeShellProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusGnomeShellProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusGnomeShellProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusGnomeShellProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusGnomeShellProxyPrivate = _PhoshDBusGnomeShellProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusGnomeShellSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusGnomeShellSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusGnomeShellSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusGnomeShellSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusGnomeShellSkeletonPrivate = _PhoshDBusGnomeShellSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusHostname1Iface {
    pub parent_iface: gobject::GTypeInterface,
    pub get_chassis: Option<unsafe extern "C" fn(*mut PhoshDBusHostname1) -> *const c_char>,
}

impl ::std::fmt::Debug for PhoshDBusHostname1Iface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusHostname1Iface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("get_chassis", &self.get_chassis)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusHostname1ProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusHostname1ProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusHostname1ProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusHostname1ProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusHostname1ProxyPrivate = _PhoshDBusHostname1ProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusHostname1SkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusHostname1SkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusHostname1SkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusHostname1SkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusHostname1SkeletonPrivate = _PhoshDBusHostname1SkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusImplPortalAccessIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_access_dialog: Option<unsafe extern "C" fn(*mut PhoshDBusImplPortalAccess, *mut gio::GDBusMethodInvocation, *const c_char, *const c_char, *const c_char, *const c_char, *const c_char, *const c_char, *mut glib::GVariant) -> gboolean>,
}

impl ::std::fmt::Debug for PhoshDBusImplPortalAccessIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusImplPortalAccessIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_access_dialog", &self.handle_access_dialog)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusImplPortalAccessProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusImplPortalAccessProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusImplPortalAccessProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusImplPortalAccessProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusImplPortalAccessProxyPrivate = _PhoshDBusImplPortalAccessProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusImplPortalAccessSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusImplPortalAccessSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusImplPortalAccessSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusImplPortalAccessSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusImplPortalAccessSkeletonPrivate = _PhoshDBusImplPortalAccessSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusImplPortalRequestIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_close: Option<unsafe extern "C" fn(*mut PhoshDBusImplPortalRequest, *mut gio::GDBusMethodInvocation) -> gboolean>,
}

impl ::std::fmt::Debug for PhoshDBusImplPortalRequestIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusImplPortalRequestIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_close", &self.handle_close)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusImplPortalRequestProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusImplPortalRequestProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusImplPortalRequestProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusImplPortalRequestProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusImplPortalRequestProxyPrivate = _PhoshDBusImplPortalRequestProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusImplPortalRequestSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusImplPortalRequestSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusImplPortalRequestSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusImplPortalRequestSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusImplPortalRequestSkeletonPrivate = _PhoshDBusImplPortalRequestSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusLoginManagerIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_get_session: Option<unsafe extern "C" fn(*mut PhoshDBusLoginManager, *mut gio::GDBusMethodInvocation, *const c_char) -> gboolean>,
    pub handle_inhibit: Option<unsafe extern "C" fn(*mut PhoshDBusLoginManager, *mut gio::GDBusMethodInvocation, *mut gio::GUnixFDList, *const c_char, *const c_char, *const c_char, *const c_char) -> gboolean>,
    pub handle_suspend: Option<unsafe extern "C" fn(*mut PhoshDBusLoginManager, *mut gio::GDBusMethodInvocation, gboolean) -> gboolean>,
    pub prepare_for_sleep: Option<unsafe extern "C" fn(*mut PhoshDBusLoginManager, gboolean)>,
}

impl ::std::fmt::Debug for PhoshDBusLoginManagerIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusLoginManagerIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_get_session", &self.handle_get_session)
         .field("handle_inhibit", &self.handle_inhibit)
         .field("handle_suspend", &self.handle_suspend)
         .field("prepare_for_sleep", &self.prepare_for_sleep)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusLoginManagerProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusLoginManagerProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusLoginManagerProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusLoginManagerProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusLoginManagerProxyPrivate = _PhoshDBusLoginManagerProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusLoginManagerSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusLoginManagerSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusLoginManagerSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusLoginManagerSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusLoginManagerSkeletonPrivate = _PhoshDBusLoginManagerSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusLoginSessionIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_set_brightness: Option<unsafe extern "C" fn(*mut PhoshDBusLoginSession, *mut gio::GDBusMethodInvocation, *const c_char, *const c_char, c_uint) -> gboolean>,
    pub handle_set_locked_hint: Option<unsafe extern "C" fn(*mut PhoshDBusLoginSession, *mut gio::GDBusMethodInvocation, gboolean) -> gboolean>,
    pub get_active: Option<unsafe extern "C" fn(*mut PhoshDBusLoginSession) -> gboolean>,
    pub get_locked_hint: Option<unsafe extern "C" fn(*mut PhoshDBusLoginSession) -> gboolean>,
    pub lock: Option<unsafe extern "C" fn(*mut PhoshDBusLoginSession)>,
    pub unlock: Option<unsafe extern "C" fn(*mut PhoshDBusLoginSession)>,
}

impl ::std::fmt::Debug for PhoshDBusLoginSessionIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusLoginSessionIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_set_brightness", &self.handle_set_brightness)
         .field("handle_set_locked_hint", &self.handle_set_locked_hint)
         .field("get_active", &self.get_active)
         .field("get_locked_hint", &self.get_locked_hint)
         .field("lock", &self.lock)
         .field("unlock", &self.unlock)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusLoginSessionProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusLoginSessionProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusLoginSessionProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusLoginSessionProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusLoginSessionProxyPrivate = _PhoshDBusLoginSessionProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusLoginSessionSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusLoginSessionSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusLoginSessionSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusLoginSessionSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusLoginSessionSkeletonPrivate = _PhoshDBusLoginSessionSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusMountOperationHandlerIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_ask_password: Option<unsafe extern "C" fn(*mut PhoshDBusMountOperationHandler, *mut gio::GDBusMethodInvocation, *const c_char, *const c_char, *const c_char, *const c_char, *const c_char, c_uint) -> gboolean>,
    pub handle_ask_question: Option<unsafe extern "C" fn(*mut PhoshDBusMountOperationHandler, *mut gio::GDBusMethodInvocation, *const c_char, *const c_char, *const c_char, *const *const c_char) -> gboolean>,
    pub handle_close: Option<unsafe extern "C" fn(*mut PhoshDBusMountOperationHandler, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_show_processes: Option<unsafe extern "C" fn(*mut PhoshDBusMountOperationHandler, *mut gio::GDBusMethodInvocation, *const c_char, *const c_char, *const c_char, *mut glib::GVariant, *const *const c_char) -> gboolean>,
}

impl ::std::fmt::Debug for PhoshDBusMountOperationHandlerIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusMountOperationHandlerIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_ask_password", &self.handle_ask_password)
         .field("handle_ask_question", &self.handle_ask_question)
         .field("handle_close", &self.handle_close)
         .field("handle_show_processes", &self.handle_show_processes)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusMountOperationHandlerProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusMountOperationHandlerProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusMountOperationHandlerProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusMountOperationHandlerProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusMountOperationHandlerProxyPrivate = _PhoshDBusMountOperationHandlerProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusMountOperationHandlerSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusMountOperationHandlerSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusMountOperationHandlerSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusMountOperationHandlerSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusMountOperationHandlerSkeletonPrivate = _PhoshDBusMountOperationHandlerSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusScreenSaverIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_get_active: Option<unsafe extern "C" fn(*mut PhoshDBusScreenSaver, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_get_active_time: Option<unsafe extern "C" fn(*mut PhoshDBusScreenSaver, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_lock: Option<unsafe extern "C" fn(*mut PhoshDBusScreenSaver, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_set_active: Option<unsafe extern "C" fn(*mut PhoshDBusScreenSaver, *mut gio::GDBusMethodInvocation, gboolean) -> gboolean>,
    pub active_changed: Option<unsafe extern "C" fn(*mut PhoshDBusScreenSaver, gboolean)>,
    pub wake_up_screen: Option<unsafe extern "C" fn(*mut PhoshDBusScreenSaver)>,
}

impl ::std::fmt::Debug for PhoshDBusScreenSaverIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusScreenSaverIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_get_active", &self.handle_get_active)
         .field("handle_get_active_time", &self.handle_get_active_time)
         .field("handle_lock", &self.handle_lock)
         .field("handle_set_active", &self.handle_set_active)
         .field("active_changed", &self.active_changed)
         .field("wake_up_screen", &self.wake_up_screen)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusScreenSaverProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusScreenSaverProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusScreenSaverProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusScreenSaverProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusScreenSaverProxyPrivate = _PhoshDBusScreenSaverProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusScreenSaverSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusScreenSaverSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusScreenSaverSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusScreenSaverSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusScreenSaverSkeletonPrivate = _PhoshDBusScreenSaverSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusScreenshotIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_flash_area: Option<unsafe extern "C" fn(*mut PhoshDBusScreenshot, *mut gio::GDBusMethodInvocation, c_int, c_int, c_int, c_int) -> gboolean>,
    pub handle_pick_color: Option<unsafe extern "C" fn(*mut PhoshDBusScreenshot, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_screenshot: Option<unsafe extern "C" fn(*mut PhoshDBusScreenshot, *mut gio::GDBusMethodInvocation, gboolean, gboolean, *const c_char) -> gboolean>,
    pub handle_screenshot_area: Option<unsafe extern "C" fn(*mut PhoshDBusScreenshot, *mut gio::GDBusMethodInvocation, c_int, c_int, c_int, c_int, gboolean, *const c_char) -> gboolean>,
    pub handle_screenshot_window: Option<unsafe extern "C" fn(*mut PhoshDBusScreenshot, *mut gio::GDBusMethodInvocation, gboolean, gboolean, gboolean, *const c_char) -> gboolean>,
    pub handle_select_area: Option<unsafe extern "C" fn(*mut PhoshDBusScreenshot, *mut gio::GDBusMethodInvocation) -> gboolean>,
}

impl ::std::fmt::Debug for PhoshDBusScreenshotIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusScreenshotIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_flash_area", &self.handle_flash_area)
         .field("handle_pick_color", &self.handle_pick_color)
         .field("handle_screenshot", &self.handle_screenshot)
         .field("handle_screenshot_area", &self.handle_screenshot_area)
         .field("handle_screenshot_window", &self.handle_screenshot_window)
         .field("handle_select_area", &self.handle_select_area)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusScreenshotProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusScreenshotProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusScreenshotProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusScreenshotProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusScreenshotProxyPrivate = _PhoshDBusScreenshotProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusScreenshotSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusScreenshotSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusScreenshotSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusScreenshotSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusScreenshotSkeletonPrivate = _PhoshDBusScreenshotSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusSensorProxyCompassIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_claim_compass: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxyCompass, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_release_compass: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxyCompass, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub get_compass_heading: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxyCompass) -> c_double>,
    pub get_has_compass: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxyCompass) -> gboolean>,
}

impl ::std::fmt::Debug for PhoshDBusSensorProxyCompassIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusSensorProxyCompassIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_claim_compass", &self.handle_claim_compass)
         .field("handle_release_compass", &self.handle_release_compass)
         .field("get_compass_heading", &self.get_compass_heading)
         .field("get_has_compass", &self.get_has_compass)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusSensorProxyCompassProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusSensorProxyCompassProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusSensorProxyCompassProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusSensorProxyCompassProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusSensorProxyCompassProxyPrivate = _PhoshDBusSensorProxyCompassProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusSensorProxyCompassSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusSensorProxyCompassSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusSensorProxyCompassSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusSensorProxyCompassSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusSensorProxyCompassSkeletonPrivate = _PhoshDBusSensorProxyCompassSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusSensorProxyIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_claim_accelerometer: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxy, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_claim_light: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxy, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_claim_proximity: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxy, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_release_accelerometer: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxy, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_release_light: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxy, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_release_proximity: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxy, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub get_accelerometer_orientation: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxy) -> *const c_char>,
    pub get_has_accelerometer: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxy) -> gboolean>,
    pub get_has_ambient_light: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxy) -> gboolean>,
    pub get_has_proximity: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxy) -> gboolean>,
    pub get_light_level: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxy) -> c_double>,
    pub get_light_level_unit: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxy) -> *const c_char>,
    pub get_proximity_near: Option<unsafe extern "C" fn(*mut PhoshDBusSensorProxy) -> gboolean>,
}

impl ::std::fmt::Debug for PhoshDBusSensorProxyIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusSensorProxyIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_claim_accelerometer", &self.handle_claim_accelerometer)
         .field("handle_claim_light", &self.handle_claim_light)
         .field("handle_claim_proximity", &self.handle_claim_proximity)
         .field("handle_release_accelerometer", &self.handle_release_accelerometer)
         .field("handle_release_light", &self.handle_release_light)
         .field("handle_release_proximity", &self.handle_release_proximity)
         .field("get_accelerometer_orientation", &self.get_accelerometer_orientation)
         .field("get_has_accelerometer", &self.get_has_accelerometer)
         .field("get_has_ambient_light", &self.get_has_ambient_light)
         .field("get_has_proximity", &self.get_has_proximity)
         .field("get_light_level", &self.get_light_level)
         .field("get_light_level_unit", &self.get_light_level_unit)
         .field("get_proximity_near", &self.get_proximity_near)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusSensorProxyProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusSensorProxyProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusSensorProxyProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusSensorProxyProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusSensorProxyProxyPrivate = _PhoshDBusSensorProxyProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusSensorProxySkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusSensorProxySkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusSensorProxySkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusSensorProxySkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusSensorProxySkeletonPrivate = _PhoshDBusSensorProxySkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusSessionManagerIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_can_shutdown: Option<unsafe extern "C" fn(*mut PhoshDBusSessionManager, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_inhibit: Option<unsafe extern "C" fn(*mut PhoshDBusSessionManager, *mut gio::GDBusMethodInvocation, *const c_char, c_uint, *const c_char, c_uint) -> gboolean>,
    pub handle_is_inhibited: Option<unsafe extern "C" fn(*mut PhoshDBusSessionManager, *mut gio::GDBusMethodInvocation, c_uint) -> gboolean>,
    pub handle_logout: Option<unsafe extern "C" fn(*mut PhoshDBusSessionManager, *mut gio::GDBusMethodInvocation, c_uint) -> gboolean>,
    pub handle_reboot: Option<unsafe extern "C" fn(*mut PhoshDBusSessionManager, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_register_client: Option<unsafe extern "C" fn(*mut PhoshDBusSessionManager, *mut gio::GDBusMethodInvocation, *const c_char, *const c_char) -> gboolean>,
    pub handle_shutdown: Option<unsafe extern "C" fn(*mut PhoshDBusSessionManager, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_uninhibit: Option<unsafe extern "C" fn(*mut PhoshDBusSessionManager, *mut gio::GDBusMethodInvocation, c_uint) -> gboolean>,
    pub get_session_is_active: Option<unsafe extern "C" fn(*mut PhoshDBusSessionManager) -> gboolean>,
    pub inhibitor_added: Option<unsafe extern "C" fn(*mut PhoshDBusSessionManager, *const c_char)>,
    pub inhibitor_removed: Option<unsafe extern "C" fn(*mut PhoshDBusSessionManager, *const c_char)>,
}

impl ::std::fmt::Debug for PhoshDBusSessionManagerIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusSessionManagerIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_can_shutdown", &self.handle_can_shutdown)
         .field("handle_inhibit", &self.handle_inhibit)
         .field("handle_is_inhibited", &self.handle_is_inhibited)
         .field("handle_logout", &self.handle_logout)
         .field("handle_reboot", &self.handle_reboot)
         .field("handle_register_client", &self.handle_register_client)
         .field("handle_shutdown", &self.handle_shutdown)
         .field("handle_uninhibit", &self.handle_uninhibit)
         .field("get_session_is_active", &self.get_session_is_active)
         .field("inhibitor_added", &self.inhibitor_added)
         .field("inhibitor_removed", &self.inhibitor_removed)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusSessionManagerProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshDBusSessionManagerProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusSessionManagerProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusSessionManagerProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusSessionManagerProxyPrivate = _PhoshDBusSessionManagerProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDBusSessionManagerSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshDBusSessionManagerSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDBusSessionManagerSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshDBusSessionManagerSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshDBusSessionManagerSkeletonPrivate = _PhoshDBusSessionManagerSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDockedInfoClass {
    pub parent_class: PhoshStatusIconClass,
}

impl ::std::fmt::Debug for PhoshDockedInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDockedInfoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshDockedManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshDockedManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshDockedManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshEmergencyCallsIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_call_emergency_contact: Option<unsafe extern "C" fn(*mut PhoshEmergencyCalls, *mut gio::GDBusMethodInvocation, *const c_char) -> gboolean>,
    pub handle_get_emergency_contacts: Option<unsafe extern "C" fn(*mut PhoshEmergencyCalls, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub emergency_numbers_changed: Option<unsafe extern "C" fn(*mut PhoshEmergencyCalls)>,
}

impl ::std::fmt::Debug for PhoshEmergencyCallsIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshEmergencyCallsIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_call_emergency_contact", &self.handle_call_emergency_contact)
         .field("handle_get_emergency_contacts", &self.handle_get_emergency_contacts)
         .field("emergency_numbers_changed", &self.emergency_numbers_changed)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshEmergencyCallsProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshEmergencyCallsProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshEmergencyCallsProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshEmergencyCallsProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshEmergencyCallsProxyPrivate = _PhoshEmergencyCallsProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshEmergencyCallsSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshEmergencyCallsSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshEmergencyCallsSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshEmergencyCallsSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshEmergencyCallsSkeletonPrivate = _PhoshEmergencyCallsSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshEmergencyContactClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshEmergencyContactClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshEmergencyContactClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshEmergencyContactRowClass {
    pub parent_class: handy::HdyActionRowClass,
}

impl ::std::fmt::Debug for PhoshEmergencyContactRowClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshEmergencyContactRowClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshEmergencyMenuClass {
    pub parent_class: PhoshSystemModalDialogClass,
}

impl ::std::fmt::Debug for PhoshEmergencyMenuClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshEmergencyMenuClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshEndSessionDialogClass {
    pub parent_class: PhoshSystemModalDialogClass,
}

impl ::std::fmt::Debug for PhoshEndSessionDialogClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshEndSessionDialogClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshFaderClass {
    pub parent_class: PhoshLayerSurfaceClass,
}

impl ::std::fmt::Debug for PhoshFaderClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshFaderClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshFadingLabelClass {
    pub parent_class: gtk::GtkBinClass,
}

impl ::std::fmt::Debug for PhoshFadingLabelClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshFadingLabelClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshFavoriteListModelClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshFavoriteListModelClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshFavoriteListModelClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshFeedbackInfoClass {
    pub parent_class: PhoshStatusIconClass,
}

impl ::std::fmt::Debug for PhoshFeedbackInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshFeedbackInfoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshFeedbackManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshFeedbackManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshFeedbackManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshFolderInfoClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshFolderInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshFolderInfoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshGeoClueDBusManagerIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_add_agent: Option<unsafe extern "C" fn(*mut PhoshGeoClueDBusManager, *mut gio::GDBusMethodInvocation, *const c_char) -> gboolean>,
    pub get_available_accuracy_level: Option<unsafe extern "C" fn(*mut PhoshGeoClueDBusManager) -> c_uint>,
    pub get_in_use: Option<unsafe extern "C" fn(*mut PhoshGeoClueDBusManager) -> gboolean>,
}

impl ::std::fmt::Debug for PhoshGeoClueDBusManagerIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshGeoClueDBusManagerIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_add_agent", &self.handle_add_agent)
         .field("get_available_accuracy_level", &self.get_available_accuracy_level)
         .field("get_in_use", &self.get_in_use)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshGeoClueDBusManagerProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshGeoClueDBusManagerProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshGeoClueDBusManagerProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshGeoClueDBusManagerProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshGeoClueDBusManagerProxyPrivate = _PhoshGeoClueDBusManagerProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshGeoClueDBusManagerSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshGeoClueDBusManagerSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshGeoClueDBusManagerSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshGeoClueDBusManagerSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshGeoClueDBusManagerSkeletonPrivate = _PhoshGeoClueDBusManagerSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_authorize_app: Option<unsafe extern "C" fn(*mut PhoshGeoClueDBusOrgFreedesktopGeoClue2Agent, *mut gio::GDBusMethodInvocation, *const c_char, c_uint) -> gboolean>,
    pub get_max_accuracy_level: Option<unsafe extern "C" fn(*mut PhoshGeoClueDBusOrgFreedesktopGeoClue2Agent) -> c_uint>,
}

impl ::std::fmt::Debug for PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_authorize_app", &self.handle_authorize_app)
         .field("get_max_accuracy_level", &self.get_max_accuracy_level)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentProxyPrivate = _PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentSkeletonPrivate = _PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshGnomeShellManagerClass {
    pub parent_class: PhoshDBusGnomeShellSkeletonClass,
}

impl ::std::fmt::Debug for PhoshGnomeShellManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshGnomeShellManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshGtkMountManagerClass {
    pub parent_class: PhoshDBusMountOperationHandlerSkeletonClass,
}

impl ::std::fmt::Debug for PhoshGtkMountManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshGtkMountManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshGtkMountPromptClass {
    pub parent_class: PhoshSystemModalDialogClass,
}

impl ::std::fmt::Debug for PhoshGtkMountPromptClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshGtkMountPromptClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshHeadClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshHeadClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshHeadClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshHksInfoClass {
    pub parent_class: PhoshStatusIconClass,
}

impl ::std::fmt::Debug for PhoshHksInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshHksInfoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshHksManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshHksManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshHksManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshIdleDBusIdleMonitorIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_add_idle_watch: Option<unsafe extern "C" fn(*mut PhoshIdleDBusIdleMonitor, *mut gio::GDBusMethodInvocation, u64) -> gboolean>,
    pub handle_add_user_active_watch: Option<unsafe extern "C" fn(*mut PhoshIdleDBusIdleMonitor, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_get_idletime: Option<unsafe extern "C" fn(*mut PhoshIdleDBusIdleMonitor, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_remove_watch: Option<unsafe extern "C" fn(*mut PhoshIdleDBusIdleMonitor, *mut gio::GDBusMethodInvocation, c_uint) -> gboolean>,
    pub watch_fired: Option<unsafe extern "C" fn(*mut PhoshIdleDBusIdleMonitor, c_uint)>,
}

impl ::std::fmt::Debug for PhoshIdleDBusIdleMonitorIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshIdleDBusIdleMonitorIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_add_idle_watch", &self.handle_add_idle_watch)
         .field("handle_add_user_active_watch", &self.handle_add_user_active_watch)
         .field("handle_get_idletime", &self.handle_get_idletime)
         .field("handle_remove_watch", &self.handle_remove_watch)
         .field("watch_fired", &self.watch_fired)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshIdleDBusIdleMonitorProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshIdleDBusIdleMonitorProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshIdleDBusIdleMonitorProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshIdleDBusIdleMonitorProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshIdleDBusIdleMonitorProxyPrivate = _PhoshIdleDBusIdleMonitorProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshIdleDBusIdleMonitorSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshIdleDBusIdleMonitorSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshIdleDBusIdleMonitorSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshIdleDBusIdleMonitorSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshIdleDBusIdleMonitorSkeletonPrivate = _PhoshIdleDBusIdleMonitorSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshIdleDBusObjectIface {
    pub parent_iface: gobject::GTypeInterface,
}

impl ::std::fmt::Debug for PhoshIdleDBusObjectIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshIdleDBusObjectIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshIdleDBusObjectManagerClientClass {
    pub parent_class: gio::GDBusObjectManagerClientClass,
}

impl ::std::fmt::Debug for PhoshIdleDBusObjectManagerClientClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshIdleDBusObjectManagerClientClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshIdleDBusObjectManagerClientPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshIdleDBusObjectManagerClientPrivate = _PhoshIdleDBusObjectManagerClientPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshIdleDBusObjectProxyClass {
    pub parent_class: gio::GDBusObjectProxyClass,
}

impl ::std::fmt::Debug for PhoshIdleDBusObjectProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshIdleDBusObjectProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshIdleDBusObjectProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshIdleDBusObjectProxyPrivate = _PhoshIdleDBusObjectProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshIdleDBusObjectSkeletonClass {
    pub parent_class: gio::GDBusObjectSkeletonClass,
}

impl ::std::fmt::Debug for PhoshIdleDBusObjectSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshIdleDBusObjectSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshIdleDBusObjectSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshIdleDBusObjectSkeletonPrivate = _PhoshIdleDBusObjectSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshIdleManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshIdleManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshIdleManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshKeyboardEventsClass {
    pub parent_class: gio::GSimpleActionGroupClass,
}

impl ::std::fmt::Debug for PhoshKeyboardEventsClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshKeyboardEventsClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshKeypadClass {
    pub parent_class: gtk::GtkGridClass,
}

impl ::std::fmt::Debug for PhoshKeypadClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshKeypadClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshLayerSurfaceClass {
    pub parent_class: gtk::GtkWindowClass,
    pub configured: Option<unsafe extern "C" fn(*mut PhoshLayerSurface)>,
}

impl ::std::fmt::Debug for PhoshLayerSurfaceClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshLayerSurfaceClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .field("configured", &self.configured)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshLayoutManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshLayoutManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshLayoutManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshLocationInfoClass {
    pub parent_class: PhoshStatusIconClass,
}

impl ::std::fmt::Debug for PhoshLocationInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshLocationInfoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshLocationManagerClass {
    pub parent_class: PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentSkeletonClass,
}

impl ::std::fmt::Debug for PhoshLocationManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshLocationManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshLockscreenClass {
    pub parent_class: PhoshLayerSurfaceClass,
    pub unlock_submit: Option<unsafe extern "C" fn(*mut PhoshLockscreen)>,
    pub _phosh_reserved1: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved2: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved3: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved4: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved5: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved6: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved7: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved8: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved9: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for PhoshLockscreenClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshLockscreenClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .field("unlock_submit", &self.unlock_submit)
         .field("_phosh_reserved1", &self._phosh_reserved1)
         .field("_phosh_reserved2", &self._phosh_reserved2)
         .field("_phosh_reserved3", &self._phosh_reserved3)
         .field("_phosh_reserved4", &self._phosh_reserved4)
         .field("_phosh_reserved5", &self._phosh_reserved5)
         .field("_phosh_reserved6", &self._phosh_reserved6)
         .field("_phosh_reserved7", &self._phosh_reserved7)
         .field("_phosh_reserved8", &self._phosh_reserved8)
         .field("_phosh_reserved9", &self._phosh_reserved9)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshLockscreenManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshLockscreenManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshLockscreenManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshLockshieldClass {
    pub parent_class: PhoshLayerSurfaceClass,
}

impl ::std::fmt::Debug for PhoshLockshieldClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshLockshieldClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMMDBusModemIface {
    pub parent_iface: gobject::GTypeInterface,
    pub get_access_technologies: Option<unsafe extern "C" fn(*mut PhoshMMDBusModem) -> c_uint>,
    pub get_signal_quality: Option<unsafe extern "C" fn(*mut PhoshMMDBusModem) -> *mut glib::GVariant>,
    pub get_sim: Option<unsafe extern "C" fn(*mut PhoshMMDBusModem) -> *const c_char>,
    pub get_state: Option<unsafe extern "C" fn(*mut PhoshMMDBusModem) -> c_int>,
    pub get_unlock_required: Option<unsafe extern "C" fn(*mut PhoshMMDBusModem) -> c_uint>,
}

impl ::std::fmt::Debug for PhoshMMDBusModemIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMMDBusModemIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("get_access_technologies", &self.get_access_technologies)
         .field("get_signal_quality", &self.get_signal_quality)
         .field("get_sim", &self.get_sim)
         .field("get_state", &self.get_state)
         .field("get_unlock_required", &self.get_unlock_required)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMMDBusModemModem3gppIface {
    pub parent_iface: gobject::GTypeInterface,
    pub get_operator_name: Option<unsafe extern "C" fn(*mut PhoshMMDBusModemModem3gpp) -> *const c_char>,
}

impl ::std::fmt::Debug for PhoshMMDBusModemModem3gppIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMMDBusModemModem3gppIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("get_operator_name", &self.get_operator_name)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMMDBusModemModem3gppProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshMMDBusModemModem3gppProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMMDBusModemModem3gppProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshMMDBusModemModem3gppProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshMMDBusModemModem3gppProxyPrivate = _PhoshMMDBusModemModem3gppProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMMDBusModemModem3gppSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshMMDBusModemModem3gppSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMMDBusModemModem3gppSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshMMDBusModemModem3gppSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshMMDBusModemModem3gppSkeletonPrivate = _PhoshMMDBusModemModem3gppSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMMDBusModemProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshMMDBusModemProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMMDBusModemProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshMMDBusModemProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshMMDBusModemProxyPrivate = _PhoshMMDBusModemProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMMDBusModemSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshMMDBusModemSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMMDBusModemSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshMMDBusModemSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshMMDBusModemSkeletonPrivate = _PhoshMMDBusModemSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMMDBusObjectIface {
    pub parent_iface: gobject::GTypeInterface,
}

impl ::std::fmt::Debug for PhoshMMDBusObjectIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMMDBusObjectIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMMDBusObjectManagerClientClass {
    pub parent_class: gio::GDBusObjectManagerClientClass,
}

impl ::std::fmt::Debug for PhoshMMDBusObjectManagerClientClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMMDBusObjectManagerClientClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshMMDBusObjectManagerClientPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshMMDBusObjectManagerClientPrivate = _PhoshMMDBusObjectManagerClientPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMMDBusObjectProxyClass {
    pub parent_class: gio::GDBusObjectProxyClass,
}

impl ::std::fmt::Debug for PhoshMMDBusObjectProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMMDBusObjectProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshMMDBusObjectProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshMMDBusObjectProxyPrivate = _PhoshMMDBusObjectProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMMDBusObjectSkeletonClass {
    pub parent_class: gio::GDBusObjectSkeletonClass,
}

impl ::std::fmt::Debug for PhoshMMDBusObjectSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMMDBusObjectSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshMMDBusObjectSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshMMDBusObjectSkeletonPrivate = _PhoshMMDBusObjectSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMediaPlayerClass {
    pub parent_class: gtk::GtkGridClass,
}

impl ::std::fmt::Debug for PhoshMediaPlayerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMediaPlayerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMonitorClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshMonitorClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMonitorClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMonitorManagerClass {
    pub parent_class: PhoshDBusDisplayConfigSkeletonClass,
}

impl ::std::fmt::Debug for PhoshMonitorManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMonitorManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMonitorMode {
    pub width: c_int,
    pub height: c_int,
    pub refresh: c_int,
    pub flags: u32,
}

impl ::std::fmt::Debug for PhoshMonitorMode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMonitorMode @ {self:p}"))
         .field("width", &self.width)
         .field("height", &self.height)
         .field("refresh", &self.refresh)
         .field("flags", &self.flags)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMountManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshMountManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMountManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMountOperationClass {
    pub parent_class: gio::GMountOperationClass,
}

impl ::std::fmt::Debug for PhoshMountOperationClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMountOperationClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMprisDBusMediaPlayer2Iface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_raise: Option<unsafe extern "C" fn(*mut PhoshMprisDBusMediaPlayer2, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub get_can_raise: Option<unsafe extern "C" fn(*mut PhoshMprisDBusMediaPlayer2) -> gboolean>,
    pub get_desktop_entry: Option<unsafe extern "C" fn(*mut PhoshMprisDBusMediaPlayer2) -> *const c_char>,
}

impl ::std::fmt::Debug for PhoshMprisDBusMediaPlayer2Iface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMprisDBusMediaPlayer2Iface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_raise", &self.handle_raise)
         .field("get_can_raise", &self.get_can_raise)
         .field("get_desktop_entry", &self.get_desktop_entry)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMprisDBusMediaPlayer2PlayerIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_next: Option<unsafe extern "C" fn(*mut PhoshMprisDBusMediaPlayer2Player, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_play_pause: Option<unsafe extern "C" fn(*mut PhoshMprisDBusMediaPlayer2Player, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_previous: Option<unsafe extern "C" fn(*mut PhoshMprisDBusMediaPlayer2Player, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_seek: Option<unsafe extern "C" fn(*mut PhoshMprisDBusMediaPlayer2Player, *mut gio::GDBusMethodInvocation, i64) -> gboolean>,
    pub get_can_go_next: Option<unsafe extern "C" fn(*mut PhoshMprisDBusMediaPlayer2Player) -> gboolean>,
    pub get_can_go_previous: Option<unsafe extern "C" fn(*mut PhoshMprisDBusMediaPlayer2Player) -> gboolean>,
    pub get_can_play: Option<unsafe extern "C" fn(*mut PhoshMprisDBusMediaPlayer2Player) -> gboolean>,
    pub get_can_seek: Option<unsafe extern "C" fn(*mut PhoshMprisDBusMediaPlayer2Player) -> gboolean>,
    pub get_metadata: Option<unsafe extern "C" fn(*mut PhoshMprisDBusMediaPlayer2Player) -> *mut glib::GVariant>,
    pub get_playback_status: Option<unsafe extern "C" fn(*mut PhoshMprisDBusMediaPlayer2Player) -> *const c_char>,
}

impl ::std::fmt::Debug for PhoshMprisDBusMediaPlayer2PlayerIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMprisDBusMediaPlayer2PlayerIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_next", &self.handle_next)
         .field("handle_play_pause", &self.handle_play_pause)
         .field("handle_previous", &self.handle_previous)
         .field("handle_seek", &self.handle_seek)
         .field("get_can_go_next", &self.get_can_go_next)
         .field("get_can_go_previous", &self.get_can_go_previous)
         .field("get_can_play", &self.get_can_play)
         .field("get_can_seek", &self.get_can_seek)
         .field("get_metadata", &self.get_metadata)
         .field("get_playback_status", &self.get_playback_status)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMprisDBusMediaPlayer2PlayerProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshMprisDBusMediaPlayer2PlayerProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMprisDBusMediaPlayer2PlayerProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshMprisDBusMediaPlayer2PlayerProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshMprisDBusMediaPlayer2PlayerProxyPrivate = _PhoshMprisDBusMediaPlayer2PlayerProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMprisDBusMediaPlayer2PlayerSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshMprisDBusMediaPlayer2PlayerSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMprisDBusMediaPlayer2PlayerSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshMprisDBusMediaPlayer2PlayerSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshMprisDBusMediaPlayer2PlayerSkeletonPrivate = _PhoshMprisDBusMediaPlayer2PlayerSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMprisDBusMediaPlayer2ProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshMprisDBusMediaPlayer2ProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMprisDBusMediaPlayer2ProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshMprisDBusMediaPlayer2ProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshMprisDBusMediaPlayer2ProxyPrivate = _PhoshMprisDBusMediaPlayer2ProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshMprisDBusMediaPlayer2SkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshMprisDBusMediaPlayer2SkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshMprisDBusMediaPlayer2SkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshMprisDBusMediaPlayer2SkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshMprisDBusMediaPlayer2SkeletonPrivate = _PhoshMprisDBusMediaPlayer2SkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshNetworkAuthManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshNetworkAuthManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshNetworkAuthManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshNotificationBannerClass {
    pub parent_class: PhoshLayerSurfaceClass,
}

impl ::std::fmt::Debug for PhoshNotificationBannerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshNotificationBannerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshNotificationContentClass {
    pub parent_class: gtk::GtkListBoxRowClass,
}

impl ::std::fmt::Debug for PhoshNotificationContentClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshNotificationContentClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshNotificationFrameClass {
    pub parent_class: gtk::GtkEventBoxClass,
}

impl ::std::fmt::Debug for PhoshNotificationFrameClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshNotificationFrameClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshNotificationListClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshNotificationListClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshNotificationListClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshNotificationSourceClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshNotificationSourceClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshNotificationSourceClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshNotifyDBusNotificationsIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_close_notification: Option<unsafe extern "C" fn(*mut PhoshNotifyDBusNotifications, *mut gio::GDBusMethodInvocation, c_uint) -> gboolean>,
    pub handle_get_capabilities: Option<unsafe extern "C" fn(*mut PhoshNotifyDBusNotifications, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_get_server_information: Option<unsafe extern "C" fn(*mut PhoshNotifyDBusNotifications, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_notify: Option<unsafe extern "C" fn(*mut PhoshNotifyDBusNotifications, *mut gio::GDBusMethodInvocation, *const c_char, c_uint, *const c_char, *const c_char, *const c_char, *const *const c_char, *mut glib::GVariant, c_int) -> gboolean>,
    pub action_invoked: Option<unsafe extern "C" fn(*mut PhoshNotifyDBusNotifications, c_uint, *const c_char)>,
    pub notification_closed: Option<unsafe extern "C" fn(*mut PhoshNotifyDBusNotifications, c_uint, c_uint)>,
}

impl ::std::fmt::Debug for PhoshNotifyDBusNotificationsIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshNotifyDBusNotificationsIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_close_notification", &self.handle_close_notification)
         .field("handle_get_capabilities", &self.handle_get_capabilities)
         .field("handle_get_server_information", &self.handle_get_server_information)
         .field("handle_notify", &self.handle_notify)
         .field("action_invoked", &self.action_invoked)
         .field("notification_closed", &self.notification_closed)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshNotifyDBusNotificationsProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshNotifyDBusNotificationsProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshNotifyDBusNotificationsProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshNotifyDBusNotificationsProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshNotifyDBusNotificationsProxyPrivate = _PhoshNotifyDBusNotificationsProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshNotifyDBusNotificationsSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshNotifyDBusNotificationsSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshNotifyDBusNotificationsSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshNotifyDBusNotificationsSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshNotifyDBusNotificationsSkeletonPrivate = _PhoshNotifyDBusNotificationsSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshNotifyFeedbackClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshNotifyFeedbackClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshNotifyFeedbackClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshNotifyManagerClass {
    pub parent_class: PhoshNotifyDBusNotificationsSkeletonClass,
}

impl ::std::fmt::Debug for PhoshNotifyManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshNotifyManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOfonoDBusManagerIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_get_modems: Option<unsafe extern "C" fn(*mut PhoshOfonoDBusManager, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub modem_added: Option<unsafe extern "C" fn(*mut PhoshOfonoDBusManager, *const c_char, *mut glib::GVariant)>,
    pub modem_removed: Option<unsafe extern "C" fn(*mut PhoshOfonoDBusManager, *const c_char)>,
}

impl ::std::fmt::Debug for PhoshOfonoDBusManagerIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOfonoDBusManagerIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_get_modems", &self.handle_get_modems)
         .field("modem_added", &self.modem_added)
         .field("modem_removed", &self.modem_removed)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOfonoDBusManagerProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshOfonoDBusManagerProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOfonoDBusManagerProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshOfonoDBusManagerProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshOfonoDBusManagerProxyPrivate = _PhoshOfonoDBusManagerProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOfonoDBusManagerSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshOfonoDBusManagerSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOfonoDBusManagerSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshOfonoDBusManagerSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshOfonoDBusManagerSkeletonPrivate = _PhoshOfonoDBusManagerSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOfonoDBusNetworkRegistrationIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_get_properties: Option<unsafe extern "C" fn(*mut PhoshOfonoDBusNetworkRegistration, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub property_changed: Option<unsafe extern "C" fn(*mut PhoshOfonoDBusNetworkRegistration, *const c_char, *mut glib::GVariant)>,
}

impl ::std::fmt::Debug for PhoshOfonoDBusNetworkRegistrationIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOfonoDBusNetworkRegistrationIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_get_properties", &self.handle_get_properties)
         .field("property_changed", &self.property_changed)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOfonoDBusNetworkRegistrationProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshOfonoDBusNetworkRegistrationProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOfonoDBusNetworkRegistrationProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshOfonoDBusNetworkRegistrationProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshOfonoDBusNetworkRegistrationProxyPrivate = _PhoshOfonoDBusNetworkRegistrationProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOfonoDBusNetworkRegistrationSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshOfonoDBusNetworkRegistrationSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOfonoDBusNetworkRegistrationSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshOfonoDBusNetworkRegistrationSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshOfonoDBusNetworkRegistrationSkeletonPrivate = _PhoshOfonoDBusNetworkRegistrationSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOfonoDBusSimManagerIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_get_properties: Option<unsafe extern "C" fn(*mut PhoshOfonoDBusSimManager, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub property_changed: Option<unsafe extern "C" fn(*mut PhoshOfonoDBusSimManager, *const c_char, *mut glib::GVariant)>,
}

impl ::std::fmt::Debug for PhoshOfonoDBusSimManagerIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOfonoDBusSimManagerIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_get_properties", &self.handle_get_properties)
         .field("property_changed", &self.property_changed)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOfonoDBusSimManagerProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshOfonoDBusSimManagerProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOfonoDBusSimManagerProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshOfonoDBusSimManagerProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshOfonoDBusSimManagerProxyPrivate = _PhoshOfonoDBusSimManagerProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOfonoDBusSimManagerSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshOfonoDBusSimManagerSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOfonoDBusSimManagerSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshOfonoDBusSimManagerSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshOfonoDBusSimManagerSkeletonPrivate = _PhoshOfonoDBusSimManagerSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOsdWindowClass {
    pub parent_class: PhoshSystemModalClass,
}

impl ::std::fmt::Debug for PhoshOsdWindowClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOsdWindowClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOsk0SmPuriOSK0Iface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_set_visible: Option<unsafe extern "C" fn(*mut PhoshOsk0SmPuriOSK0, *mut gio::GDBusMethodInvocation, gboolean) -> gboolean>,
    pub get_visible: Option<unsafe extern "C" fn(*mut PhoshOsk0SmPuriOSK0) -> gboolean>,
}

impl ::std::fmt::Debug for PhoshOsk0SmPuriOSK0Iface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOsk0SmPuriOSK0Iface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_set_visible", &self.handle_set_visible)
         .field("get_visible", &self.get_visible)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOsk0SmPuriOSK0ProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshOsk0SmPuriOSK0ProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOsk0SmPuriOSK0ProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshOsk0SmPuriOSK0ProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshOsk0SmPuriOSK0ProxyPrivate = _PhoshOsk0SmPuriOSK0ProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOsk0SmPuriOSK0SkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshOsk0SmPuriOSK0SkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOsk0SmPuriOSK0SkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshOsk0SmPuriOSK0SkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshOsk0SmPuriOSK0SkeletonPrivate = _PhoshOsk0SmPuriOSK0SkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOskButtonClass {
    pub parent_class: gtk::GtkToggleButtonClass,
}

impl ::std::fmt::Debug for PhoshOskButtonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOskButtonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOskManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshOskManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOskManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshOverviewClass {
    pub parent_class: gtk::GtkBoxClass,
}

impl ::std::fmt::Debug for PhoshOverviewClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshOverviewClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshPasswordEntryClass {
    pub parent_class: gtk::GtkEntryClass,
}

impl ::std::fmt::Debug for PhoshPasswordEntryClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshPasswordEntryClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshPluginLoaderClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshPluginLoaderClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshPluginLoaderClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshPolkitAuthPromptClass {
    pub parent_class: PhoshSystemModalDialogClass,
}

impl ::std::fmt::Debug for PhoshPolkitAuthPromptClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshPolkitAuthPromptClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshPortalAccessManagerClass {
    pub parent_class: PhoshDBusImplPortalAccessSkeletonClass,
}

impl ::std::fmt::Debug for PhoshPortalAccessManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshPortalAccessManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshPortalRequestClass {
    pub parent_class: PhoshDBusImplPortalRequestSkeletonClass,
}

impl ::std::fmt::Debug for PhoshPortalRequestClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshPortalRequestClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshPowerMenuClass {
    pub parent_class: PhoshSystemModalDialogClass,
}

impl ::std::fmt::Debug for PhoshPowerMenuClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshPowerMenuClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshPowerMenuManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshPowerMenuManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshPowerMenuManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshProximityClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshProximityClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshProximityClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshQuickSettingClass {
    pub parent_class: gtk::GtkButtonClass,
}

impl ::std::fmt::Debug for PhoshQuickSettingClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshQuickSettingClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshRevealerClass {
    pub parent_class: gtk::GtkRevealerClass,
}

impl ::std::fmt::Debug for PhoshRevealerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshRevealerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshRfkillDBusRfkillIface {
    pub parent_iface: gobject::GTypeInterface,
    pub get_airplane_mode: Option<unsafe extern "C" fn(*mut PhoshRfkillDBusRfkill) -> gboolean>,
    pub get_bluetooth_airplane_mode: Option<unsafe extern "C" fn(*mut PhoshRfkillDBusRfkill) -> gboolean>,
    pub get_bluetooth_hardware_airplane_mode: Option<unsafe extern "C" fn(*mut PhoshRfkillDBusRfkill) -> gboolean>,
    pub get_bluetooth_has_airplane_mode: Option<unsafe extern "C" fn(*mut PhoshRfkillDBusRfkill) -> gboolean>,
    pub get_hardware_airplane_mode: Option<unsafe extern "C" fn(*mut PhoshRfkillDBusRfkill) -> gboolean>,
    pub get_should_show_airplane_mode: Option<unsafe extern "C" fn(*mut PhoshRfkillDBusRfkill) -> gboolean>,
}

impl ::std::fmt::Debug for PhoshRfkillDBusRfkillIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshRfkillDBusRfkillIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("get_airplane_mode", &self.get_airplane_mode)
         .field("get_bluetooth_airplane_mode", &self.get_bluetooth_airplane_mode)
         .field("get_bluetooth_hardware_airplane_mode", &self.get_bluetooth_hardware_airplane_mode)
         .field("get_bluetooth_has_airplane_mode", &self.get_bluetooth_has_airplane_mode)
         .field("get_hardware_airplane_mode", &self.get_hardware_airplane_mode)
         .field("get_should_show_airplane_mode", &self.get_should_show_airplane_mode)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshRfkillDBusRfkillProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshRfkillDBusRfkillProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshRfkillDBusRfkillProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshRfkillDBusRfkillProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshRfkillDBusRfkillProxyPrivate = _PhoshRfkillDBusRfkillProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshRfkillDBusRfkillSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshRfkillDBusRfkillSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshRfkillDBusRfkillSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshRfkillDBusRfkillSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshRfkillDBusRfkillSkeletonPrivate = _PhoshRfkillDBusRfkillSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshRotateInfoClass {
    pub parent_class: PhoshStatusIconClass,
}

impl ::std::fmt::Debug for PhoshRotateInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshRotateInfoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshRotationManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshRotationManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshRotationManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshRunCommandDialogClass {
    pub parent_class: PhoshSystemModalDialogClass,
}

impl ::std::fmt::Debug for PhoshRunCommandDialogClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshRunCommandDialogClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshRunCommandManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshRunCommandManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshRunCommandManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshScreenSaverManagerClass {
    pub parent_class: PhoshDBusScreenSaverSkeletonClass,
}

impl ::std::fmt::Debug for PhoshScreenSaverManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshScreenSaverManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshScreenshotManagerClass {
    pub parent_class: PhoshDBusScreenshotSkeletonClass,
}

impl ::std::fmt::Debug for PhoshScreenshotManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshScreenshotManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSensorProxyManagerClass {
    pub parent_class: PhoshDBusSensorProxyProxyClass,
}

impl ::std::fmt::Debug for PhoshSensorProxyManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSensorProxyManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSessionClientPrivateDBusClientPrivateIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_end_session_response: Option<unsafe extern "C" fn(*mut PhoshSessionClientPrivateDBusClientPrivate, *mut gio::GDBusMethodInvocation, gboolean, *const c_char) -> gboolean>,
    pub cancel_end_session: Option<unsafe extern "C" fn(*mut PhoshSessionClientPrivateDBusClientPrivate)>,
    pub end_session: Option<unsafe extern "C" fn(*mut PhoshSessionClientPrivateDBusClientPrivate, c_uint)>,
    pub query_end_session: Option<unsafe extern "C" fn(*mut PhoshSessionClientPrivateDBusClientPrivate, c_uint)>,
    pub stop: Option<unsafe extern "C" fn(*mut PhoshSessionClientPrivateDBusClientPrivate)>,
}

impl ::std::fmt::Debug for PhoshSessionClientPrivateDBusClientPrivateIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSessionClientPrivateDBusClientPrivateIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("handle_end_session_response", &self.handle_end_session_response)
         .field("cancel_end_session", &self.cancel_end_session)
         .field("end_session", &self.end_session)
         .field("query_end_session", &self.query_end_session)
         .field("stop", &self.stop)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSessionClientPrivateDBusClientPrivateProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshSessionClientPrivateDBusClientPrivateProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSessionClientPrivateDBusClientPrivateProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshSessionClientPrivateDBusClientPrivateProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshSessionClientPrivateDBusClientPrivateProxyPrivate = _PhoshSessionClientPrivateDBusClientPrivateProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSessionClientPrivateDBusClientPrivateSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshSessionClientPrivateDBusClientPrivateSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSessionClientPrivateDBusClientPrivateSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshSessionClientPrivateDBusClientPrivateSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshSessionClientPrivateDBusClientPrivateSkeletonPrivate = _PhoshSessionClientPrivateDBusClientPrivateSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSessionManagerClass {
    pub parent_class: PhoshDBusEndSessionDialogSkeletonClass,
}

impl ::std::fmt::Debug for PhoshSessionManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSessionManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSessionPresenceClass {
    pub parent_class: PhoshSessionPresenceDBusPresenceProxyClass,
}

impl ::std::fmt::Debug for PhoshSessionPresenceClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSessionPresenceClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSessionPresenceDBusPresenceIface {
    pub parent_iface: gobject::GTypeInterface,
    pub get_status: Option<unsafe extern "C" fn(*mut PhoshSessionPresenceDBusPresence) -> c_uint>,
    pub status_changed: Option<unsafe extern "C" fn(*mut PhoshSessionPresenceDBusPresence, c_uint)>,
}

impl ::std::fmt::Debug for PhoshSessionPresenceDBusPresenceIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSessionPresenceDBusPresenceIface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("get_status", &self.get_status)
         .field("status_changed", &self.status_changed)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSessionPresenceDBusPresenceProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for PhoshSessionPresenceDBusPresenceProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSessionPresenceDBusPresenceProxyClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshSessionPresenceDBusPresenceProxyPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshSessionPresenceDBusPresenceProxyPrivate = _PhoshSessionPresenceDBusPresenceProxyPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSessionPresenceDBusPresenceSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for PhoshSessionPresenceDBusPresenceSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSessionPresenceDBusPresenceSkeletonClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _PhoshSessionPresenceDBusPresenceSkeletonPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PhoshSessionPresenceDBusPresenceSkeletonPrivate = _PhoshSessionPresenceDBusPresenceSkeletonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshShellClass {
    pub parent_class: gobject::GObjectClass,
    pub get_lockscreen_type: Option<unsafe extern "C" fn(*mut PhoshShell) -> GType>,
    pub _phosh_reserved1: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved2: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved3: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved4: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved5: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved6: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved7: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved8: Option<unsafe extern "C" fn()>,
    pub _phosh_reserved9: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for PhoshShellClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshShellClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .field("get_lockscreen_type", &self.get_lockscreen_type)
         .field("_phosh_reserved1", &self._phosh_reserved1)
         .field("_phosh_reserved2", &self._phosh_reserved2)
         .field("_phosh_reserved3", &self._phosh_reserved3)
         .field("_phosh_reserved4", &self._phosh_reserved4)
         .field("_phosh_reserved5", &self._phosh_reserved5)
         .field("_phosh_reserved6", &self._phosh_reserved6)
         .field("_phosh_reserved7", &self._phosh_reserved7)
         .field("_phosh_reserved8", &self._phosh_reserved8)
         .field("_phosh_reserved9", &self._phosh_reserved9)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSplashClass {
    pub parent_class: PhoshLayerSurfaceClass,
}

impl ::std::fmt::Debug for PhoshSplashClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSplashClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSplashManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshSplashManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSplashManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshStatusIconClass {
    pub parent_class: gtk::GtkBinClass,
    pub idle_init: Option<unsafe extern "C" fn(*mut PhoshStatusIcon)>,
}

impl ::std::fmt::Debug for PhoshStatusIconClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshStatusIconClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .field("idle_init", &self.idle_init)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshStatusPageClass {
    pub parent_class: gtk::GtkBinClass,
}

impl ::std::fmt::Debug for PhoshStatusPageClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshStatusPageClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshStatusPagePlaceholderClass {
    pub parent_class: gtk::GtkBinClass,
}

impl ::std::fmt::Debug for PhoshStatusPagePlaceholderClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshStatusPagePlaceholderClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSwipeAwayBinClass {
    pub parent_class: gtk::GtkEventBoxClass,
}

impl ::std::fmt::Debug for PhoshSwipeAwayBinClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSwipeAwayBinClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSystemModalClass {
    pub parent_class: PhoshLayerSurfaceClass,
}

impl ::std::fmt::Debug for PhoshSystemModalClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSystemModalClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshSystemModalDialogClass {
    pub parent_class: PhoshSystemModalClass,
}

impl ::std::fmt::Debug for PhoshSystemModalDialogClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshSystemModalDialogClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshTimestampLabelClass {
    pub parent_class: gtk::GtkLabelClass,
}

impl ::std::fmt::Debug for PhoshTimestampLabelClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshTimestampLabelClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshToplevelClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshToplevelClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshToplevelClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshToplevelManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshToplevelManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshToplevelManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshTorchInfoClass {
    pub parent_class: PhoshStatusIconClass,
}

impl ::std::fmt::Debug for PhoshTorchInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshTorchInfoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshVpnInfoClass {
    pub parent_class: PhoshStatusIconClass,
}

impl ::std::fmt::Debug for PhoshVpnInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshVpnInfoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshVpnManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshVpnManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshVpnManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWWanInfoClass {
    pub parent_class: PhoshStatusIconClass,
}

impl ::std::fmt::Debug for PhoshWWanInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWWanInfoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWWanInterface {
    pub parent_iface: gobject::GTypeInterface,
    pub get_signal_quality: Option<unsafe extern "C" fn(*mut PhoshWWan) -> c_uint>,
    pub get_access_tec: Option<unsafe extern "C" fn(*mut PhoshWWan) -> *const c_char>,
    pub is_unlocked: Option<unsafe extern "C" fn(*mut PhoshWWan) -> gboolean>,
    pub has_sim: Option<unsafe extern "C" fn(*mut PhoshWWan) -> gboolean>,
    pub is_present: Option<unsafe extern "C" fn(*mut PhoshWWan) -> gboolean>,
    pub is_enabled: Option<unsafe extern "C" fn(*mut PhoshWWan) -> gboolean>,
    pub get_operator: Option<unsafe extern "C" fn(*mut PhoshWWan) -> *const c_char>,
}

impl ::std::fmt::Debug for PhoshWWanInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWWanInterface @ {self:p}"))
         .field("parent_iface", &self.parent_iface)
         .field("get_signal_quality", &self.get_signal_quality)
         .field("get_access_tec", &self.get_access_tec)
         .field("is_unlocked", &self.is_unlocked)
         .field("has_sim", &self.has_sim)
         .field("is_present", &self.is_present)
         .field("is_enabled", &self.is_enabled)
         .field("get_operator", &self.get_operator)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWWanMMClass {
    pub parent_class: PhoshWWanManagerClass,
}

impl ::std::fmt::Debug for PhoshWWanMMClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWWanMMClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWWanManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshWWanManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWWanManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWWanOfonoClass {
    pub parent_class: PhoshWWanManagerClass,
}

impl ::std::fmt::Debug for PhoshWWanOfonoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWWanOfonoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWallClockClass {
    pub parent_class: gobject::GObjectClass,
    pub get_clock: Option<unsafe extern "C" fn(*mut PhoshWallClock, gboolean) -> *const c_char>,
    pub get_time_t: Option<unsafe extern "C" fn(*mut PhoshWallClock) -> i64>,
}

impl ::std::fmt::Debug for PhoshWallClockClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWallClockClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .field("get_clock", &self.get_clock)
         .field("get_time_t", &self.get_time_t)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWaylandClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshWaylandClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWaylandClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWidgetBoxClass {
    pub parent_class: gtk::GtkBoxClass,
}

impl ::std::fmt::Debug for PhoshWidgetBoxClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWidgetBoxClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWifiInfoClass {
    pub parent_class: PhoshStatusIconClass,
}

impl ::std::fmt::Debug for PhoshWifiInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWifiInfoClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWifiManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshWifiManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWifiManagerClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWifiNetworkClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PhoshWifiNetworkClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWifiNetworkClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWifiNetworkRowClass {
    pub parent_class: handy::HdyActionRowClass,
}

impl ::std::fmt::Debug for PhoshWifiNetworkRowClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWifiNetworkRowClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWifiStatusPageClass {
    pub parent_class: PhoshStatusPageClass,
}

impl ::std::fmt::Debug for PhoshWifiStatusPageClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWifiStatusPageClass @ {self:p}"))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

// Classes
#[repr(C)]
pub struct PhoshActivity {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshActivity {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshActivity @ {self:p}"))
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshLayerSurface {
    pub parent_instance: gtk::GtkWindow,
}

impl ::std::fmt::Debug for PhoshLayerSurface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshLayerSurface @ {self:p}"))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshLockscreen {
    pub parent_instance: PhoshLayerSurface,
}

impl ::std::fmt::Debug for PhoshLockscreen {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshLockscreen @ {self:p}"))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct PhoshRevealer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshRevealer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshRevealer @ {self:p}"))
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshShell {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PhoshShell {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshShell @ {self:p}"))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshStatusIcon {
    pub parent_instance: gtk::GtkBin,
}

impl ::std::fmt::Debug for PhoshStatusIcon {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshStatusIcon @ {self:p}"))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct PhoshStatusPagePlaceholder {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshStatusPagePlaceholder {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshStatusPagePlaceholder @ {self:p}"))
         .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhoshWallClock {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PhoshWallClock {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWallClock @ {self:p}"))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct PhoshWifiNetworkRow {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshWifiNetworkRow {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PhoshWifiNetworkRow @ {self:p}"))
         .finish()
    }
}

// Interfaces
#[repr(C)]
pub struct PhoshCallsDBusCallsCall {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshCallsDBusCallsCall {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshCallsDBusCallsCall @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshCallsDBusObject {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshCallsDBusObject {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshCallsDBusObject @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusColor {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusColor {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusColor @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusDisplayConfig {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusDisplayConfig {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusDisplayConfig @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusEndSessionDialog {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusEndSessionDialog {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusEndSessionDialog @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusGnomeShell {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusGnomeShell {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusGnomeShell @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusHostname1 {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusHostname1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusHostname1 @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusImplPortalAccess {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusImplPortalAccess {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusImplPortalAccess @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusImplPortalRequest {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusImplPortalRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusImplPortalRequest @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusLoginManager {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusLoginManager {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusLoginManager @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusLoginSession {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusLoginSession {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusLoginSession @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusMountOperationHandler {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusMountOperationHandler {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusMountOperationHandler @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusScreenSaver {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusScreenSaver {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusScreenSaver @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusScreenshot {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusScreenshot {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusScreenshot @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusSensorProxy {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusSensorProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusSensorProxy @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusSensorProxyCompass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusSensorProxyCompass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusSensorProxyCompass @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshDBusSessionManager {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshDBusSessionManager {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshDBusSessionManager @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshEmergencyCalls {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshEmergencyCalls {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshEmergencyCalls @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshGeoClueDBusManager {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshGeoClueDBusManager {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshGeoClueDBusManager @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshGeoClueDBusOrgFreedesktopGeoClue2Agent {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshGeoClueDBusOrgFreedesktopGeoClue2Agent {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshGeoClueDBusOrgFreedesktopGeoClue2Agent @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshIdleDBusIdleMonitor {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshIdleDBusIdleMonitor {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshIdleDBusIdleMonitor @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshIdleDBusObject {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshIdleDBusObject {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshIdleDBusObject @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshMMDBusModem {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshMMDBusModem {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshMMDBusModem @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshMMDBusModemModem3gpp {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshMMDBusModemModem3gpp {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshMMDBusModemModem3gpp @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshMMDBusObject {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshMMDBusObject {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshMMDBusObject @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshMprisDBusMediaPlayer2 {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshMprisDBusMediaPlayer2 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshMprisDBusMediaPlayer2 @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshMprisDBusMediaPlayer2Player {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshMprisDBusMediaPlayer2Player {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshMprisDBusMediaPlayer2Player @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshNotifyDBusNotifications {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshNotifyDBusNotifications {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshNotifyDBusNotifications @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshOfonoDBusManager {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshOfonoDBusManager {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshOfonoDBusManager @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshOfonoDBusNetworkRegistration {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshOfonoDBusNetworkRegistration {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshOfonoDBusNetworkRegistration @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshOfonoDBusSimManager {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshOfonoDBusSimManager {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshOfonoDBusSimManager @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshOsk0SmPuriOSK0 {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshOsk0SmPuriOSK0 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshOsk0SmPuriOSK0 @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshRfkillDBusRfkill {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshRfkillDBusRfkill {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshRfkillDBusRfkill @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshSessionClientPrivateDBusClientPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshSessionClientPrivateDBusClientPrivate {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshSessionClientPrivateDBusClientPrivate @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshSessionPresenceDBusPresence {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshSessionPresenceDBusPresence {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshSessionPresenceDBusPresence @ {self:p}")
    }
}

#[repr(C)]
pub struct PhoshWWan {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PhoshWWan {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PhoshWWan @ {self:p}")
    }
}


#[link(name = "phosh")]
extern "C" {

    //=========================================================================
    // PhoshAnimationType
    //=========================================================================
    pub fn phosh_animation_type_get_type() -> GType;

    //=========================================================================
    // PhoshAppGridButtonMode
    //=========================================================================
    pub fn phosh_app_grid_button_mode_get_type() -> GType;

    //=========================================================================
    // PhoshDragSurfaceDragMode
    //=========================================================================
    pub fn phosh_drag_surface_drag_mode_get_type() -> GType;

    //=========================================================================
    // PhoshDragSurfaceState
    //=========================================================================
    pub fn phosh_drag_surface_state_get_type() -> GType;

    //=========================================================================
    // PhoshHomeState
    //=========================================================================
    pub fn phosh_home_state_get_type() -> GType;

    //=========================================================================
    // PhoshLayoutClockPosition
    //=========================================================================
    pub fn phosh_layout_clock_position_get_type() -> GType;

    //=========================================================================
    // PhoshLockscreenPage
    //=========================================================================
    pub fn phosh_lockscreen_page_get_type() -> GType;

    //=========================================================================
    // PhoshModeDeviceType
    //=========================================================================
    pub fn phosh_mode_device_type_get_type() -> GType;

    //=========================================================================
    // PhoshMonitorConnectorType
    //=========================================================================
    pub fn phosh_monitor_connector_type_get_type() -> GType;
    pub fn phosh_monitor_connector_type_from_name(name: *const c_char) -> PhoshMonitorConnectorType;

    //=========================================================================
    // PhoshMonitorPowerSaveMode
    //=========================================================================
    pub fn phosh_monitor_power_save_mode_get_type() -> GType;

    //=========================================================================
    // PhoshMonitorTransform
    //=========================================================================
    pub fn phosh_monitor_transform_get_type() -> GType;
    pub fn phosh_monitor_transform_is_tilted(transform: PhoshMonitorTransform) -> gboolean;

    //=========================================================================
    // PhoshNotificationReason
    //=========================================================================
    pub fn phosh_notification_reason_get_type() -> GType;

    //=========================================================================
    // PhoshNotificationUrgency
    //=========================================================================
    pub fn phosh_notification_urgency_get_type() -> GType;

    //=========================================================================
    // PhoshRotationManagerMode
    //=========================================================================
    pub fn phosh_rotation_manager_mode_get_type() -> GType;

    //=========================================================================
    // PhoshShellLayout
    //=========================================================================
    pub fn phosh_shell_layout_get_type() -> GType;

    //=========================================================================
    // PhoshTopPanelState
    //=========================================================================
    pub fn phosh_top_panel_state_get_type() -> GType;

    //=========================================================================
    // PhoshWWanBackend
    //=========================================================================
    pub fn phosh_wwan_backend_get_type() -> GType;

    //=========================================================================
    // PhoshAppFilterModeFlags
    //=========================================================================
    pub fn phosh_app_filter_mode_flags_get_type() -> GType;

    //=========================================================================
    // PhoshModeHwFlags
    //=========================================================================
    pub fn phosh_mode_hw_flags_get_type() -> GType;

    //=========================================================================
    // PhoshNotifyScreenWakeupFlags
    //=========================================================================
    pub fn phosh_notify_screen_wakeup_flags_get_type() -> GType;

    //=========================================================================
    // PhoshShellActionMode
    //=========================================================================
    pub fn phosh_shell_action_mode_get_type() -> GType;

    //=========================================================================
    // PhoshShellDebugFlags
    //=========================================================================
    pub fn phosh_shell_debug_flags_get_type() -> GType;

    //=========================================================================
    // PhoshShellKeyBindingFlags
    //=========================================================================
    pub fn phosh_shell_key_binding_flags_get_type() -> GType;

    //=========================================================================
    // PhoshShellStateFlags
    //=========================================================================
    pub fn phosh_shell_state_flags_get_type() -> GType;

    //=========================================================================
    // PhoshWaylandSeatCapabilities
    //=========================================================================
    pub fn phosh_wayland_seat_capabilities_get_type() -> GType;

    //=========================================================================
    // PhoshAnimation
    //=========================================================================
    pub fn phosh_animation_get_type() -> GType;
    pub fn phosh_animation_new(widget: *mut gtk::GtkWidget, from: c_double, to: c_double, duration: i64, type_: PhoshAnimationType, value_cb: PhoshAnimationValueCallback, done_cb: PhoshAnimationDoneCallback, user_data: gpointer) -> *mut PhoshAnimation;
    pub fn phosh_animation_get_value(self_: *mut PhoshAnimation) -> c_double;
    pub fn phosh_animation_ref(self_: *mut PhoshAnimation) -> *mut PhoshAnimation;
    pub fn phosh_animation_start(self_: *mut PhoshAnimation);
    pub fn phosh_animation_stop(self_: *mut PhoshAnimation);
    pub fn phosh_animation_unref(self_: *mut PhoshAnimation);

    //=========================================================================
    // PhoshBackgroundData
    //=========================================================================
    //pub fn phosh_background_data_free(bg_data: /*Ignored*/*mut PhoshBackgroundData);

    //=========================================================================
    // PhoshWlBuffer
    //=========================================================================
    //pub fn phosh_wl_buffer_destroy(self_: /*Ignored*/*mut PhoshWlBuffer);
    //pub fn phosh_wl_buffer_get_bytes(self_: /*Ignored*/*mut PhoshWlBuffer) -> *mut glib::GBytes;
    //pub fn phosh_wl_buffer_get_size(self_: /*Ignored*/*mut PhoshWlBuffer) -> size_t;
    //pub fn phosh_wl_buffer_new(format: wl_shm_format, width: u32, height: u32, stride: u32) -> /*Ignored*/*mut PhoshWlBuffer;

    //=========================================================================
    // PhoshActivity
    //=========================================================================
    pub fn phosh_activity_get_type() -> GType;
    pub fn phosh_activity_new(app_id: *const c_char) -> *mut gtk::GtkWidget;
    pub fn phosh_activity_get_app_id(self_: *mut PhoshActivity) -> *const c_char;
    pub fn phosh_activity_get_thumbnail_allocation(self_: *mut PhoshActivity, allocation: *mut gtk::GtkAllocation);
    //pub fn phosh_activity_set_thumbnail(self_: *mut PhoshActivity, thumbnail: /*Ignored*/*mut PhoshThumbnail);

    //=========================================================================
    // PhoshAmbient
    //=========================================================================
    pub fn phosh_ambient_get_type() -> GType;
    //pub fn phosh_ambient_new(sensor_proxy_manager: /*Ignored*/*mut PhoshSensorProxyManager) -> /*Ignored*/*mut PhoshAmbient;

    //=========================================================================
    // PhoshAppAuthPrompt
    //=========================================================================
    pub fn phosh_app_auth_prompt_get_type() -> GType;
    pub fn phosh_app_auth_prompt_new(icon: *mut gio::GIcon, title: *const c_char, subtitle: *const c_char, body: *const c_char, grant_label: *const c_char, deny_label: *const c_char, offer_remember: gboolean, choices: *mut glib::GVariant) -> *mut gtk::GtkWidget;
    pub fn phosh_app_auth_prompt_get_grant_access(self_: *mut gtk::GtkWidget) -> gboolean;
    pub fn phosh_app_auth_prompt_get_remember(self_: *mut gtk::GtkWidget) -> gboolean;
    pub fn phosh_app_auth_prompt_get_selected_choices(self_: *mut gtk::GtkWidget) -> *mut glib::GVariant;

    //=========================================================================
    // PhoshAppGrid
    //=========================================================================
    pub fn phosh_app_grid_get_type() -> GType;
    pub fn phosh_app_grid_new() -> *mut gtk::GtkWidget;
    //pub fn phosh_app_grid_focus_search(self_: /*Ignored*/*mut PhoshAppGrid);
    //pub fn phosh_app_grid_handle_search(self_: /*Ignored*/*mut PhoshAppGrid, event: *mut gdk::GdkEvent) -> gboolean;
    //pub fn phosh_app_grid_reset(self_: /*Ignored*/*mut PhoshAppGrid);
    //pub fn phosh_app_grid_set_filter_adaptive(self_: /*Ignored*/*mut PhoshAppGrid, enable: gboolean);

    //=========================================================================
    // PhoshAppGridBaseButton
    //=========================================================================
    pub fn phosh_app_grid_base_button_get_type() -> GType;
    //pub fn phosh_app_grid_base_button_get_label(self_: /*Ignored*/*mut PhoshAppGridBaseButton) -> *const c_char;
    //pub fn phosh_app_grid_base_button_set_label(self_: /*Ignored*/*mut PhoshAppGridBaseButton, label: *const c_char);

    //=========================================================================
    // PhoshAppGridButton
    //=========================================================================
    pub fn phosh_app_grid_button_get_type() -> GType;
    pub fn phosh_app_grid_button_new(info: *mut gio::GAppInfo) -> *mut gtk::GtkWidget;
    pub fn phosh_app_grid_button_new_favorite(info: *mut gio::GAppInfo) -> *mut gtk::GtkWidget;
    //pub fn phosh_app_grid_button_get_app_info(self_: /*Ignored*/*mut PhoshAppGridButton) -> *mut gio::GAppInfo;
    //pub fn phosh_app_grid_button_get_mode(self_: /*Ignored*/*mut PhoshAppGridButton) -> PhoshAppGridButtonMode;
    //pub fn phosh_app_grid_button_is_favorite(self_: /*Ignored*/*mut PhoshAppGridButton) -> gboolean;
    //pub fn phosh_app_grid_button_set_app_info(self_: /*Ignored*/*mut PhoshAppGridButton, info: *mut gio::GAppInfo);
    //pub fn phosh_app_grid_button_set_folder_info(self_: /*Ignored*/*mut PhoshAppGridButton, folder_info: /*Ignored*/*mut PhoshFolderInfo);
    //pub fn phosh_app_grid_button_set_mode(self_: /*Ignored*/*mut PhoshAppGridButton, mode: PhoshAppGridButtonMode);

    //=========================================================================
    // PhoshAppGridFolderButton
    //=========================================================================
    pub fn phosh_app_grid_folder_button_get_type() -> GType;
    //pub fn phosh_app_grid_folder_button_new_from_folder_info(folder_info: /*Ignored*/*mut PhoshFolderInfo) -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshAppListModel
    //=========================================================================
    pub fn phosh_app_list_model_get_type() -> GType;
    //pub fn phosh_app_list_model_get_default() -> /*Ignored*/*mut PhoshAppListModel;

    //=========================================================================
    // PhoshAppTracker
    //=========================================================================
    pub fn phosh_app_tracker_get_type() -> GType;
    //pub fn phosh_app_tracker_new() -> /*Ignored*/*mut PhoshAppTracker;
    //pub fn phosh_app_tracker_launch_app_info(self_: /*Ignored*/*mut PhoshAppTracker, info: *mut gio::GAppInfo);

    //=========================================================================
    // PhoshArrow
    //=========================================================================
    pub fn phosh_arrow_get_type() -> GType;
    //pub fn phosh_arrow_new() -> /*Ignored*/*mut PhoshArrow;
    //pub fn phosh_arrow_get_progress(self_: /*Ignored*/*mut PhoshArrow) -> c_double;
    //pub fn phosh_arrow_set_progress(self_: /*Ignored*/*mut PhoshArrow, progress: c_double);

    //=========================================================================
    // PhoshAudioDevice
    //=========================================================================
    pub fn phosh_audio_device_get_type() -> GType;
    //pub fn phosh_audio_device_new(id: c_uint, icon_name: *const c_char, description: *const c_char) -> /*Ignored*/*mut PhoshAudioDevice;
    //pub fn phosh_audio_device_get_description(self_: /*Ignored*/*mut PhoshAudioDevice) -> *const c_char;
    //pub fn phosh_audio_device_get_id(self_: /*Ignored*/*mut PhoshAudioDevice) -> c_uint;
    //pub fn phosh_audio_device_set_active(self_: /*Ignored*/*mut PhoshAudioDevice, active: gboolean);

    //=========================================================================
    // PhoshAudioDeviceRow
    //=========================================================================
    pub fn phosh_audio_device_row_get_type() -> GType;
    //pub fn phosh_audio_device_row_new(audio_device: /*Ignored*/*mut PhoshAudioDevice) -> /*Ignored*/*mut PhoshAudioDeviceRow;
    //pub fn phosh_audio_device_row_get_audio_device(self_: /*Ignored*/*mut PhoshAudioDeviceRow) -> /*Ignored*/*mut PhoshAudioDevice;

    //=========================================================================
    // PhoshAudioDevices
    //=========================================================================
    pub fn phosh_audio_devices_get_type() -> GType;
    //pub fn phosh_audio_devices_new(mixer_control: gpointer, is_input: gboolean) -> /*Ignored*/*mut PhoshAudioDevices;

    //=========================================================================
    // PhoshAudioSettings
    //=========================================================================
    pub fn phosh_audio_settings_get_type() -> GType;
    //pub fn phosh_audio_settings_new() -> /*Ignored*/*mut PhoshAudioSettings;
    //pub fn phosh_audio_settings_get_output_is_headphone(self_: /*Ignored*/*mut PhoshAudioSettings) -> gboolean;
    //pub fn phosh_audio_settings_hide_details(self_: /*Ignored*/*mut PhoshAudioSettings);

    //=========================================================================
    // PhoshAuth
    //=========================================================================
    pub fn phosh_auth_get_type() -> GType;
    pub fn phosh_auth_new() -> *mut gobject::GObject;
    //pub fn phosh_auth_authenticate_async(self_: /*Ignored*/*mut PhoshAuth, number: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    //pub fn phosh_auth_authenticate_finish(self_: /*Ignored*/*mut PhoshAuth, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;

    //=========================================================================
    // PhoshAuthPromptOption
    //=========================================================================
    pub fn phosh_auth_prompt_option_get_type() -> GType;
    //pub fn phosh_auth_prompt_option_get_id(self_: /*Ignored*/*mut PhoshAuthPromptOption) -> *const c_char;
    //pub fn phosh_auth_prompt_option_get_label(self_: /*Ignored*/*mut PhoshAuthPromptOption) -> *const c_char;

    //=========================================================================
    // PhoshBackground
    //=========================================================================
    pub fn phosh_background_get_type() -> GType;
    //pub fn phosh_background_new(layer_shell: gpointer, monitor: /*Ignored*/*mut PhoshMonitor, primary: gboolean) -> *mut gtk::GtkWidget;
    //pub fn phosh_background_get_scale(self_: /*Ignored*/*mut PhoshBackground) -> c_float;
    //pub fn phosh_background_needs_update(self_: /*Ignored*/*mut PhoshBackground);
    //pub fn phosh_background_set_primary(self_: /*Ignored*/*mut PhoshBackground, primary: gboolean);
    //pub fn phosh_background_set_scale(self_: /*Ignored*/*mut PhoshBackground, scale: c_float);

    //=========================================================================
    // PhoshBackgroundCache
    //=========================================================================
    pub fn phosh_background_cache_get_type() -> GType;
    //pub fn phosh_background_cache_get_default() -> /*Ignored*/*mut PhoshBackgroundCache;
    //pub fn phosh_background_cache_clear_all(self_: /*Ignored*/*mut PhoshBackgroundCache);
    //pub fn phosh_background_cache_fetch_background(self_: /*Ignored*/*mut PhoshBackgroundCache, file: *mut gio::GFile, cancel: *mut gio::GCancellable);
    //pub fn phosh_background_cache_lookup_background(self_: /*Ignored*/*mut PhoshBackgroundCache, file: *mut gio::GFile) -> /*Ignored*/*mut PhoshBackgroundImage;

    //=========================================================================
    // PhoshBackgroundImage
    //=========================================================================
    pub fn phosh_background_image_get_type() -> GType;
    //pub fn phosh_background_image_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshBackgroundImage;
    //pub fn phosh_background_image_new_sync(file: *mut gio::GFile, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshBackgroundImage;
    pub fn phosh_background_image_new(file: *mut gio::GFile, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    //pub fn phosh_background_image_get_file(self_: /*Ignored*/*mut PhoshBackgroundImage) -> *mut gio::GFile;
    //pub fn phosh_background_image_get_pixbuf(self_: /*Ignored*/*mut PhoshBackgroundImage) -> *mut gdk_pixbuf::GdkPixbuf;

    //=========================================================================
    // PhoshBackgroundManager
    //=========================================================================
    pub fn phosh_background_manager_get_type() -> GType;
    //pub fn phosh_background_manager_new() -> /*Ignored*/*mut PhoshBackgroundManager;
    //pub fn phosh_background_manager_get_backgrounds(self_: /*Ignored*/*mut PhoshBackgroundManager) -> *mut glib::GList;
    //pub fn phosh_background_manager_get_data(self_: /*Ignored*/*mut PhoshBackgroundManager, background: /*Ignored*/*mut PhoshBackground) -> /*Ignored*/*mut PhoshBackgroundData;

    //=========================================================================
    // PhoshBatteryInfo
    //=========================================================================
    pub fn phosh_battery_info_get_type() -> GType;
    pub fn phosh_battery_info_new() -> *mut gtk::GtkWidget;
    //pub fn phosh_battery_info_get_show_detail(self_: /*Ignored*/*mut PhoshBatteryInfo) -> gboolean;
    //pub fn phosh_battery_info_set_show_detail(self_: /*Ignored*/*mut PhoshBatteryInfo, show: gboolean);

    //=========================================================================
    // PhoshBtInfo
    //=========================================================================
    pub fn phosh_bt_info_get_type() -> GType;
    pub fn phosh_bt_info_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshBtStatusPage
    //=========================================================================
    pub fn phosh_bt_status_page_get_type() -> GType;
    pub fn phosh_bt_status_page_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshCall
    //=========================================================================
    pub fn phosh_call_get_type() -> GType;
    //pub fn phosh_call_new(proxy: *mut PhoshCallsDBusCallsCall) -> /*Ignored*/*mut PhoshCall;

    //=========================================================================
    // PhoshCallNotification
    //=========================================================================
    pub fn phosh_call_notification_get_type() -> GType;
    //pub fn phosh_call_notification_new(call: /*Ignored*/*mut PhoshCall) -> /*Ignored*/*mut PhoshCallNotification;

    //=========================================================================
    // PhoshCallsDBusCallsCallProxy
    //=========================================================================
    pub fn phosh_calls_dbus_calls_call_proxy_get_type() -> GType;
    //pub fn phosh_calls_dbus_calls_call_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshCallsDBusCallsCallProxy;
    //pub fn phosh_calls_dbus_calls_call_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshCallsDBusCallsCallProxy;
    //pub fn phosh_calls_dbus_calls_call_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshCallsDBusCallsCallProxy;
    //pub fn phosh_calls_dbus_calls_call_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshCallsDBusCallsCallProxy;
    pub fn phosh_calls_dbus_calls_call_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_calls_dbus_calls_call_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshCallsDBusCallsCallSkeleton
    //=========================================================================
    pub fn phosh_calls_dbus_calls_call_skeleton_get_type() -> GType;
    //pub fn phosh_calls_dbus_calls_call_skeleton_new() -> /*Ignored*/*mut PhoshCallsDBusCallsCallSkeleton;

    //=========================================================================
    // PhoshCallsDBusObjectManagerClient
    //=========================================================================
    pub fn phosh_calls_dbus_object_manager_client_get_type() -> GType;
    //pub fn phosh_calls_dbus_object_manager_client_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshCallsDBusObjectManagerClient;
    //pub fn phosh_calls_dbus_object_manager_client_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshCallsDBusObjectManagerClient;
    //pub fn phosh_calls_dbus_object_manager_client_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshCallsDBusObjectManagerClient;
    //pub fn phosh_calls_dbus_object_manager_client_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshCallsDBusObjectManagerClient;
    pub fn phosh_calls_dbus_object_manager_client_get_proxy_type(manager: *mut gio::GDBusObjectManagerClient, object_path: *const c_char, interface_name: *const c_char, user_data: gpointer) -> GType;
    pub fn phosh_calls_dbus_object_manager_client_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_calls_dbus_object_manager_client_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshCallsDBusObjectProxy
    //=========================================================================
    pub fn phosh_calls_dbus_object_proxy_get_type() -> GType;
    //pub fn phosh_calls_dbus_object_proxy_new(connection: *mut gio::GDBusConnection, object_path: *const c_char) -> /*Ignored*/*mut PhoshCallsDBusObjectProxy;

    //=========================================================================
    // PhoshCallsDBusObjectSkeleton
    //=========================================================================
    pub fn phosh_calls_dbus_object_skeleton_get_type() -> GType;
    //pub fn phosh_calls_dbus_object_skeleton_new(object_path: *const c_char) -> /*Ignored*/*mut PhoshCallsDBusObjectSkeleton;
    //pub fn phosh_calls_dbus_object_skeleton_set_calls_call(object: /*Ignored*/*mut PhoshCallsDBusObjectSkeleton, interface_: *mut PhoshCallsDBusCallsCall);

    //=========================================================================
    // PhoshCallsManager
    //=========================================================================
    pub fn phosh_calls_manager_get_type() -> GType;
    //pub fn phosh_calls_manager_new() -> /*Ignored*/*mut PhoshCallsManager;
    //pub fn phosh_calls_manager_get_active_call_handle(self_: /*Ignored*/*mut PhoshCallsManager) -> *const c_char;
    //pub fn phosh_calls_manager_get_call(self_: /*Ignored*/*mut PhoshCallsManager, handle: *const c_char) -> /*Ignored*/*mut PhoshCall;
    //pub fn phosh_calls_manager_get_present(self_: /*Ignored*/*mut PhoshCallsManager) -> gboolean;
    //pub fn phosh_calls_manager_has_incoming_call(self_: /*Ignored*/*mut PhoshCallsManager) -> gboolean;

    //=========================================================================
    // PhoshClamp
    //=========================================================================
    pub fn phosh_clamp_get_type() -> GType;
    pub fn phosh_clamp_new() -> *mut gtk::GtkWidget;
    //pub fn phosh_clamp_get_natural_size(self_: /*Ignored*/*mut PhoshClamp) -> c_int;
    //pub fn phosh_clamp_set_natural_size(self_: /*Ignored*/*mut PhoshClamp, natural_size: c_int);

    //=========================================================================
    // PhoshConnectivityInfo
    //=========================================================================
    pub fn phosh_connectivity_info_get_type() -> GType;
    pub fn phosh_connectivity_info_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshDBusColorProxy
    //=========================================================================
    pub fn phosh_dbus_color_proxy_get_type() -> GType;
    //pub fn phosh_dbus_color_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusColorProxy;
    //pub fn phosh_dbus_color_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusColorProxy;
    //pub fn phosh_dbus_color_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusColorProxy;
    //pub fn phosh_dbus_color_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusColorProxy;
    pub fn phosh_dbus_color_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_color_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusColorSkeleton
    //=========================================================================
    pub fn phosh_dbus_color_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_color_skeleton_new() -> /*Ignored*/*mut PhoshDBusColorSkeleton;

    //=========================================================================
    // PhoshDBusDisplayConfigProxy
    //=========================================================================
    pub fn phosh_dbus_display_config_proxy_get_type() -> GType;
    //pub fn phosh_dbus_display_config_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusDisplayConfigProxy;
    //pub fn phosh_dbus_display_config_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusDisplayConfigProxy;
    //pub fn phosh_dbus_display_config_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusDisplayConfigProxy;
    //pub fn phosh_dbus_display_config_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusDisplayConfigProxy;
    pub fn phosh_dbus_display_config_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_display_config_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusDisplayConfigSkeleton
    //=========================================================================
    pub fn phosh_dbus_display_config_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_display_config_skeleton_new() -> /*Ignored*/*mut PhoshDBusDisplayConfigSkeleton;

    //=========================================================================
    // PhoshDBusEndSessionDialogProxy
    //=========================================================================
    pub fn phosh_dbus_end_session_dialog_proxy_get_type() -> GType;
    //pub fn phosh_dbus_end_session_dialog_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusEndSessionDialogProxy;
    //pub fn phosh_dbus_end_session_dialog_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusEndSessionDialogProxy;
    //pub fn phosh_dbus_end_session_dialog_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusEndSessionDialogProxy;
    //pub fn phosh_dbus_end_session_dialog_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusEndSessionDialogProxy;
    pub fn phosh_dbus_end_session_dialog_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_end_session_dialog_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusEndSessionDialogSkeleton
    //=========================================================================
    pub fn phosh_dbus_end_session_dialog_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_end_session_dialog_skeleton_new() -> /*Ignored*/*mut PhoshDBusEndSessionDialogSkeleton;

    //=========================================================================
    // PhoshDBusGnomeShellProxy
    //=========================================================================
    pub fn phosh_dbus_gnome_shell_proxy_get_type() -> GType;
    //pub fn phosh_dbus_gnome_shell_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusGnomeShellProxy;
    //pub fn phosh_dbus_gnome_shell_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusGnomeShellProxy;
    //pub fn phosh_dbus_gnome_shell_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusGnomeShellProxy;
    //pub fn phosh_dbus_gnome_shell_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusGnomeShellProxy;
    pub fn phosh_dbus_gnome_shell_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_gnome_shell_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusGnomeShellSkeleton
    //=========================================================================
    pub fn phosh_dbus_gnome_shell_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_gnome_shell_skeleton_new() -> /*Ignored*/*mut PhoshDBusGnomeShellSkeleton;

    //=========================================================================
    // PhoshDBusHostname1Proxy
    //=========================================================================
    pub fn phosh_dbus_hostname1_proxy_get_type() -> GType;
    //pub fn phosh_dbus_hostname1_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusHostname1Proxy;
    //pub fn phosh_dbus_hostname1_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusHostname1Proxy;
    //pub fn phosh_dbus_hostname1_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusHostname1Proxy;
    //pub fn phosh_dbus_hostname1_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusHostname1Proxy;
    pub fn phosh_dbus_hostname1_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_hostname1_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusHostname1Skeleton
    //=========================================================================
    pub fn phosh_dbus_hostname1_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_hostname1_skeleton_new() -> /*Ignored*/*mut PhoshDBusHostname1Skeleton;

    //=========================================================================
    // PhoshDBusImplPortalAccessProxy
    //=========================================================================
    pub fn phosh_dbus_impl_portal_access_proxy_get_type() -> GType;
    //pub fn phosh_dbus_impl_portal_access_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusImplPortalAccessProxy;
    //pub fn phosh_dbus_impl_portal_access_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusImplPortalAccessProxy;
    //pub fn phosh_dbus_impl_portal_access_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusImplPortalAccessProxy;
    //pub fn phosh_dbus_impl_portal_access_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusImplPortalAccessProxy;
    pub fn phosh_dbus_impl_portal_access_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_impl_portal_access_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusImplPortalAccessSkeleton
    //=========================================================================
    pub fn phosh_dbus_impl_portal_access_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_impl_portal_access_skeleton_new() -> /*Ignored*/*mut PhoshDBusImplPortalAccessSkeleton;

    //=========================================================================
    // PhoshDBusImplPortalRequestProxy
    //=========================================================================
    pub fn phosh_dbus_impl_portal_request_proxy_get_type() -> GType;
    //pub fn phosh_dbus_impl_portal_request_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusImplPortalRequestProxy;
    //pub fn phosh_dbus_impl_portal_request_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusImplPortalRequestProxy;
    //pub fn phosh_dbus_impl_portal_request_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusImplPortalRequestProxy;
    //pub fn phosh_dbus_impl_portal_request_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusImplPortalRequestProxy;
    pub fn phosh_dbus_impl_portal_request_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_impl_portal_request_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusImplPortalRequestSkeleton
    //=========================================================================
    pub fn phosh_dbus_impl_portal_request_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_impl_portal_request_skeleton_new() -> /*Ignored*/*mut PhoshDBusImplPortalRequestSkeleton;

    //=========================================================================
    // PhoshDBusLoginManagerProxy
    //=========================================================================
    pub fn phosh_dbus_login_manager_proxy_get_type() -> GType;
    //pub fn phosh_dbus_login_manager_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusLoginManagerProxy;
    //pub fn phosh_dbus_login_manager_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusLoginManagerProxy;
    //pub fn phosh_dbus_login_manager_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusLoginManagerProxy;
    //pub fn phosh_dbus_login_manager_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusLoginManagerProxy;
    pub fn phosh_dbus_login_manager_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_login_manager_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusLoginManagerSkeleton
    //=========================================================================
    pub fn phosh_dbus_login_manager_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_login_manager_skeleton_new() -> /*Ignored*/*mut PhoshDBusLoginManagerSkeleton;

    //=========================================================================
    // PhoshDBusLoginSessionProxy
    //=========================================================================
    pub fn phosh_dbus_login_session_proxy_get_type() -> GType;
    //pub fn phosh_dbus_login_session_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusLoginSessionProxy;
    //pub fn phosh_dbus_login_session_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusLoginSessionProxy;
    //pub fn phosh_dbus_login_session_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusLoginSessionProxy;
    //pub fn phosh_dbus_login_session_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusLoginSessionProxy;
    pub fn phosh_dbus_login_session_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_login_session_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusLoginSessionSkeleton
    //=========================================================================
    pub fn phosh_dbus_login_session_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_login_session_skeleton_new() -> /*Ignored*/*mut PhoshDBusLoginSessionSkeleton;

    //=========================================================================
    // PhoshDBusMountOperationHandlerProxy
    //=========================================================================
    pub fn phosh_dbus_mount_operation_handler_proxy_get_type() -> GType;
    //pub fn phosh_dbus_mount_operation_handler_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusMountOperationHandlerProxy;
    //pub fn phosh_dbus_mount_operation_handler_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusMountOperationHandlerProxy;
    //pub fn phosh_dbus_mount_operation_handler_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusMountOperationHandlerProxy;
    //pub fn phosh_dbus_mount_operation_handler_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusMountOperationHandlerProxy;
    pub fn phosh_dbus_mount_operation_handler_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_mount_operation_handler_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusMountOperationHandlerSkeleton
    //=========================================================================
    pub fn phosh_dbus_mount_operation_handler_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_mount_operation_handler_skeleton_new() -> /*Ignored*/*mut PhoshDBusMountOperationHandlerSkeleton;

    //=========================================================================
    // PhoshDBusNotification
    //=========================================================================
    pub fn phosh_dbus_notification_get_type() -> GType;
    //pub fn phosh_dbus_notification_new(id: c_uint, app_name: *const c_char, info: *mut gio::GAppInfo, summary: *const c_char, body: *const c_char, icon: *mut gio::GIcon, image: *mut gio::GIcon, urgency: PhoshNotificationUrgency, actions: c_char, transient: gboolean, resident: gboolean, category: *const c_char, profile: *const c_char, timestamp: *mut glib::GDateTime) -> /*Ignored*/*mut PhoshDBusNotification;

    //=========================================================================
    // PhoshDBusScreenSaverProxy
    //=========================================================================
    pub fn phosh_dbus_screen_saver_proxy_get_type() -> GType;
    //pub fn phosh_dbus_screen_saver_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusScreenSaverProxy;
    //pub fn phosh_dbus_screen_saver_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusScreenSaverProxy;
    //pub fn phosh_dbus_screen_saver_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusScreenSaverProxy;
    //pub fn phosh_dbus_screen_saver_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusScreenSaverProxy;
    pub fn phosh_dbus_screen_saver_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_screen_saver_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusScreenSaverSkeleton
    //=========================================================================
    pub fn phosh_dbus_screen_saver_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_screen_saver_skeleton_new() -> /*Ignored*/*mut PhoshDBusScreenSaverSkeleton;

    //=========================================================================
    // PhoshDBusScreenshotProxy
    //=========================================================================
    pub fn phosh_dbus_screenshot_proxy_get_type() -> GType;
    //pub fn phosh_dbus_screenshot_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusScreenshotProxy;
    //pub fn phosh_dbus_screenshot_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusScreenshotProxy;
    //pub fn phosh_dbus_screenshot_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusScreenshotProxy;
    //pub fn phosh_dbus_screenshot_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusScreenshotProxy;
    pub fn phosh_dbus_screenshot_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_screenshot_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusScreenshotSkeleton
    //=========================================================================
    pub fn phosh_dbus_screenshot_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_screenshot_skeleton_new() -> /*Ignored*/*mut PhoshDBusScreenshotSkeleton;

    //=========================================================================
    // PhoshDBusSensorProxyCompassProxy
    //=========================================================================
    pub fn phosh_dbus_sensor_proxy_compass_proxy_get_type() -> GType;
    //pub fn phosh_dbus_sensor_proxy_compass_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusSensorProxyCompassProxy;
    //pub fn phosh_dbus_sensor_proxy_compass_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusSensorProxyCompassProxy;
    //pub fn phosh_dbus_sensor_proxy_compass_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusSensorProxyCompassProxy;
    //pub fn phosh_dbus_sensor_proxy_compass_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusSensorProxyCompassProxy;
    pub fn phosh_dbus_sensor_proxy_compass_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_sensor_proxy_compass_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusSensorProxyCompassSkeleton
    //=========================================================================
    pub fn phosh_dbus_sensor_proxy_compass_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_sensor_proxy_compass_skeleton_new() -> /*Ignored*/*mut PhoshDBusSensorProxyCompassSkeleton;

    //=========================================================================
    // PhoshDBusSensorProxyProxy
    //=========================================================================
    pub fn phosh_dbus_sensor_proxy_proxy_get_type() -> GType;
    //pub fn phosh_dbus_sensor_proxy_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusSensorProxyProxy;
    //pub fn phosh_dbus_sensor_proxy_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusSensorProxyProxy;
    //pub fn phosh_dbus_sensor_proxy_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusSensorProxyProxy;
    //pub fn phosh_dbus_sensor_proxy_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusSensorProxyProxy;
    pub fn phosh_dbus_sensor_proxy_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_sensor_proxy_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusSensorProxySkeleton
    //=========================================================================
    pub fn phosh_dbus_sensor_proxy_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_sensor_proxy_skeleton_new() -> /*Ignored*/*mut PhoshDBusSensorProxySkeleton;

    //=========================================================================
    // PhoshDBusSessionManagerProxy
    //=========================================================================
    pub fn phosh_dbus_session_manager_proxy_get_type() -> GType;
    //pub fn phosh_dbus_session_manager_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusSessionManagerProxy;
    //pub fn phosh_dbus_session_manager_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusSessionManagerProxy;
    //pub fn phosh_dbus_session_manager_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusSessionManagerProxy;
    //pub fn phosh_dbus_session_manager_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshDBusSessionManagerProxy;
    pub fn phosh_dbus_session_manager_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_session_manager_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshDBusSessionManagerSkeleton
    //=========================================================================
    pub fn phosh_dbus_session_manager_skeleton_get_type() -> GType;
    //pub fn phosh_dbus_session_manager_skeleton_new() -> /*Ignored*/*mut PhoshDBusSessionManagerSkeleton;

    //=========================================================================
    // PhoshDockedInfo
    //=========================================================================
    pub fn phosh_docked_info_get_type() -> GType;
    pub fn phosh_docked_info_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshDockedManager
    //=========================================================================
    pub fn phosh_docked_manager_get_type() -> GType;
    //pub fn phosh_docked_manager_new(mode_manager: /*Ignored*/*mut PhoshModeManager) -> /*Ignored*/*mut PhoshDockedManager;
    //pub fn phosh_docked_manager_get_can_dock(self_: /*Ignored*/*mut PhoshDockedManager) -> gboolean;
    //pub fn phosh_docked_manager_get_enabled(self_: /*Ignored*/*mut PhoshDockedManager) -> gboolean;
    //pub fn phosh_docked_manager_get_icon_name(self_: /*Ignored*/*mut PhoshDockedManager) -> *const c_char;
    //pub fn phosh_docked_manager_set_enabled(self_: /*Ignored*/*mut PhoshDockedManager, enabled: gboolean);

    //=========================================================================
    // PhoshDragSurface
    //=========================================================================
    pub fn phosh_drag_surface_get_type() -> GType;
    //pub fn phosh_drag_surface_get_drag_handle(self_: /*Ignored*/*mut PhoshDragSurface) -> c_uint;
    //pub fn phosh_drag_surface_get_drag_mode(self_: /*Ignored*/*mut PhoshDragSurface) -> PhoshDragSurfaceDragMode;
    //pub fn phosh_drag_surface_get_drag_state(self_: /*Ignored*/*mut PhoshDragSurface) -> PhoshDragSurfaceState;
    //pub fn phosh_drag_surface_get_threshold(self_: /*Ignored*/*mut PhoshDragSurface) -> c_float;
    //pub fn phosh_drag_surface_set_drag_handle(self_: /*Ignored*/*mut PhoshDragSurface, handle: c_uint);
    //pub fn phosh_drag_surface_set_drag_mode(self_: /*Ignored*/*mut PhoshDragSurface, mode: PhoshDragSurfaceDragMode);
    //pub fn phosh_drag_surface_set_drag_state(self_: /*Ignored*/*mut PhoshDragSurface, state: PhoshDragSurfaceState);
    //pub fn phosh_drag_surface_set_exclusive(self_: /*Ignored*/*mut PhoshDragSurface, exclusive: c_uint);
    //pub fn phosh_drag_surface_set_margin(self_: /*Ignored*/*mut PhoshDragSurface, margin_folded: c_int, margin_unfolded: c_int);
    //pub fn phosh_drag_surface_set_threshold(self_: /*Ignored*/*mut PhoshDragSurface, threshold: c_double);

    //=========================================================================
    // PhoshEmergencyCallsManager
    //=========================================================================
    pub fn phosh_emergency_calls_manager_get_type() -> GType;
    //pub fn phosh_emergency_calls_manager_new() -> /*Ignored*/*mut PhoshEmergencyCallsManager;
    //pub fn phosh_emergency_calls_manager_call(self_: /*Ignored*/*mut PhoshEmergencyCallsManager, id: *const c_char);
    //pub fn phosh_emergency_calls_manager_get_list_store(self_: /*Ignored*/*mut PhoshEmergencyCallsManager) -> *mut gio::GListStore;

    //=========================================================================
    // PhoshEmergencyCallsProxy
    //=========================================================================
    pub fn phosh_emergency_calls_proxy_get_type() -> GType;
    //pub fn phosh_emergency_calls_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshEmergencyCallsProxy;
    //pub fn phosh_emergency_calls_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshEmergencyCallsProxy;
    //pub fn phosh_emergency_calls_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshEmergencyCallsProxy;
    //pub fn phosh_emergency_calls_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshEmergencyCallsProxy;
    pub fn phosh_emergency_calls_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_emergency_calls_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshEmergencyCallsSkeleton
    //=========================================================================
    pub fn phosh_emergency_calls_skeleton_get_type() -> GType;
    //pub fn phosh_emergency_calls_skeleton_new() -> /*Ignored*/*mut PhoshEmergencyCallsSkeleton;

    //=========================================================================
    // PhoshEmergencyContact
    //=========================================================================
    pub fn phosh_emergency_contact_get_type() -> GType;
    //pub fn phosh_emergency_contact_new(id: *const c_char, name: *const c_char, source: i32, additional_properties: *mut glib::GVariant) -> /*Ignored*/*mut PhoshEmergencyContact;
    //pub fn phosh_emergency_contact_call(self_: /*Ignored*/*mut PhoshEmergencyContact, emergency_calls_manager: /*Ignored*/*mut PhoshEmergencyCallsManager);

    //=========================================================================
    // PhoshEmergencyContactRow
    //=========================================================================
    pub fn phosh_emergency_contact_row_get_type() -> GType;
    //pub fn phosh_emergency_contact_row_new(contact: /*Ignored*/*mut PhoshEmergencyContact) -> /*Ignored*/*mut PhoshEmergencyContactRow;
    //pub fn phosh_emergency_contact_row_call(self_: /*Ignored*/*mut PhoshEmergencyContactRow, manager: /*Ignored*/*mut PhoshEmergencyCallsManager);

    //=========================================================================
    // PhoshEmergencyMenu
    //=========================================================================
    pub fn phosh_emergency_menu_get_type() -> GType;
    //pub fn phosh_emergency_menu_new() -> /*Ignored*/*mut PhoshEmergencyMenu;

    //=========================================================================
    // PhoshEndSessionDialog
    //=========================================================================
    pub fn phosh_end_session_dialog_get_type() -> GType;
    pub fn phosh_end_session_dialog_new(action: c_int, seconds: c_int, paths: *const *const c_char) -> *mut gtk::GtkWidget;
    //pub fn phosh_end_session_dialog_get_action(self_: /*Ignored*/*mut PhoshEndSessionDialog) -> c_int;
    //pub fn phosh_end_session_dialog_get_action_confirmed(self_: /*Ignored*/*mut PhoshEndSessionDialog) -> gboolean;

    //=========================================================================
    // PhoshFader
    //=========================================================================
    pub fn phosh_fader_get_type() -> GType;
    //pub fn phosh_fader_new(monitor: /*Ignored*/*mut PhoshMonitor) -> /*Ignored*/*mut PhoshFader;
    //pub fn phosh_fader_hide(self_: /*Ignored*/*mut PhoshFader);

    //=========================================================================
    // PhoshFadingLabel
    //=========================================================================
    pub fn phosh_fading_label_get_type() -> GType;
    pub fn phosh_fading_label_new(label: *const c_char) -> *mut gtk::GtkWidget;
    //pub fn phosh_fading_label_get_align(self_: /*Ignored*/*mut PhoshFadingLabel) -> c_float;
    //pub fn phosh_fading_label_get_label(self_: /*Ignored*/*mut PhoshFadingLabel) -> *const c_char;
    //pub fn phosh_fading_label_set_align(self_: /*Ignored*/*mut PhoshFadingLabel, align: c_float);
    //pub fn phosh_fading_label_set_label(self_: /*Ignored*/*mut PhoshFadingLabel, label: *const c_char);

    //=========================================================================
    // PhoshFavoriteListModel
    //=========================================================================
    pub fn phosh_favorite_list_model_get_type() -> GType;
    //pub fn phosh_favorite_list_model_get_default() -> /*Ignored*/*mut PhoshFavoriteListModel;
    //pub fn phosh_favorite_list_model_add_app(self_: /*Ignored*/*mut PhoshFavoriteListModel, app: *mut gio::GAppInfo);
    //pub fn phosh_favorite_list_model_app_is_favorite(self_: /*Ignored*/*mut PhoshFavoriteListModel, app: *mut gio::GAppInfo) -> gboolean;
    //pub fn phosh_favorite_list_model_remove_app(self_: /*Ignored*/*mut PhoshFavoriteListModel, app: *mut gio::GAppInfo);

    //=========================================================================
    // PhoshFeedbackInfo
    //=========================================================================
    pub fn phosh_feedback_info_get_type() -> GType;
    pub fn phosh_feedback_info_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshFeedbackManager
    //=========================================================================
    pub fn phosh_feedback_manager_get_type() -> GType;
    //pub fn phosh_feedback_manager_new() -> /*Ignored*/*mut PhoshFeedbackManager;
    //pub fn phosh_feedback_manager_get_icon_name(self_: /*Ignored*/*mut PhoshFeedbackManager) -> *const c_char;
    //pub fn phosh_feedback_manager_get_profile(self_: /*Ignored*/*mut PhoshFeedbackManager) -> *const c_char;
    //pub fn phosh_feedback_manager_set_profile(self_: /*Ignored*/*mut PhoshFeedbackManager, profile: *const c_char);
    //pub fn phosh_feedback_manager_toggle(self_: /*Ignored*/*mut PhoshFeedbackManager);
    //pub fn phosh_feedback_manager_trigger_feedback(self_: /*Ignored*/*mut PhoshFeedbackManager, event: *const c_char);

    //=========================================================================
    // PhoshFolderInfo
    //=========================================================================
    pub fn phosh_folder_info_get_type() -> GType;
    //pub fn phosh_folder_info_new_from_folder_path(path: *mut c_char) -> /*Ignored*/*mut PhoshFolderInfo;
    //pub fn phosh_folder_info_add_app_info(self_: /*Ignored*/*mut PhoshFolderInfo, app_info: *mut gio::GAppInfo);
    //pub fn phosh_folder_info_contains(self_: /*Ignored*/*mut PhoshFolderInfo, app_info: *mut gio::GAppInfo) -> gboolean;
    //pub fn phosh_folder_info_get_app_infos(self_: /*Ignored*/*mut PhoshFolderInfo) -> *mut gio::GListModel;
    //pub fn phosh_folder_info_get_name(self_: /*Ignored*/*mut PhoshFolderInfo) -> *mut c_char;
    //pub fn phosh_folder_info_refilter(self_: /*Ignored*/*mut PhoshFolderInfo, search: *const c_char) -> gboolean;
    //pub fn phosh_folder_info_remove_app_info(self_: /*Ignored*/*mut PhoshFolderInfo, app_info: *mut gio::GAppInfo) -> gboolean;
    //pub fn phosh_folder_info_set_name(self_: /*Ignored*/*mut PhoshFolderInfo, name: *const c_char);

    //=========================================================================
    // PhoshGeoClueDBusManagerProxy
    //=========================================================================
    pub fn phosh_geo_clue_dbus_manager_proxy_get_type() -> GType;
    //pub fn phosh_geo_clue_dbus_manager_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshGeoClueDBusManagerProxy;
    //pub fn phosh_geo_clue_dbus_manager_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshGeoClueDBusManagerProxy;
    //pub fn phosh_geo_clue_dbus_manager_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshGeoClueDBusManagerProxy;
    //pub fn phosh_geo_clue_dbus_manager_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshGeoClueDBusManagerProxy;
    pub fn phosh_geo_clue_dbus_manager_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_geo_clue_dbus_manager_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshGeoClueDBusManagerSkeleton
    //=========================================================================
    pub fn phosh_geo_clue_dbus_manager_skeleton_get_type() -> GType;
    //pub fn phosh_geo_clue_dbus_manager_skeleton_new() -> /*Ignored*/*mut PhoshGeoClueDBusManagerSkeleton;

    //=========================================================================
    // PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentProxy
    //=========================================================================
    pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_proxy_get_type() -> GType;
    //pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentProxy;
    //pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentProxy;
    //pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentProxy;
    //pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentProxy;
    pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentSkeleton
    //=========================================================================
    pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_skeleton_get_type() -> GType;
    //pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_skeleton_new() -> /*Ignored*/*mut PhoshGeoClueDBusOrgFreedesktopGeoClue2AgentSkeleton;

    //=========================================================================
    // PhoshGnomeShellManager
    //=========================================================================
    pub fn phosh_gnome_shell_manager_get_type() -> GType;
    //pub fn phosh_gnome_shell_manager_get_default() -> /*Ignored*/*mut PhoshGnomeShellManager;

    //=========================================================================
    // PhoshGtkMountManager
    //=========================================================================
    pub fn phosh_gtk_mount_manager_get_type() -> GType;
    //pub fn phosh_gtk_mount_manager_new() -> /*Ignored*/*mut PhoshGtkMountManager;

    //=========================================================================
    // PhoshGtkMountPrompt
    //=========================================================================
    pub fn phosh_gtk_mount_prompt_get_type() -> GType;
    pub fn phosh_gtk_mount_prompt_new(message: *const c_char, icon_name: *const c_char, default_user: *const c_char, default_domain: *const c_char, pids: *mut glib::GVariant, choices: *const *const c_char, ask_flags: gio::GAskPasswordFlags) -> *mut gtk::GtkWidget;
    //pub fn phosh_gtk_mount_prompt_get_ask_flags(self_: /*Ignored*/*mut PhoshGtkMountPrompt) -> gio::GAskPasswordFlags;
    //pub fn phosh_gtk_mount_prompt_get_cancelled(self_: /*Ignored*/*mut PhoshGtkMountPrompt) -> gboolean;
    //pub fn phosh_gtk_mount_prompt_get_choice(self_: /*Ignored*/*mut PhoshGtkMountPrompt) -> c_int;
    //pub fn phosh_gtk_mount_prompt_get_choices(self_: /*Ignored*/*mut PhoshGtkMountPrompt) -> c_char;
    //pub fn phosh_gtk_mount_prompt_get_password(self_: /*Ignored*/*mut PhoshGtkMountPrompt) -> *const c_char;
    //pub fn phosh_gtk_mount_prompt_set_pids(self_: /*Ignored*/*mut PhoshGtkMountPrompt, pids: *mut glib::GVariant);

    //=========================================================================
    // PhoshHead
    //=========================================================================
    pub fn phosh_head_get_type() -> GType;
    //pub fn phosh_head_new_from_wlr_head(wlr_head: gpointer) -> /*Ignored*/*mut PhoshHead;
    //pub fn phosh_head_calculate_supported_mode_scales(head: /*Ignored*/*mut PhoshHead, mode: /*Ignored*/*mut PhoshHeadMode, n: *mut c_int, fractional: gboolean) -> *mut c_float;
    //pub fn phosh_head_clear_pending(self_: /*Ignored*/*mut PhoshHead);
    //pub fn phosh_head_find_mode_by_name(self_: /*Ignored*/*mut PhoshHead, name: *const c_char) -> /*Ignored*/*mut PhoshHeadMode;
    //pub fn phosh_head_get_enabled(self_: /*Ignored*/*mut PhoshHead) -> gboolean;
    //pub fn phosh_head_get_preferred_mode(self_: /*Ignored*/*mut PhoshHead) -> /*Ignored*/*mut PhoshHeadMode;
    //pub fn phosh_head_get_wlr_head(self_: /*Ignored*/*mut PhoshHead) -> *mut zwlr_output_head_v1;
    //pub fn phosh_head_is_builtin(self_: /*Ignored*/*mut PhoshHead) -> gboolean;
    //pub fn phosh_head_set_pending_enabled(self_: /*Ignored*/*mut PhoshHead, enabled: gboolean);
    //pub fn phosh_head_set_pending_transform(self_: /*Ignored*/*mut PhoshHead, transform: PhoshMonitorTransform, heads: *mut glib::GPtrArray);

    //=========================================================================
    // PhoshHksInfo
    //=========================================================================
    pub fn phosh_hks_info_get_type() -> GType;
    pub fn phosh_hks_info_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshHksManager
    //=========================================================================
    pub fn phosh_hks_manager_get_type() -> GType;
    //pub fn phosh_hks_manager_new() -> /*Ignored*/*mut PhoshHksManager;

    //=========================================================================
    // PhoshHome
    //=========================================================================
    pub fn phosh_home_get_type() -> GType;
    //pub fn phosh_home_new(layer_shell: *mut zwlr_layer_shell_v1, layer_shell_effects: *mut zphoc_layer_shell_effects_v1, monitor: /*Ignored*/*mut PhoshMonitor) -> *mut gtk::GtkWidget;
    //pub fn phosh_home_get_overview(self_: /*Ignored*/*mut PhoshHome) -> /*Ignored*/*mut PhoshOverview;
    //pub fn phosh_home_get_state(self_: /*Ignored*/*mut PhoshHome) -> PhoshHomeState;
    //pub fn phosh_home_set_state(self_: /*Ignored*/*mut PhoshHome, state: PhoshHomeState);

    //=========================================================================
    // PhoshIdleDBusIdleMonitorProxy
    //=========================================================================
    pub fn phosh_idle_dbus_idle_monitor_proxy_get_type() -> GType;
    //pub fn phosh_idle_dbus_idle_monitor_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshIdleDBusIdleMonitorProxy;
    //pub fn phosh_idle_dbus_idle_monitor_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshIdleDBusIdleMonitorProxy;
    //pub fn phosh_idle_dbus_idle_monitor_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshIdleDBusIdleMonitorProxy;
    //pub fn phosh_idle_dbus_idle_monitor_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshIdleDBusIdleMonitorProxy;
    pub fn phosh_idle_dbus_idle_monitor_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_idle_dbus_idle_monitor_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshIdleDBusIdleMonitorSkeleton
    //=========================================================================
    pub fn phosh_idle_dbus_idle_monitor_skeleton_get_type() -> GType;
    //pub fn phosh_idle_dbus_idle_monitor_skeleton_new() -> /*Ignored*/*mut PhoshIdleDBusIdleMonitorSkeleton;

    //=========================================================================
    // PhoshIdleDBusObjectManagerClient
    //=========================================================================
    pub fn phosh_idle_dbus_object_manager_client_get_type() -> GType;
    //pub fn phosh_idle_dbus_object_manager_client_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshIdleDBusObjectManagerClient;
    //pub fn phosh_idle_dbus_object_manager_client_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshIdleDBusObjectManagerClient;
    //pub fn phosh_idle_dbus_object_manager_client_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshIdleDBusObjectManagerClient;
    //pub fn phosh_idle_dbus_object_manager_client_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshIdleDBusObjectManagerClient;
    pub fn phosh_idle_dbus_object_manager_client_get_proxy_type(manager: *mut gio::GDBusObjectManagerClient, object_path: *const c_char, interface_name: *const c_char, user_data: gpointer) -> GType;
    pub fn phosh_idle_dbus_object_manager_client_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_idle_dbus_object_manager_client_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshIdleDBusObjectProxy
    //=========================================================================
    pub fn phosh_idle_dbus_object_proxy_get_type() -> GType;
    //pub fn phosh_idle_dbus_object_proxy_new(connection: *mut gio::GDBusConnection, object_path: *const c_char) -> /*Ignored*/*mut PhoshIdleDBusObjectProxy;

    //=========================================================================
    // PhoshIdleDBusObjectSkeleton
    //=========================================================================
    pub fn phosh_idle_dbus_object_skeleton_get_type() -> GType;
    //pub fn phosh_idle_dbus_object_skeleton_new(object_path: *const c_char) -> /*Ignored*/*mut PhoshIdleDBusObjectSkeleton;
    //pub fn phosh_idle_dbus_object_skeleton_set_idle_monitor(object: /*Ignored*/*mut PhoshIdleDBusObjectSkeleton, interface_: *mut PhoshIdleDBusIdleMonitor);

    //=========================================================================
    // PhoshIdleManager
    //=========================================================================
    pub fn phosh_idle_manager_get_type() -> GType;
    //pub fn phosh_idle_manager_get_default() -> /*Ignored*/*mut PhoshIdleManager;
    //pub fn phosh_idle_manager_reset_timers(self_: /*Ignored*/*mut PhoshIdleManager);

    //=========================================================================
    // PhoshKeyboardEvents
    //=========================================================================
    pub fn phosh_keyboard_events_get_type() -> GType;
    //pub fn phosh_keyboard_events_new() -> /*Ignored*/*mut PhoshKeyboardEvents;

    //=========================================================================
    // PhoshKeypad
    //=========================================================================
    pub fn phosh_keypad_get_type() -> GType;
    pub fn phosh_keypad_new() -> *mut gtk::GtkWidget;
    //pub fn phosh_keypad_distribute(self_: /*Ignored*/*mut PhoshKeypad);
    //pub fn phosh_keypad_get_end_action(self_: /*Ignored*/*mut PhoshKeypad) -> *mut gtk::GtkWidget;
    //pub fn phosh_keypad_get_entry(self_: /*Ignored*/*mut PhoshKeypad) -> *mut gtk::GtkEntry;
    //pub fn phosh_keypad_get_shuffle(self_: /*Ignored*/*mut PhoshKeypad) -> gboolean;
    //pub fn phosh_keypad_get_start_action(self_: /*Ignored*/*mut PhoshKeypad) -> *mut gtk::GtkWidget;
    //pub fn phosh_keypad_set_end_action(self_: /*Ignored*/*mut PhoshKeypad, end_action: *mut gtk::GtkWidget);
    //pub fn phosh_keypad_set_entry(self_: /*Ignored*/*mut PhoshKeypad, entry: *mut gtk::GtkEntry);
    //pub fn phosh_keypad_set_shuffle(self_: /*Ignored*/*mut PhoshKeypad, shuffle: gboolean);
    //pub fn phosh_keypad_set_start_action(self_: /*Ignored*/*mut PhoshKeypad, start_action: *mut gtk::GtkWidget);

    //=========================================================================
    // PhoshLauncherEntryManager
    //=========================================================================
    pub fn phosh_launcher_entry_manager_get_type() -> GType;
    //pub fn phosh_launcher_entry_manager_new() -> /*Ignored*/*mut PhoshLauncherEntryManager;

    //=========================================================================
    // PhoshLayerSurface
    //=========================================================================
    pub fn phosh_layer_surface_get_type() -> GType;
    pub fn phosh_layer_surface_new(layer_shell: gpointer, wl_output: gpointer) -> *mut gtk::GtkWidget;
    pub fn phosh_layer_surface_get_configured_height(self_: *mut PhoshLayerSurface) -> c_int;
    pub fn phosh_layer_surface_get_configured_width(self_: *mut PhoshLayerSurface) -> c_int;
    pub fn phosh_layer_surface_get_margins(self_: *mut PhoshLayerSurface, top: *mut c_int, right: *mut c_int, bottom: *mut c_int, left: *mut c_int);
    pub fn phosh_layer_surface_has_alpha(self_: *mut PhoshLayerSurface) -> gboolean;
    pub fn phosh_layer_surface_set_alpha(self_: *mut PhoshLayerSurface, alpha: c_double);
    pub fn phosh_layer_surface_set_exclusive_zone(self_: *mut PhoshLayerSurface, zone: c_int);
    pub fn phosh_layer_surface_set_kbd_interactivity(self_: *mut PhoshLayerSurface, interactivity: gboolean);
    pub fn phosh_layer_surface_set_layer(self_: *mut PhoshLayerSurface, layer: u32);
    pub fn phosh_layer_surface_set_margins(self_: *mut PhoshLayerSurface, top: c_int, right: c_int, bottom: c_int, left: c_int);
    pub fn phosh_layer_surface_set_size(self_: *mut PhoshLayerSurface, width: c_int, height: c_int);
    pub fn phosh_layer_surface_wl_surface_commit(self_: *mut PhoshLayerSurface);

    //=========================================================================
    // PhoshLayoutManager
    //=========================================================================
    pub fn phosh_layout_manager_get_type() -> GType;
    //pub fn phosh_layout_manager_new() -> /*Ignored*/*mut PhoshLayoutManager;
    //pub fn phosh_layout_manager_get_clock_pos(self_: /*Ignored*/*mut PhoshLayoutManager) -> PhoshLayoutClockPosition;
    //pub fn phosh_layout_manager_get_clock_shift(self_: /*Ignored*/*mut PhoshLayoutManager) -> c_uint;
    //pub fn phosh_layout_manager_get_corner_shift(self_: /*Ignored*/*mut PhoshLayoutManager) -> c_uint;

    //=========================================================================
    // PhoshLocationInfo
    //=========================================================================
    pub fn phosh_location_info_get_type() -> GType;
    pub fn phosh_location_info_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshLocationManager
    //=========================================================================
    pub fn phosh_location_manager_get_type() -> GType;
    //pub fn phosh_location_manager_new() -> /*Ignored*/*mut PhoshLocationManager;

    //=========================================================================
    // PhoshLockscreen
    //=========================================================================
    pub fn phosh_lockscreen_get_type() -> GType;
    //pub fn phosh_lockscreen_new(lockscreen_type: GType, layer_shell: gpointer, wl_output: gpointer, calls_manager: /*Ignored*/*mut PhoshCallsManager) -> *mut gtk::GtkWidget;
    pub fn phosh_lockscreen_add_extra_page(self_: *mut PhoshLockscreen, widget: *mut gtk::GtkWidget);
    pub fn phosh_lockscreen_clear_pin_entry(self_: *mut PhoshLockscreen);
    pub fn phosh_lockscreen_get_page(self_: *mut PhoshLockscreen) -> PhoshLockscreenPage;
    pub fn phosh_lockscreen_get_pin_entry(self_: *mut PhoshLockscreen) -> *const c_char;
    pub fn phosh_lockscreen_set_default_page(self_: *mut PhoshLockscreen, page: PhoshLockscreenPage);
    pub fn phosh_lockscreen_set_page(self_: *mut PhoshLockscreen, page: PhoshLockscreenPage);
    pub fn phosh_lockscreen_set_unlock_status(self_: *mut PhoshLockscreen, status: *const c_char);
    pub fn phosh_lockscreen_shake_pin_entry(self_: *mut PhoshLockscreen);

    //=========================================================================
    // PhoshLockscreenManager
    //=========================================================================
    pub fn phosh_lockscreen_manager_get_type() -> GType;
    //pub fn phosh_lockscreen_manager_new(calls_manager: /*Ignored*/*mut PhoshCallsManager) -> /*Ignored*/*mut PhoshLockscreenManager;
    //pub fn phosh_lockscreen_manager_get_active_time(self_: /*Ignored*/*mut PhoshLockscreenManager) -> i64;
    //pub fn phosh_lockscreen_manager_get_locked(self_: /*Ignored*/*mut PhoshLockscreenManager) -> gboolean;
    //pub fn phosh_lockscreen_manager_get_lockscreen(self_: /*Ignored*/*mut PhoshLockscreenManager) -> *mut PhoshLockscreen;
    //pub fn phosh_lockscreen_manager_get_page(self_: /*Ignored*/*mut PhoshLockscreenManager) -> PhoshLockscreenPage;
    //pub fn phosh_lockscreen_manager_get_timeout(self_: /*Ignored*/*mut PhoshLockscreenManager) -> c_int;
    //pub fn phosh_lockscreen_manager_set_locked(self_: /*Ignored*/*mut PhoshLockscreenManager, state: gboolean);
    //pub fn phosh_lockscreen_manager_set_page(self_: /*Ignored*/*mut PhoshLockscreenManager, page: PhoshLockscreenPage) -> gboolean;
    //pub fn phosh_lockscreen_manager_set_timeout(self_: /*Ignored*/*mut PhoshLockscreenManager, timeout: c_int);

    //=========================================================================
    // PhoshLockshield
    //=========================================================================
    pub fn phosh_lockshield_get_type() -> GType;
    //pub fn phosh_lockshield_new(layer_shell: *mut zwlr_layer_shell_v1, monitor: /*Ignored*/*mut PhoshMonitor) -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshMMDBusModemModem3gppProxy
    //=========================================================================
    pub fn phosh_mm_dbus_modem_modem3gpp_proxy_get_type() -> GType;
    //pub fn phosh_mm_dbus_modem_modem3gpp_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMMDBusModemModem3gppProxy;
    //pub fn phosh_mm_dbus_modem_modem3gpp_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMMDBusModemModem3gppProxy;
    //pub fn phosh_mm_dbus_modem_modem3gpp_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMMDBusModemModem3gppProxy;
    //pub fn phosh_mm_dbus_modem_modem3gpp_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMMDBusModemModem3gppProxy;
    pub fn phosh_mm_dbus_modem_modem3gpp_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_mm_dbus_modem_modem3gpp_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshMMDBusModemModem3gppSkeleton
    //=========================================================================
    pub fn phosh_mm_dbus_modem_modem3gpp_skeleton_get_type() -> GType;
    //pub fn phosh_mm_dbus_modem_modem3gpp_skeleton_new() -> /*Ignored*/*mut PhoshMMDBusModemModem3gppSkeleton;

    //=========================================================================
    // PhoshMMDBusModemProxy
    //=========================================================================
    pub fn phosh_mm_dbus_modem_proxy_get_type() -> GType;
    //pub fn phosh_mm_dbus_modem_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMMDBusModemProxy;
    //pub fn phosh_mm_dbus_modem_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMMDBusModemProxy;
    //pub fn phosh_mm_dbus_modem_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMMDBusModemProxy;
    //pub fn phosh_mm_dbus_modem_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMMDBusModemProxy;
    pub fn phosh_mm_dbus_modem_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_mm_dbus_modem_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshMMDBusModemSkeleton
    //=========================================================================
    pub fn phosh_mm_dbus_modem_skeleton_get_type() -> GType;
    //pub fn phosh_mm_dbus_modem_skeleton_new() -> /*Ignored*/*mut PhoshMMDBusModemSkeleton;

    //=========================================================================
    // PhoshMMDBusObjectManagerClient
    //=========================================================================
    pub fn phosh_mm_dbus_object_manager_client_get_type() -> GType;
    //pub fn phosh_mm_dbus_object_manager_client_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMMDBusObjectManagerClient;
    //pub fn phosh_mm_dbus_object_manager_client_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMMDBusObjectManagerClient;
    //pub fn phosh_mm_dbus_object_manager_client_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMMDBusObjectManagerClient;
    //pub fn phosh_mm_dbus_object_manager_client_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMMDBusObjectManagerClient;
    pub fn phosh_mm_dbus_object_manager_client_get_proxy_type(manager: *mut gio::GDBusObjectManagerClient, object_path: *const c_char, interface_name: *const c_char, user_data: gpointer) -> GType;
    pub fn phosh_mm_dbus_object_manager_client_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_mm_dbus_object_manager_client_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshMMDBusObjectProxy
    //=========================================================================
    pub fn phosh_mm_dbus_object_proxy_get_type() -> GType;
    //pub fn phosh_mm_dbus_object_proxy_new(connection: *mut gio::GDBusConnection, object_path: *const c_char) -> /*Ignored*/*mut PhoshMMDBusObjectProxy;

    //=========================================================================
    // PhoshMMDBusObjectSkeleton
    //=========================================================================
    pub fn phosh_mm_dbus_object_skeleton_get_type() -> GType;
    //pub fn phosh_mm_dbus_object_skeleton_new(object_path: *const c_char) -> /*Ignored*/*mut PhoshMMDBusObjectSkeleton;
    //pub fn phosh_mm_dbus_object_skeleton_set_modem(object: /*Ignored*/*mut PhoshMMDBusObjectSkeleton, interface_: *mut PhoshMMDBusModem);
    //pub fn phosh_mm_dbus_object_skeleton_set_modem_modem3gpp(object: /*Ignored*/*mut PhoshMMDBusObjectSkeleton, interface_: *mut PhoshMMDBusModemModem3gpp);

    //=========================================================================
    // PhoshManager
    //=========================================================================
    pub fn phosh_manager_get_type() -> GType;

    //=========================================================================
    // PhoshMediaPlayer
    //=========================================================================
    pub fn phosh_media_player_get_type() -> GType;
    pub fn phosh_media_player_new() -> *mut gtk::GtkWidget;
    //pub fn phosh_media_player_get_is_playable(self_: /*Ignored*/*mut PhoshMediaPlayer) -> gboolean;
    //pub fn phosh_media_player_get_status(self_: /*Ignored*/*mut PhoshMediaPlayer) -> PhoshMediaPlayerStatus;
    //pub fn phosh_media_player_toggle_play_pause(self_: /*Ignored*/*mut PhoshMediaPlayer);

    //=========================================================================
    // PhoshModeManager
    //=========================================================================
    pub fn phosh_mode_manager_get_type() -> GType;
    //pub fn phosh_mode_manager_new() -> /*Ignored*/*mut PhoshModeManager;
    //pub fn phosh_mode_manager_get_device_type(self_: /*Ignored*/*mut PhoshModeManager) -> /*Ignored*/PhoshModeDeviceType;
    //pub fn phosh_mode_manager_get_mimicry(self_: /*Ignored*/*mut PhoshModeManager) -> /*Ignored*/PhoshModeDeviceType;

    //=========================================================================
    // PhoshMonitor
    //=========================================================================
    pub fn phosh_monitor_get_type() -> GType;
    //pub fn phosh_monitor_new_from_wl_output(wl_output: gpointer) -> /*Ignored*/*mut PhoshMonitor;
    pub fn phosh_monitor_connector_is_builtin(type_: PhoshMonitorConnectorType) -> gboolean;
    //pub fn phosh_monitor_get_current_mode(self_: /*Ignored*/*mut PhoshMonitor) -> *mut PhoshMonitorMode;
    //pub fn phosh_monitor_get_fractional_scale(self_: /*Ignored*/*mut PhoshMonitor) -> c_float;
    //pub fn phosh_monitor_get_power_save_mode(self_: /*Ignored*/*mut PhoshMonitor) -> PhoshMonitorPowerSaveMode;
    //pub fn phosh_monitor_get_transform(self_: /*Ignored*/*mut PhoshMonitor) -> c_uint;
    //pub fn phosh_monitor_get_wl_output(self_: /*Ignored*/*mut PhoshMonitor) -> *mut wl_output;
    //pub fn phosh_monitor_has_gamma(self_: /*Ignored*/*mut PhoshMonitor) -> gboolean;
    //pub fn phosh_monitor_is_builtin(self_: /*Ignored*/*mut PhoshMonitor) -> gboolean;
    //pub fn phosh_monitor_is_configured(self_: /*Ignored*/*mut PhoshMonitor) -> gboolean;
    //pub fn phosh_monitor_is_flipped(self_: /*Ignored*/*mut PhoshMonitor) -> gboolean;
    //pub fn phosh_monitor_is_preferred_mode(self_: /*Ignored*/*mut PhoshMonitor) -> gboolean;
    //pub fn phosh_monitor_set_color_temp(self_: /*Ignored*/*mut PhoshMonitor, temp: u32) -> gboolean;
    //pub fn phosh_monitor_set_power_save_mode(self_: /*Ignored*/*mut PhoshMonitor, mode: PhoshMonitorPowerSaveMode);

    //=========================================================================
    // PhoshMonitorManager
    //=========================================================================
    pub fn phosh_monitor_manager_get_type() -> GType;
    //pub fn phosh_monitor_manager_new(proxy: /*Ignored*/*mut PhoshSensorProxyManager) -> /*Ignored*/*mut PhoshMonitorManager;
    //pub fn phosh_monitor_manager_apply_monitor_config(self_: /*Ignored*/*mut PhoshMonitorManager);
    //pub fn phosh_monitor_manager_enable_fallback(self_: /*Ignored*/*mut PhoshMonitorManager) -> gboolean;
    //pub fn phosh_monitor_manager_find_monitor(self_: /*Ignored*/*mut PhoshMonitorManager, name: *const c_char) -> /*Ignored*/*mut PhoshMonitor;
    //pub fn phosh_monitor_manager_get_monitor(self_: /*Ignored*/*mut PhoshMonitorManager, num: c_uint) -> /*Ignored*/*mut PhoshMonitor;
    //pub fn phosh_monitor_manager_get_night_light_supported(self_: /*Ignored*/*mut PhoshMonitorManager) -> gboolean;
    //pub fn phosh_monitor_manager_get_num_monitors(self_: /*Ignored*/*mut PhoshMonitorManager) -> c_uint;
    //pub fn phosh_monitor_manager_set_monitor_transform(self_: /*Ignored*/*mut PhoshMonitorManager, monitor: /*Ignored*/*mut PhoshMonitor, transform: PhoshMonitorTransform);
    //pub fn phosh_monitor_manager_set_power_save_mode(self_: /*Ignored*/*mut PhoshMonitorManager, mode: PhoshMonitorPowerSaveMode);
    //pub fn phosh_monitor_manager_set_sensor_proxy_manager(self_: /*Ignored*/*mut PhoshMonitorManager, manager: /*Ignored*/*mut PhoshSensorProxyManager);

    //=========================================================================
    // PhoshMountManager
    //=========================================================================
    pub fn phosh_mount_manager_get_type() -> GType;
    //pub fn phosh_mount_manager_new() -> /*Ignored*/*mut PhoshMountManager;

    //=========================================================================
    // PhoshMountNotification
    //=========================================================================
    pub fn phosh_mount_notification_get_type() -> GType;
    //pub fn phosh_mount_notification_new_from_mount(id: c_uint, mount: *mut gio::GMount) -> /*Ignored*/*mut PhoshMountNotification;

    //=========================================================================
    // PhoshMountOperation
    //=========================================================================
    pub fn phosh_mount_operation_get_type() -> GType;
    //pub fn phosh_mount_operation_new() -> /*Ignored*/*mut PhoshMountOperation;

    //=========================================================================
    // PhoshMprisDBusMediaPlayer2PlayerProxy
    //=========================================================================
    pub fn phosh_mpris_dbus_media_player2_player_proxy_get_type() -> GType;
    //pub fn phosh_mpris_dbus_media_player2_player_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMprisDBusMediaPlayer2PlayerProxy;
    //pub fn phosh_mpris_dbus_media_player2_player_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMprisDBusMediaPlayer2PlayerProxy;
    //pub fn phosh_mpris_dbus_media_player2_player_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMprisDBusMediaPlayer2PlayerProxy;
    //pub fn phosh_mpris_dbus_media_player2_player_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMprisDBusMediaPlayer2PlayerProxy;
    pub fn phosh_mpris_dbus_media_player2_player_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_mpris_dbus_media_player2_player_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshMprisDBusMediaPlayer2PlayerSkeleton
    //=========================================================================
    pub fn phosh_mpris_dbus_media_player2_player_skeleton_get_type() -> GType;
    //pub fn phosh_mpris_dbus_media_player2_player_skeleton_new() -> /*Ignored*/*mut PhoshMprisDBusMediaPlayer2PlayerSkeleton;

    //=========================================================================
    // PhoshMprisDBusMediaPlayer2Proxy
    //=========================================================================
    pub fn phosh_mpris_dbus_media_player2_proxy_get_type() -> GType;
    //pub fn phosh_mpris_dbus_media_player2_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMprisDBusMediaPlayer2Proxy;
    //pub fn phosh_mpris_dbus_media_player2_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMprisDBusMediaPlayer2Proxy;
    //pub fn phosh_mpris_dbus_media_player2_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMprisDBusMediaPlayer2Proxy;
    //pub fn phosh_mpris_dbus_media_player2_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshMprisDBusMediaPlayer2Proxy;
    pub fn phosh_mpris_dbus_media_player2_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_mpris_dbus_media_player2_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshMprisDBusMediaPlayer2Skeleton
    //=========================================================================
    pub fn phosh_mpris_dbus_media_player2_skeleton_get_type() -> GType;
    //pub fn phosh_mpris_dbus_media_player2_skeleton_new() -> /*Ignored*/*mut PhoshMprisDBusMediaPlayer2Skeleton;

    //=========================================================================
    // PhoshNetworkAuthManager
    //=========================================================================
    pub fn phosh_network_auth_manager_get_type() -> GType;
    //pub fn phosh_network_auth_manager_new() -> /*Ignored*/*mut PhoshNetworkAuthManager;

    //=========================================================================
    // PhoshNotification
    //=========================================================================
    pub fn phosh_notification_get_type() -> GType;
    //pub fn phosh_notification_new(id: c_uint, app_name: *const c_char, info: *mut gio::GAppInfo, summary: *const c_char, body: *const c_char, icon: *mut gio::GIcon, image: *mut gio::GIcon, urgency: PhoshNotificationUrgency, actions: c_char, transient: gboolean, resident: gboolean, category: *const c_char, profile: *const c_char, timestamp: *mut glib::GDateTime) -> /*Ignored*/*mut PhoshNotification;
    //pub fn phosh_notification_activate(self_: /*Ignored*/*mut PhoshNotification, action: *const c_char);
    //pub fn phosh_notification_close(self_: /*Ignored*/*mut PhoshNotification, reason: PhoshNotificationReason);
    //pub fn phosh_notification_do_action(notification: /*Ignored*/*mut PhoshNotification, id: c_uint, action: *const c_char);
    //pub fn phosh_notification_expires(self_: /*Ignored*/*mut PhoshNotification, timeout: c_int);
    //pub fn phosh_notification_get_actions(self_: /*Ignored*/*mut PhoshNotification) -> c_char;
    //pub fn phosh_notification_get_app_icon(self_: /*Ignored*/*mut PhoshNotification) -> *mut gio::GIcon;
    //pub fn phosh_notification_get_app_info(self_: /*Ignored*/*mut PhoshNotification) -> *mut gio::GAppInfo;
    //pub fn phosh_notification_get_app_name(self_: /*Ignored*/*mut PhoshNotification) -> *const c_char;
    //pub fn phosh_notification_get_body(self_: /*Ignored*/*mut PhoshNotification) -> *const c_char;
    //pub fn phosh_notification_get_category(self_: /*Ignored*/*mut PhoshNotification) -> *const c_char;
    //pub fn phosh_notification_get_id(self_: /*Ignored*/*mut PhoshNotification) -> c_uint;
    //pub fn phosh_notification_get_image(self_: /*Ignored*/*mut PhoshNotification) -> *mut gio::GIcon;
    //pub fn phosh_notification_get_profile(self_: /*Ignored*/*mut PhoshNotification) -> *const c_char;
    //pub fn phosh_notification_get_resident(self_: /*Ignored*/*mut PhoshNotification) -> gboolean;
    //pub fn phosh_notification_get_summary(self_: /*Ignored*/*mut PhoshNotification) -> *const c_char;
    //pub fn phosh_notification_get_timestamp(self_: /*Ignored*/*mut PhoshNotification) -> *mut glib::GDateTime;
    //pub fn phosh_notification_get_transient(self_: /*Ignored*/*mut PhoshNotification) -> gboolean;
    //pub fn phosh_notification_get_urgency(self_: /*Ignored*/*mut PhoshNotification) -> PhoshNotificationUrgency;
    //pub fn phosh_notification_set_actions(self_: /*Ignored*/*mut PhoshNotification, actions: c_char);
    //pub fn phosh_notification_set_app_icon(self_: /*Ignored*/*mut PhoshNotification, icon: *mut gio::GIcon);
    //pub fn phosh_notification_set_app_info(self_: /*Ignored*/*mut PhoshNotification, info: *mut gio::GAppInfo);
    //pub fn phosh_notification_set_app_name(self_: /*Ignored*/*mut PhoshNotification, app_name: *const c_char);
    //pub fn phosh_notification_set_body(self_: /*Ignored*/*mut PhoshNotification, body: *const c_char);
    //pub fn phosh_notification_set_category(self_: /*Ignored*/*mut PhoshNotification, category: *const c_char);
    //pub fn phosh_notification_set_id(self_: /*Ignored*/*mut PhoshNotification, id: c_uint);
    //pub fn phosh_notification_set_image(self_: /*Ignored*/*mut PhoshNotification, icon: *mut gio::GIcon);
    //pub fn phosh_notification_set_profile(self_: /*Ignored*/*mut PhoshNotification, profile: *const c_char);
    //pub fn phosh_notification_set_resident(self_: /*Ignored*/*mut PhoshNotification, resident: gboolean);
    //pub fn phosh_notification_set_summary(self_: /*Ignored*/*mut PhoshNotification, summary: *const c_char);
    //pub fn phosh_notification_set_timestamp(self_: /*Ignored*/*mut PhoshNotification, timestamp: *mut glib::GDateTime);
    //pub fn phosh_notification_set_transient(self_: /*Ignored*/*mut PhoshNotification, transient: gboolean);
    //pub fn phosh_notification_set_urgency(self_: /*Ignored*/*mut PhoshNotification, urgency: PhoshNotificationUrgency);

    //=========================================================================
    // PhoshNotificationBanner
    //=========================================================================
    pub fn phosh_notification_banner_get_type() -> GType;
    //pub fn phosh_notification_banner_new(notification: /*Ignored*/*mut PhoshNotification) -> *mut gtk::GtkWidget;
    //pub fn phosh_notification_banner_get_notification(self_: /*Ignored*/*mut PhoshNotificationBanner) -> /*Ignored*/*mut PhoshNotification;

    //=========================================================================
    // PhoshNotificationContent
    //=========================================================================
    pub fn phosh_notification_content_get_type() -> GType;
    //pub fn phosh_notification_content_new(notification: /*Ignored*/*mut PhoshNotification, show_body: gboolean, action_filters: *const *const c_char) -> *mut gtk::GtkWidget;
    //pub fn phosh_notification_content_get_notification(self_: /*Ignored*/*mut PhoshNotificationContent) -> /*Ignored*/*mut PhoshNotification;

    //=========================================================================
    // PhoshNotificationFrame
    //=========================================================================
    pub fn phosh_notification_frame_get_type() -> GType;
    pub fn phosh_notification_frame_new(show_body: gboolean, action_filters: *const *const c_char) -> *mut gtk::GtkWidget;
    //pub fn phosh_notification_frame_bind_model(self_: /*Ignored*/*mut PhoshNotificationFrame, model: *mut gio::GListModel);
    //pub fn phosh_notification_frame_bind_notification(self_: /*Ignored*/*mut PhoshNotificationFrame, notification: /*Ignored*/*mut PhoshNotification);
    //pub fn phosh_notification_frame_get_action_filter_keys(self_: /*Ignored*/*mut PhoshNotificationFrame) -> *const *const c_char;

    //=========================================================================
    // PhoshNotificationList
    //=========================================================================
    pub fn phosh_notification_list_get_type() -> GType;
    //pub fn phosh_notification_list_new() -> /*Ignored*/*mut PhoshNotificationList;
    //pub fn phosh_notification_list_add(self_: /*Ignored*/*mut PhoshNotificationList, source_id: *const c_char, notification: /*Ignored*/*mut PhoshNotification);
    //pub fn phosh_notification_list_get_by_id(self_: /*Ignored*/*mut PhoshNotificationList, id: c_uint) -> /*Ignored*/*mut PhoshNotification;

    //=========================================================================
    // PhoshNotificationSource
    //=========================================================================
    pub fn phosh_notification_source_get_type() -> GType;
    //pub fn phosh_notification_source_new(name: *const c_char) -> /*Ignored*/*mut PhoshNotificationSource;
    //pub fn phosh_notification_source_add(self_: /*Ignored*/*mut PhoshNotificationSource, notification: /*Ignored*/*mut PhoshNotification);
    //pub fn phosh_notification_source_get_name(self_: /*Ignored*/*mut PhoshNotificationSource) -> *const c_char;

    //=========================================================================
    // PhoshNotifyDBusNotificationsProxy
    //=========================================================================
    pub fn phosh_notify_dbus_notifications_proxy_get_type() -> GType;
    //pub fn phosh_notify_dbus_notifications_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshNotifyDBusNotificationsProxy;
    //pub fn phosh_notify_dbus_notifications_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshNotifyDBusNotificationsProxy;
    //pub fn phosh_notify_dbus_notifications_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshNotifyDBusNotificationsProxy;
    //pub fn phosh_notify_dbus_notifications_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshNotifyDBusNotificationsProxy;
    pub fn phosh_notify_dbus_notifications_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_notify_dbus_notifications_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshNotifyDBusNotificationsSkeleton
    //=========================================================================
    pub fn phosh_notify_dbus_notifications_skeleton_get_type() -> GType;
    //pub fn phosh_notify_dbus_notifications_skeleton_new() -> /*Ignored*/*mut PhoshNotifyDBusNotificationsSkeleton;

    //=========================================================================
    // PhoshNotifyFeedback
    //=========================================================================
    pub fn phosh_notify_feedback_get_type() -> GType;
    //pub fn phosh_notify_feedback_new(list: /*Ignored*/*mut PhoshNotificationList) -> /*Ignored*/*mut PhoshNotifyFeedback;
    //pub fn phosh_notify_feedback_check_screen_wakeup(self_: /*Ignored*/*mut PhoshNotifyFeedback, notification: /*Ignored*/*mut PhoshNotification) -> gboolean;

    //=========================================================================
    // PhoshNotifyManager
    //=========================================================================
    pub fn phosh_notify_manager_get_type() -> GType;
    //pub fn phosh_notify_manager_get_default() -> /*Ignored*/*mut PhoshNotifyManager;
    //pub fn phosh_notify_manager_add_notification(self_: /*Ignored*/*mut PhoshNotifyManager, source_id: *const c_char, expire_timeout: c_int, notification: /*Ignored*/*mut PhoshNotification);
    //pub fn phosh_notify_manager_add_shell_notification(self_: /*Ignored*/*mut PhoshNotifyManager, summary: *const c_char, body: *const c_char, icon: *const c_char, expire_timeout: c_int) -> c_uint;
    //pub fn phosh_notify_manager_close_all_notifications(self_: /*Ignored*/*mut PhoshNotifyManager, reaseon: PhoshNotificationReason);
    //pub fn phosh_notify_manager_close_notification_by_id(self_: /*Ignored*/*mut PhoshNotifyManager, id: c_int, reason: PhoshNotificationReason) -> gboolean;
    //pub fn phosh_notify_manager_get_list(self_: /*Ignored*/*mut PhoshNotifyManager) -> /*Ignored*/*mut PhoshNotificationList;
    //pub fn phosh_notify_manager_get_notification_id(self_: /*Ignored*/*mut PhoshNotifyManager) -> c_uint;
    //pub fn phosh_notify_manager_get_show_banners(self_: /*Ignored*/*mut PhoshNotifyManager) -> gboolean;
    //pub fn phosh_notify_manager_get_show_notification_banner(self_: /*Ignored*/*mut PhoshNotifyManager, notification: /*Ignored*/*mut PhoshNotification) -> gboolean;

    //=========================================================================
    // PhoshOfonoDBusManagerProxy
    //=========================================================================
    pub fn phosh_ofono_dbus_manager_proxy_get_type() -> GType;
    //pub fn phosh_ofono_dbus_manager_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOfonoDBusManagerProxy;
    //pub fn phosh_ofono_dbus_manager_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOfonoDBusManagerProxy;
    //pub fn phosh_ofono_dbus_manager_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOfonoDBusManagerProxy;
    //pub fn phosh_ofono_dbus_manager_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOfonoDBusManagerProxy;
    pub fn phosh_ofono_dbus_manager_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_ofono_dbus_manager_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshOfonoDBusManagerSkeleton
    //=========================================================================
    pub fn phosh_ofono_dbus_manager_skeleton_get_type() -> GType;
    //pub fn phosh_ofono_dbus_manager_skeleton_new() -> /*Ignored*/*mut PhoshOfonoDBusManagerSkeleton;

    //=========================================================================
    // PhoshOfonoDBusNetworkRegistrationProxy
    //=========================================================================
    pub fn phosh_ofono_dbus_network_registration_proxy_get_type() -> GType;
    //pub fn phosh_ofono_dbus_network_registration_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOfonoDBusNetworkRegistrationProxy;
    //pub fn phosh_ofono_dbus_network_registration_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOfonoDBusNetworkRegistrationProxy;
    //pub fn phosh_ofono_dbus_network_registration_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOfonoDBusNetworkRegistrationProxy;
    //pub fn phosh_ofono_dbus_network_registration_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOfonoDBusNetworkRegistrationProxy;
    pub fn phosh_ofono_dbus_network_registration_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_ofono_dbus_network_registration_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshOfonoDBusNetworkRegistrationSkeleton
    //=========================================================================
    pub fn phosh_ofono_dbus_network_registration_skeleton_get_type() -> GType;
    //pub fn phosh_ofono_dbus_network_registration_skeleton_new() -> /*Ignored*/*mut PhoshOfonoDBusNetworkRegistrationSkeleton;

    //=========================================================================
    // PhoshOfonoDBusSimManagerProxy
    //=========================================================================
    pub fn phosh_ofono_dbus_sim_manager_proxy_get_type() -> GType;
    //pub fn phosh_ofono_dbus_sim_manager_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOfonoDBusSimManagerProxy;
    //pub fn phosh_ofono_dbus_sim_manager_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOfonoDBusSimManagerProxy;
    //pub fn phosh_ofono_dbus_sim_manager_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOfonoDBusSimManagerProxy;
    //pub fn phosh_ofono_dbus_sim_manager_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOfonoDBusSimManagerProxy;
    pub fn phosh_ofono_dbus_sim_manager_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_ofono_dbus_sim_manager_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshOfonoDBusSimManagerSkeleton
    //=========================================================================
    pub fn phosh_ofono_dbus_sim_manager_skeleton_get_type() -> GType;
    //pub fn phosh_ofono_dbus_sim_manager_skeleton_new() -> /*Ignored*/*mut PhoshOfonoDBusSimManagerSkeleton;

    //=========================================================================
    // PhoshOsdWindow
    //=========================================================================
    pub fn phosh_osd_window_get_type() -> GType;
    pub fn phosh_osd_window_new(connector: *mut c_char, label: *mut c_char, icon_name: *mut c_char, level: c_double, max_level: c_double) -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshOsk0SmPuriOSK0Proxy
    //=========================================================================
    pub fn phosh_osk0_sm_puri_osk0_proxy_get_type() -> GType;
    //pub fn phosh_osk0_sm_puri_osk0_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOsk0SmPuriOSK0Proxy;
    //pub fn phosh_osk0_sm_puri_osk0_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOsk0SmPuriOSK0Proxy;
    //pub fn phosh_osk0_sm_puri_osk0_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOsk0SmPuriOSK0Proxy;
    //pub fn phosh_osk0_sm_puri_osk0_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshOsk0SmPuriOSK0Proxy;
    pub fn phosh_osk0_sm_puri_osk0_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_osk0_sm_puri_osk0_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshOsk0SmPuriOSK0Skeleton
    //=========================================================================
    pub fn phosh_osk0_sm_puri_osk0_skeleton_get_type() -> GType;
    //pub fn phosh_osk0_sm_puri_osk0_skeleton_new() -> /*Ignored*/*mut PhoshOsk0SmPuriOSK0Skeleton;

    //=========================================================================
    // PhoshOskButton
    //=========================================================================
    pub fn phosh_osk_button_get_type() -> GType;
    pub fn phosh_osk_button_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshOskManager
    //=========================================================================
    pub fn phosh_osk_manager_get_type() -> GType;
    //pub fn phosh_osk_manager_new() -> /*Ignored*/*mut PhoshOskManager;
    //pub fn phosh_osk_manager_get_available(self_: /*Ignored*/*mut PhoshOskManager) -> gboolean;
    //pub fn phosh_osk_manager_get_visible(self_: /*Ignored*/*mut PhoshOskManager) -> gboolean;
    //pub fn phosh_osk_manager_set_visible(self_: /*Ignored*/*mut PhoshOskManager, visible: gboolean);

    //=========================================================================
    // PhoshOverview
    //=========================================================================
    pub fn phosh_overview_get_type() -> GType;
    pub fn phosh_overview_new() -> *mut gtk::GtkWidget;
    //pub fn phosh_overview_focus_app_search(self_: /*Ignored*/*mut PhoshOverview);
    //pub fn phosh_overview_get_app_grid(self_: /*Ignored*/*mut PhoshOverview) -> /*Ignored*/*mut PhoshAppGrid;
    //pub fn phosh_overview_handle_search(self_: /*Ignored*/*mut PhoshOverview, event: *mut gdk::GdkEvent) -> gboolean;
    //pub fn phosh_overview_has_running_activities(self_: /*Ignored*/*mut PhoshOverview) -> gboolean;
    //pub fn phosh_overview_reset(self_: /*Ignored*/*mut PhoshOverview);

    //=========================================================================
    // PhoshPasswordEntry
    //=========================================================================
    pub fn phosh_password_entry_get_type() -> GType;
    //pub fn phosh_password_entry_new() -> /*Ignored*/*mut PhoshPasswordEntry;

    //=========================================================================
    // PhoshPluginLoader
    //=========================================================================
    pub fn phosh_plugin_loader_get_type() -> GType;
    //pub fn phosh_plugin_loader_new(plugin_dirs: c_char, extension_point: *const c_char) -> /*Ignored*/*mut PhoshPluginLoader;
    //pub fn phosh_plugin_loader_get_extension_point(self_: /*Ignored*/*mut PhoshPluginLoader) -> *const c_char;
    //pub fn phosh_plugin_loader_get_plugin_dirs(self_: /*Ignored*/*mut PhoshPluginLoader) -> *const *const c_char;
    //pub fn phosh_plugin_loader_load_plugin(self_: /*Ignored*/*mut PhoshPluginLoader, name: *const c_char) -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshPolkitAuthPrompt
    //=========================================================================
    pub fn phosh_polkit_auth_prompt_get_type() -> GType;
    pub fn phosh_polkit_auth_prompt_new(action_id: *const c_char, message: *const c_char, icon_name: *const c_char, cookie: *const c_char, user_names: c_char) -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshPortalAccessManager
    //=========================================================================
    pub fn phosh_portal_access_manager_get_type() -> GType;
    //pub fn phosh_portal_access_manager_new() -> /*Ignored*/*mut PhoshPortalAccessManager;

    //=========================================================================
    // PhoshPortalRequest
    //=========================================================================
    pub fn phosh_portal_request_get_type() -> GType;
    //pub fn phosh_portal_request_new(sender: *const c_char, app_id: *const c_char, id: *const c_char) -> /*Ignored*/*mut PhoshPortalRequest;
    //pub fn phosh_portal_request_export(self_: /*Ignored*/*mut PhoshPortalRequest, connection: *mut gio::GDBusConnection);
    //pub fn phosh_portal_request_exported(self_: /*Ignored*/*mut PhoshPortalRequest) -> gboolean;
    //pub fn phosh_portal_request_unexport(self_: /*Ignored*/*mut PhoshPortalRequest);

    //=========================================================================
    // PhoshPowerMenu
    //=========================================================================
    pub fn phosh_power_menu_get_type() -> GType;
    //pub fn phosh_power_menu_new(monitor: /*Ignored*/*mut PhoshMonitor) -> /*Ignored*/*mut PhoshPowerMenu;
    //pub fn phosh_power_menu_get_show_suspend(self_: /*Ignored*/*mut PhoshPowerMenu) -> gboolean;
    //pub fn phosh_power_menu_set_show_suspend(self_: /*Ignored*/*mut PhoshPowerMenu, show_suspend: gboolean);

    //=========================================================================
    // PhoshPowerMenuManager
    //=========================================================================
    pub fn phosh_power_menu_manager_get_type() -> GType;
    //pub fn phosh_power_menu_manager_new() -> /*Ignored*/*mut PhoshPowerMenuManager;

    //=========================================================================
    // PhoshProximity
    //=========================================================================
    pub fn phosh_proximity_get_type() -> GType;
    //pub fn phosh_proximity_new(sensor_proxy_manager: /*Ignored*/*mut PhoshSensorProxyManager, calls_manager: /*Ignored*/*mut PhoshCallsManager) -> /*Ignored*/*mut PhoshProximity;
    //pub fn phosh_proximity_has_fader(sensor_proxy_manager: /*Ignored*/*mut PhoshProximity) -> gboolean;

    //=========================================================================
    // PhoshQuickSetting
    //=========================================================================
    pub fn phosh_quick_setting_get_type() -> GType;
    pub fn phosh_quick_setting_new() -> *mut gtk::GtkWidget;
    pub fn phosh_quick_setting_open_settings_panel(panel: *const c_char);
    //pub fn phosh_quick_setting_get_active(self_: /*Ignored*/*mut PhoshQuickSetting) -> gboolean;
    //pub fn phosh_quick_setting_get_has_status(self_: /*Ignored*/*mut PhoshQuickSetting) -> gboolean;
    //pub fn phosh_quick_setting_get_present(self_: /*Ignored*/*mut PhoshQuickSetting) -> gboolean;
    //pub fn phosh_quick_setting_get_status_icon(self_: /*Ignored*/*mut PhoshQuickSetting) -> *mut PhoshStatusIcon;
    //pub fn phosh_quick_setting_set_active(self_: /*Ignored*/*mut PhoshQuickSetting, active: gboolean);
    //pub fn phosh_quick_setting_set_has_status(self_: /*Ignored*/*mut PhoshQuickSetting, has_status: gboolean);
    //pub fn phosh_quick_setting_set_present(self_: /*Ignored*/*mut PhoshQuickSetting, present: gboolean);
    //pub fn phosh_quick_setting_set_status_icon(self_: /*Ignored*/*mut PhoshQuickSetting, widget: *mut PhoshStatusIcon);

    //=========================================================================
    // PhoshRevealer
    //=========================================================================
    pub fn phosh_revealer_get_type() -> GType;
    pub fn phosh_revealer_new() -> *mut PhoshRevealer;
    pub fn phosh_revealer_get_show_child(self_: *mut PhoshRevealer) -> gboolean;
    pub fn phosh_revealer_set_show_child(self_: *mut PhoshRevealer, show_child: gboolean);

    //=========================================================================
    // PhoshRfkillDBusRfkillProxy
    //=========================================================================
    pub fn phosh_rfkill_dbus_rfkill_proxy_get_type() -> GType;
    //pub fn phosh_rfkill_dbus_rfkill_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshRfkillDBusRfkillProxy;
    //pub fn phosh_rfkill_dbus_rfkill_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshRfkillDBusRfkillProxy;
    //pub fn phosh_rfkill_dbus_rfkill_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshRfkillDBusRfkillProxy;
    //pub fn phosh_rfkill_dbus_rfkill_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshRfkillDBusRfkillProxy;
    pub fn phosh_rfkill_dbus_rfkill_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_rfkill_dbus_rfkill_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshRfkillDBusRfkillSkeleton
    //=========================================================================
    pub fn phosh_rfkill_dbus_rfkill_skeleton_get_type() -> GType;
    //pub fn phosh_rfkill_dbus_rfkill_skeleton_new() -> /*Ignored*/*mut PhoshRfkillDBusRfkillSkeleton;

    //=========================================================================
    // PhoshRotateInfo
    //=========================================================================
    pub fn phosh_rotate_info_get_type() -> GType;
    pub fn phosh_rotate_info_new() -> *mut gtk::GtkWidget;
    //pub fn phosh_rotate_info_get_mode(self_: /*Ignored*/*mut PhoshRotateInfo) -> PhoshRotateInfoMode;
    //pub fn phosh_rotate_info_set_mode(self_: /*Ignored*/*mut PhoshRotateInfo, mode: PhoshRotateInfoMode);

    //=========================================================================
    // PhoshRotationManager
    //=========================================================================
    pub fn phosh_rotation_manager_get_type() -> GType;
    //pub fn phosh_rotation_manager_new(sensor_proxy_manager: /*Ignored*/*mut PhoshSensorProxyManager, lockscreen_manager: /*Ignored*/*mut PhoshLockscreenManager, monitor: /*Ignored*/*mut PhoshMonitor) -> /*Ignored*/*mut PhoshRotationManager;
    //pub fn phosh_rotation_manager_get_mode(self_: /*Ignored*/*mut PhoshRotationManager) -> PhoshRotationManagerMode;
    //pub fn phosh_rotation_manager_get_monitor(self_: /*Ignored*/*mut PhoshRotationManager) -> /*Ignored*/*mut PhoshMonitor;
    //pub fn phosh_rotation_manager_get_orientation_locked(self_: /*Ignored*/*mut PhoshRotationManager) -> gboolean;
    //pub fn phosh_rotation_manager_get_transform(self_: /*Ignored*/*mut PhoshRotationManager) -> PhoshMonitorTransform;
    //pub fn phosh_rotation_manager_set_mode(self_: /*Ignored*/*mut PhoshRotationManager, mode: PhoshRotationManagerMode) -> gboolean;
    //pub fn phosh_rotation_manager_set_monitor(self_: /*Ignored*/*mut PhoshRotationManager, monitor: /*Ignored*/*mut PhoshMonitor);
    //pub fn phosh_rotation_manager_set_orientation_locked(self_: /*Ignored*/*mut PhoshRotationManager, locked: gboolean);
    //pub fn phosh_rotation_manager_set_transform(self_: /*Ignored*/*mut PhoshRotationManager, transform: PhoshMonitorTransform);

    //=========================================================================
    // PhoshRunCommandDialog
    //=========================================================================
    pub fn phosh_run_command_dialog_get_type() -> GType;
    pub fn phosh_run_command_dialog_new() -> *mut gtk::GtkWidget;
    //pub fn phosh_run_command_dialog_set_message(self_: /*Ignored*/*mut PhoshRunCommandDialog, message: *const c_char);

    //=========================================================================
    // PhoshRunCommandManager
    //=========================================================================
    pub fn phosh_run_command_manager_get_type() -> GType;
    //pub fn phosh_run_command_manager_new() -> /*Ignored*/*mut PhoshRunCommandManager;

    //=========================================================================
    // PhoshScreenSaverManager
    //=========================================================================
    pub fn phosh_screen_saver_manager_get_type() -> GType;
    //pub fn phosh_screen_saver_manager_new(lockscreen_manager: /*Ignored*/*mut PhoshLockscreenManager) -> /*Ignored*/*mut PhoshScreenSaverManager;

    //=========================================================================
    // PhoshScreenshotManager
    //=========================================================================
    pub fn phosh_screenshot_manager_get_type() -> GType;
    //pub fn phosh_screenshot_manager_new() -> /*Ignored*/*mut PhoshScreenshotManager;
    //pub fn phosh_screenshot_manager_do_screenshot(self_: /*Ignored*/*mut PhoshScreenshotManager, area: *mut gdk::GdkRectangle, filename: *const c_char, include_cursor: gboolean) -> gboolean;

    //=========================================================================
    // PhoshSensorProxyManager
    //=========================================================================
    pub fn phosh_sensor_proxy_manager_get_type() -> GType;
    //pub fn phosh_sensor_proxy_manager_new(error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshSensorProxyManager;
    //pub fn phosh_sensor_proxy_manager_claim_proximity_sync(self_: /*Ignored*/*mut PhoshSensorProxyManager, error: *mut *mut glib::GError) -> gboolean;

    //=========================================================================
    // PhoshSessionClientPrivateDBusClientPrivateProxy
    //=========================================================================
    pub fn phosh_session_client_private_dbus_client_private_proxy_get_type() -> GType;
    //pub fn phosh_session_client_private_dbus_client_private_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshSessionClientPrivateDBusClientPrivateProxy;
    //pub fn phosh_session_client_private_dbus_client_private_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshSessionClientPrivateDBusClientPrivateProxy;
    //pub fn phosh_session_client_private_dbus_client_private_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshSessionClientPrivateDBusClientPrivateProxy;
    //pub fn phosh_session_client_private_dbus_client_private_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshSessionClientPrivateDBusClientPrivateProxy;
    pub fn phosh_session_client_private_dbus_client_private_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_session_client_private_dbus_client_private_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshSessionClientPrivateDBusClientPrivateSkeleton
    //=========================================================================
    pub fn phosh_session_client_private_dbus_client_private_skeleton_get_type() -> GType;
    //pub fn phosh_session_client_private_dbus_client_private_skeleton_new() -> /*Ignored*/*mut PhoshSessionClientPrivateDBusClientPrivateSkeleton;

    //=========================================================================
    // PhoshSessionManager
    //=========================================================================
    pub fn phosh_session_manager_get_type() -> GType;
    //pub fn phosh_session_manager_new() -> /*Ignored*/*mut PhoshSessionManager;
    //pub fn phosh_session_manager_export_end_session(self_: /*Ignored*/*mut PhoshSessionManager, connection: *mut gio::GDBusConnection);
    //pub fn phosh_session_manager_inhibit(self_: /*Ignored*/*mut PhoshSessionManager, what: PhoshSessionManagerFlags, reason: *const c_char) -> c_uint;
    //pub fn phosh_session_manager_is_active(self_: /*Ignored*/*mut PhoshSessionManager) -> gboolean;
    //pub fn phosh_session_manager_logout(self_: /*Ignored*/*mut PhoshSessionManager);
    //pub fn phosh_session_manager_reboot(self_: /*Ignored*/*mut PhoshSessionManager);
    //pub fn phosh_session_manager_register(self_: /*Ignored*/*mut PhoshSessionManager, app_id: *const c_char, startup_id: *const c_char);
    //pub fn phosh_session_manager_shutdown(self_: /*Ignored*/*mut PhoshSessionManager);
    //pub fn phosh_session_manager_uninhibit(self_: /*Ignored*/*mut PhoshSessionManager, cookie: c_uint);

    //=========================================================================
    // PhoshSessionPresence
    //=========================================================================
    pub fn phosh_session_presence_get_type() -> GType;
    //pub fn phosh_session_presence_get_default_failable() -> /*Ignored*/*mut PhoshSessionPresence;

    //=========================================================================
    // PhoshSessionPresenceDBusPresenceProxy
    //=========================================================================
    pub fn phosh_session_presence_dbus_presence_proxy_get_type() -> GType;
    //pub fn phosh_session_presence_dbus_presence_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshSessionPresenceDBusPresenceProxy;
    //pub fn phosh_session_presence_dbus_presence_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshSessionPresenceDBusPresenceProxy;
    //pub fn phosh_session_presence_dbus_presence_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshSessionPresenceDBusPresenceProxy;
    //pub fn phosh_session_presence_dbus_presence_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> /*Ignored*/*mut PhoshSessionPresenceDBusPresenceProxy;
    pub fn phosh_session_presence_dbus_presence_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_session_presence_dbus_presence_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // PhoshSessionPresenceDBusPresenceSkeleton
    //=========================================================================
    pub fn phosh_session_presence_dbus_presence_skeleton_get_type() -> GType;
    //pub fn phosh_session_presence_dbus_presence_skeleton_new() -> /*Ignored*/*mut PhoshSessionPresenceDBusPresenceSkeleton;

    //=========================================================================
    // PhoshShell
    //=========================================================================
    pub fn phosh_shell_get_type() -> GType;
    pub fn phosh_shell_new() -> *mut PhoshShell;
    pub fn phosh_shell_get_debug_flags() -> PhoshShellDebugFlags;
    pub fn phosh_shell_get_default() -> *mut PhoshShell;
    pub fn phosh_shell_activate_action(self_: *mut PhoshShell, action: *const c_char, parameter: *mut glib::GVariant) -> gboolean;
    pub fn phosh_shell_add_global_keyboard_action_entries(self_: *mut PhoshShell, actions: *const gio::GActionEntry, n_entries: c_int, user_data: gpointer);
    pub fn phosh_shell_enable_power_save(self_: *mut PhoshShell, enable: gboolean);
    pub fn phosh_shell_fade_out(self_: *mut PhoshShell, timeout: c_uint);
    pub fn phosh_shell_get_app_launch_context(self_: *mut PhoshShell) -> *mut gdk::GdkAppLaunchContext;
    //pub fn phosh_shell_get_app_tracker(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshAppTracker;
    pub fn phosh_shell_get_area(self_: *mut PhoshShell, width: *mut c_int, height: *mut c_int);
    //pub fn phosh_shell_get_background_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshBackgroundManager;
    pub fn phosh_shell_get_blanked(self_: *mut PhoshShell) -> gboolean;
    //pub fn phosh_shell_get_builtin_monitor(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshMonitor;
    //pub fn phosh_shell_get_calls_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshCallsManager;
    pub fn phosh_shell_get_docked(self_: *mut PhoshShell) -> gboolean;
    //pub fn phosh_shell_get_docked_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshDockedManager;
    //pub fn phosh_shell_get_emergency_calls_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshEmergencyCallsManager;
    //pub fn phosh_shell_get_feedback_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshFeedbackManager;
    //pub fn phosh_shell_get_gtk_mount_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshGtkMountManager;
    //pub fn phosh_shell_get_hks_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshHksManager;
    //pub fn phosh_shell_get_launcher_entry_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshLauncherEntryManager;
    //pub fn phosh_shell_get_layout_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshLayoutManager;
    //pub fn phosh_shell_get_location_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshLocationManager;
    pub fn phosh_shell_get_locked(self_: *mut PhoshShell) -> gboolean;
    //pub fn phosh_shell_get_lockscreen_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshLockscreenManager;
    pub fn phosh_shell_get_lockscreen_type(self_: *mut PhoshShell) -> GType;
    //pub fn phosh_shell_get_mode_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshModeManager;
    //pub fn phosh_shell_get_monitor_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshMonitorManager;
    //pub fn phosh_shell_get_osk_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshOskManager;
    //pub fn phosh_shell_get_primary_monitor(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshMonitor;
    //pub fn phosh_shell_get_rotation_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshRotationManager;
    //pub fn phosh_shell_get_screen_saver_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshScreenSaverManager;
    //pub fn phosh_shell_get_screenshot_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshScreenshotManager;
    //pub fn phosh_shell_get_session_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshSessionManager;
    pub fn phosh_shell_get_show_splash(self_: *mut PhoshShell) -> gboolean;
    pub fn phosh_shell_get_state(self_: *mut PhoshShell) -> PhoshShellStateFlags;
    //pub fn phosh_shell_get_toplevel_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshToplevelManager;
    //pub fn phosh_shell_get_torch_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshTorchManager;
    pub fn phosh_shell_get_usable_area(self_: *mut PhoshShell, x: *mut c_int, y: *mut c_int, width: *mut c_int, height: *mut c_int);
    //pub fn phosh_shell_get_vpn_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshVpnManager;
    //pub fn phosh_shell_get_wifi_manager(self_: *mut PhoshShell) -> /*Ignored*/*mut PhoshWifiManager;
    pub fn phosh_shell_get_wwan(self_: *mut PhoshShell) -> *mut PhoshWWan;
    pub fn phosh_shell_is_session_active(self_: *mut PhoshShell) -> gboolean;
    pub fn phosh_shell_is_startup_finished(self_: *mut PhoshShell) -> gboolean;
    pub fn phosh_shell_lock(self_: *mut PhoshShell);
    pub fn phosh_shell_remove_global_keyboard_action_entries(self_: *mut PhoshShell, action_names: c_char);
    pub fn phosh_shell_set_default(self_: *mut PhoshShell);
    pub fn phosh_shell_set_locked(self_: *mut PhoshShell, locked: gboolean);
    //pub fn phosh_shell_set_primary_monitor(self_: *mut PhoshShell, monitor: /*Ignored*/*mut PhoshMonitor);
    pub fn phosh_shell_set_state(self_: *mut PhoshShell, state: PhoshShellStateFlags, enabled: gboolean);
    pub fn phosh_shell_started_by_display_manager(self_: *mut PhoshShell) -> gboolean;
    pub fn phosh_shell_unlock(self_: *mut PhoshShell);

    //=========================================================================
    // PhoshSplash
    //=========================================================================
    pub fn phosh_splash_get_type() -> GType;
    pub fn phosh_splash_new(info: *mut gio::GDesktopAppInfo, prefer_dark: gboolean) -> *mut gtk::GtkWidget;
    //pub fn phosh_splash_hide(self_: /*Ignored*/*mut PhoshSplash);

    //=========================================================================
    // PhoshSplashManager
    //=========================================================================
    pub fn phosh_splash_manager_get_type() -> GType;
    //pub fn phosh_splash_manager_new(app_tracker: /*Ignored*/*mut PhoshAppTracker) -> /*Ignored*/*mut PhoshSplashManager;

    //=========================================================================
    // PhoshStatusIcon
    //=========================================================================
    pub fn phosh_status_icon_get_type() -> GType;
    pub fn phosh_status_icon_new() -> *mut gtk::GtkWidget;
    pub fn phosh_status_icon_get_extra_widget(self_: *mut PhoshStatusIcon) -> *mut gtk::GtkWidget;
    pub fn phosh_status_icon_get_icon_name(self_: *mut PhoshStatusIcon) -> *mut c_char;
    pub fn phosh_status_icon_get_icon_size(self_: *mut PhoshStatusIcon) -> gtk::GtkIconSize;
    pub fn phosh_status_icon_get_info(self_: *mut PhoshStatusIcon) -> *mut c_char;
    pub fn phosh_status_icon_get_show_always(self_: *mut PhoshStatusIcon) -> gboolean;
    pub fn phosh_status_icon_set_extra_widget(self_: *mut PhoshStatusIcon, widget: *mut gtk::GtkWidget);
    pub fn phosh_status_icon_set_icon_name(self_: *mut PhoshStatusIcon, icon_name: *const c_char);
    pub fn phosh_status_icon_set_icon_size(self_: *mut PhoshStatusIcon, size: gtk::GtkIconSize);
    pub fn phosh_status_icon_set_info(self_: *mut PhoshStatusIcon, info: *const c_char);
    pub fn phosh_status_icon_set_show_always(self_: *mut PhoshStatusIcon, show_always: gboolean);

    //=========================================================================
    // PhoshStatusPage
    //=========================================================================
    pub fn phosh_status_page_get_type() -> GType;
    //pub fn phosh_status_page_new() -> /*Ignored*/*mut PhoshStatusPage;
    //pub fn phosh_status_page_get_footer(self_: /*Ignored*/*mut PhoshStatusPage) -> *mut gtk::GtkWidget;
    //pub fn phosh_status_page_get_header(self_: /*Ignored*/*mut PhoshStatusPage) -> *mut gtk::GtkWidget;
    //pub fn phosh_status_page_get_title(self_: /*Ignored*/*mut PhoshStatusPage) -> *const c_char;
    //pub fn phosh_status_page_set_footer(self_: /*Ignored*/*mut PhoshStatusPage, footer: *mut gtk::GtkWidget);
    //pub fn phosh_status_page_set_header(self_: /*Ignored*/*mut PhoshStatusPage, header: *mut gtk::GtkWidget);
    //pub fn phosh_status_page_set_title(self_: /*Ignored*/*mut PhoshStatusPage, title: *const c_char);

    //=========================================================================
    // PhoshStatusPagePlaceholder
    //=========================================================================
    pub fn phosh_status_page_placeholder_get_type() -> GType;
    pub fn phosh_status_page_placeholder_new() -> *mut PhoshStatusPagePlaceholder;
    pub fn phosh_status_page_placeholder_get_icon_name(self_: *mut PhoshStatusPagePlaceholder) -> *const c_char;
    pub fn phosh_status_page_placeholder_get_title(self_: *mut PhoshStatusPagePlaceholder) -> *const c_char;
    pub fn phosh_status_page_placeholder_set_icon_name(self_: *mut PhoshStatusPagePlaceholder, icon_name: *const c_char);
    pub fn phosh_status_page_placeholder_set_title(self_: *mut PhoshStatusPagePlaceholder, title: *const c_char);

    //=========================================================================
    // PhoshSuspendManager
    //=========================================================================
    pub fn phosh_suspend_manager_get_type() -> GType;
    //pub fn phosh_suspend_manager_new() -> /*Ignored*/*mut PhoshSuspendManager;

    //=========================================================================
    // PhoshSwipeAwayBin
    //=========================================================================
    pub fn phosh_swipe_away_bin_get_type() -> GType;
    //pub fn phosh_swipe_away_bin_get_allow_negative(self_: /*Ignored*/*mut PhoshSwipeAwayBin) -> gboolean;
    //pub fn phosh_swipe_away_bin_get_reserve_size(self_: /*Ignored*/*mut PhoshSwipeAwayBin) -> gboolean;
    //pub fn phosh_swipe_away_bin_hide(self_: /*Ignored*/*mut PhoshSwipeAwayBin);
    //pub fn phosh_swipe_away_bin_remove(self_: /*Ignored*/*mut PhoshSwipeAwayBin);
    //pub fn phosh_swipe_away_bin_reveal(self_: /*Ignored*/*mut PhoshSwipeAwayBin);
    //pub fn phosh_swipe_away_bin_set_allow_negative(self_: /*Ignored*/*mut PhoshSwipeAwayBin, allow_negative: gboolean);
    //pub fn phosh_swipe_away_bin_set_reserve_size(self_: /*Ignored*/*mut PhoshSwipeAwayBin, reserve_size: gboolean);
    //pub fn phosh_swipe_away_bin_undo(self_: /*Ignored*/*mut PhoshSwipeAwayBin);

    //=========================================================================
    // PhoshSystemModal
    //=========================================================================
    pub fn phosh_system_modal_get_type() -> GType;
    //pub fn phosh_system_modal_new(monitor: /*Ignored*/*mut PhoshMonitor) -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshSystemModalDialog
    //=========================================================================
    pub fn phosh_system_modal_dialog_get_type() -> GType;
    pub fn phosh_system_modal_dialog_new() -> *mut gtk::GtkWidget;
    //pub fn phosh_system_modal_dialog_add_button(self_: /*Ignored*/*mut PhoshSystemModalDialog, button: *mut gtk::GtkWidget, position: c_int);
    //pub fn phosh_system_modal_dialog_close(self_: /*Ignored*/*mut PhoshSystemModalDialog);
    //pub fn phosh_system_modal_dialog_get_buttons(self_: /*Ignored*/*mut PhoshSystemModalDialog) -> *mut glib::GList;
    //pub fn phosh_system_modal_dialog_remove_button(self_: /*Ignored*/*mut PhoshSystemModalDialog, button: *mut gtk::GtkWidget);
    //pub fn phosh_system_modal_dialog_set_content(self_: /*Ignored*/*mut PhoshSystemModalDialog, content: *mut gtk::GtkWidget);
    //pub fn phosh_system_modal_dialog_set_title(self_: /*Ignored*/*mut PhoshSystemModalDialog, title: *const c_char);

    //=========================================================================
    // PhoshThumbnail
    //=========================================================================
    pub fn phosh_thumbnail_get_type() -> GType;
    //pub fn phosh_thumbnail_get_image(self_: /*Ignored*/*mut PhoshThumbnail) -> *mut c_void;
    //pub fn phosh_thumbnail_get_size(self_: /*Ignored*/*mut PhoshThumbnail, width: *mut c_uint, height: *mut c_uint, stride: *mut c_uint);
    //pub fn phosh_thumbnail_is_ready(self_: /*Ignored*/*mut PhoshThumbnail) -> gboolean;

    //=========================================================================
    // PhoshTimestampLabel
    //=========================================================================
    pub fn phosh_timestamp_label_get_type() -> GType;
    //pub fn phosh_timestamp_label_new() -> /*Ignored*/*mut PhoshTimestampLabel;
    //pub fn phosh_timestamp_label_get_timestamp(self_: /*Ignored*/*mut PhoshTimestampLabel) -> *mut glib::GDateTime;
    //pub fn phosh_timestamp_label_set_timestamp(self_: /*Ignored*/*mut PhoshTimestampLabel, date: *mut glib::GDateTime);

    //=========================================================================
    // PhoshTopPanel
    //=========================================================================
    pub fn phosh_top_panel_get_type() -> GType;
    //pub fn phosh_top_panel_new(layer_shell: *mut zwlr_layer_shell_v1, layer_shell_effects: *mut zphoc_layer_shell_effects_v1, monitor: /*Ignored*/*mut PhoshMonitor, layer: u32) -> *mut gtk::GtkWidget;
    //pub fn phosh_top_panel_fold(self_: /*Ignored*/*mut PhoshTopPanel);
    //pub fn phosh_top_panel_get_state(self_: /*Ignored*/*mut PhoshTopPanel) -> PhoshTopPanelState;
    //pub fn phosh_top_panel_toggle_fold(self_: /*Ignored*/*mut PhoshTopPanel);
    //pub fn phosh_top_panel_unfold(self_: /*Ignored*/*mut PhoshTopPanel);

    //=========================================================================
    // PhoshToplevel
    //=========================================================================
    pub fn phosh_toplevel_get_type() -> GType;
    //pub fn phosh_toplevel_new_from_handle(handle: *mut zwlr_foreign_toplevel_handle_v1) -> /*Ignored*/*mut PhoshToplevel;
    //pub fn phosh_toplevel_activate(self_: /*Ignored*/*mut PhoshToplevel, seat: *mut wl_seat);
    //pub fn phosh_toplevel_close(self_: /*Ignored*/*mut PhoshToplevel);
    //pub fn phosh_toplevel_get_app_id(self_: /*Ignored*/*mut PhoshToplevel) -> *const c_char;
    //pub fn phosh_toplevel_get_handle(self_: /*Ignored*/*mut PhoshToplevel) -> *mut zwlr_foreign_toplevel_handle_v1;
    //pub fn phosh_toplevel_get_title(self_: /*Ignored*/*mut PhoshToplevel) -> *const c_char;
    //pub fn phosh_toplevel_is_activated(self_: /*Ignored*/*mut PhoshToplevel) -> gboolean;
    //pub fn phosh_toplevel_is_configured(self_: /*Ignored*/*mut PhoshToplevel) -> gboolean;
    //pub fn phosh_toplevel_is_fullscreen(self_: /*Ignored*/*mut PhoshToplevel) -> gboolean;
    //pub fn phosh_toplevel_is_maximized(self_: /*Ignored*/*mut PhoshToplevel) -> gboolean;

    //=========================================================================
    // PhoshToplevelManager
    //=========================================================================
    pub fn phosh_toplevel_manager_get_type() -> GType;
    //pub fn phosh_toplevel_manager_new() -> /*Ignored*/*mut PhoshToplevelManager;
    //pub fn phosh_toplevel_manager_get_num_toplevels(self_: /*Ignored*/*mut PhoshToplevelManager) -> c_uint;
    //pub fn phosh_toplevel_manager_get_toplevel(self_: /*Ignored*/*mut PhoshToplevelManager, num: c_uint) -> /*Ignored*/*mut PhoshToplevel;

    //=========================================================================
    // PhoshToplevelThumbnail
    //=========================================================================
    pub fn phosh_toplevel_thumbnail_get_type() -> GType;
    //pub fn phosh_toplevel_thumbnail_new_from_toplevel(toplevel: /*Ignored*/*mut PhoshToplevel, max_width: u32, max_height: u32) -> /*Ignored*/*mut PhoshToplevelThumbnail;

    //=========================================================================
    // PhoshTorchInfo
    //=========================================================================
    pub fn phosh_torch_info_get_type() -> GType;
    pub fn phosh_torch_info_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshTorchManager
    //=========================================================================
    pub fn phosh_torch_manager_get_type() -> GType;
    //pub fn phosh_torch_manager_new() -> /*Ignored*/*mut PhoshTorchManager;
    //pub fn phosh_torch_manager_get_brightness(self_: /*Ignored*/*mut PhoshTorchManager) -> c_int;
    //pub fn phosh_torch_manager_get_enabled(self_: /*Ignored*/*mut PhoshTorchManager) -> gboolean;
    //pub fn phosh_torch_manager_get_icon_name(self_: /*Ignored*/*mut PhoshTorchManager) -> *const c_char;
    //pub fn phosh_torch_manager_get_max_brightness(self_: /*Ignored*/*mut PhoshTorchManager) -> c_int;
    //pub fn phosh_torch_manager_get_present(self_: /*Ignored*/*mut PhoshTorchManager) -> gboolean;
    //pub fn phosh_torch_manager_get_scaled_brightness(self_: /*Ignored*/*mut PhoshTorchManager) -> c_double;
    //pub fn phosh_torch_manager_set_scaled_brightness(self_: /*Ignored*/*mut PhoshTorchManager, frac: c_double);
    //pub fn phosh_torch_manager_toggle(self_: /*Ignored*/*mut PhoshTorchManager);

    //=========================================================================
    // PhoshVpnInfo
    //=========================================================================
    pub fn phosh_vpn_info_get_type() -> GType;
    pub fn phosh_vpn_info_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshVpnManager
    //=========================================================================
    pub fn phosh_vpn_manager_get_type() -> GType;
    //pub fn phosh_vpn_manager_new() -> /*Ignored*/*mut PhoshVpnManager;
    //pub fn phosh_vpn_manager_get_enabled(self_: /*Ignored*/*mut PhoshVpnManager) -> gboolean;
    //pub fn phosh_vpn_manager_get_icon_name(self_: /*Ignored*/*mut PhoshVpnManager) -> *const c_char;
    //pub fn phosh_vpn_manager_get_last_connection(self_: /*Ignored*/*mut PhoshVpnManager) -> *const c_char;
    //pub fn phosh_vpn_manager_get_present(self_: /*Ignored*/*mut PhoshVpnManager) -> gboolean;
    //pub fn phosh_vpn_manager_toggle_last_connection(self_: /*Ignored*/*mut PhoshVpnManager);

    //=========================================================================
    // PhoshWWanInfo
    //=========================================================================
    pub fn phosh_wwan_info_get_type() -> GType;
    pub fn phosh_wwan_info_new() -> *mut gtk::GtkWidget;
    //pub fn phosh_wwan_info_get_show_detail(self_: /*Ignored*/*mut PhoshWWanInfo) -> gboolean;
    //pub fn phosh_wwan_info_set_show_detail(self_: /*Ignored*/*mut PhoshWWanInfo, show: gboolean);

    //=========================================================================
    // PhoshWWanMM
    //=========================================================================
    pub fn phosh_wwan_mm_get_type() -> GType;
    //pub fn phosh_wwan_mm_new() -> /*Ignored*/*mut PhoshWWanMM;

    //=========================================================================
    // PhoshWWanManager
    //=========================================================================
    pub fn phosh_wwan_manager_get_type() -> GType;
    //pub fn phosh_wwan_manager_new() -> /*Ignored*/*mut PhoshWWanManager;
    //pub fn phosh_wwan_manager_get_data_enabled(self_: /*Ignored*/*mut PhoshWWanManager) -> gboolean;
    //pub fn phosh_wwan_manager_set_data_enabled(self_: /*Ignored*/*mut PhoshWWanManager, enabled: gboolean);
    //pub fn phosh_wwan_manager_set_enabled(self_: /*Ignored*/*mut PhoshWWanManager, enabled: gboolean);

    //=========================================================================
    // PhoshWWanOfono
    //=========================================================================
    pub fn phosh_wwan_ofono_get_type() -> GType;
    //pub fn phosh_wwan_ofono_new() -> /*Ignored*/*mut PhoshWWanOfono;

    //=========================================================================
    // PhoshWallClock
    //=========================================================================
    pub fn phosh_wall_clock_get_type() -> GType;
    pub fn phosh_wall_clock_new() -> *mut PhoshWallClock;
    pub fn phosh_wall_clock_get_default() -> *mut PhoshWallClock;
    pub fn phosh_wall_clock_get_clock(clock: *mut PhoshWallClock, time_only: gboolean) -> *const c_char;
    pub fn phosh_wall_clock_local_date(clock: *mut PhoshWallClock) -> *mut c_char;
    pub fn phosh_wall_clock_set_default(self_: *mut PhoshWallClock);

    //=========================================================================
    // PhoshWayland
    //=========================================================================
    pub fn phosh_wayland_get_type() -> GType;
    //pub fn phosh_wayland_get_default() -> /*Ignored*/*mut PhoshWayland;
    //pub fn phosh_wayland_get_ext_idle_notifier_v1(self_: /*Ignored*/*mut PhoshWayland) -> *mut ext_idle_notifier_v1;
    //pub fn phosh_wayland_get_phosh_private(self_: /*Ignored*/*mut PhoshWayland) -> *mut phosh_private;
    //pub fn phosh_wayland_get_phosh_private_version(self_: /*Ignored*/*mut PhoshWayland) -> u32;
    //pub fn phosh_wayland_get_seat_capabilities(self_: /*Ignored*/*mut PhoshWayland) -> PhoshWaylandSeatCapabilities;
    //pub fn phosh_wayland_get_wl_outputs(self_: /*Ignored*/*mut PhoshWayland) -> *mut glib::GHashTable;
    //pub fn phosh_wayland_get_wl_seat(self_: /*Ignored*/*mut PhoshWayland) -> *mut wl_seat;
    //pub fn phosh_wayland_get_wl_shm(self_: /*Ignored*/*mut PhoshWayland) -> *mut wl_shm;
    //pub fn phosh_wayland_get_xdg_wm_base(self_: /*Ignored*/*mut PhoshWayland) -> *mut xdg_wm_base;
    //pub fn phosh_wayland_get_zphoc_device_state_v1(self_: /*Ignored*/*mut PhoshWayland) -> *mut zphoc_device_state_v1;
    //pub fn phosh_wayland_get_zphoc_layer_shell_effects_v1(self_: /*Ignored*/*mut PhoshWayland) -> *mut zphoc_layer_shell_effects_v1;
    //pub fn phosh_wayland_get_zwlr_foreign_toplevel_manager_v1(self_: /*Ignored*/*mut PhoshWayland) -> *mut zwlr_foreign_toplevel_manager_v1;
    //pub fn phosh_wayland_get_zwlr_gamma_control_manager_v1(self_: /*Ignored*/*mut PhoshWayland) -> *mut zwlr_gamma_control_manager_v1;
    //pub fn phosh_wayland_get_zwlr_layer_shell_v1(self_: /*Ignored*/*mut PhoshWayland) -> *mut zwlr_layer_shell_v1;
    //pub fn phosh_wayland_get_zwlr_output_manager_v1(self_: /*Ignored*/*mut PhoshWayland) -> *mut zwlr_output_manager_v1;
    //pub fn phosh_wayland_get_zwlr_output_power_manager_v1(self_: /*Ignored*/*mut PhoshWayland) -> *mut zwlr_output_power_manager_v1;
    //pub fn phosh_wayland_get_zwlr_screencopy_manager_v1(self_: /*Ignored*/*mut PhoshWayland) -> *mut zwlr_screencopy_manager_v1;
    //pub fn phosh_wayland_get_zwp_virtual_keyboard_manager_v1(self_: /*Ignored*/*mut PhoshWayland) -> *mut zwp_virtual_keyboard_manager_v1;
    //pub fn phosh_wayland_get_zxdg_output_manager_v1(self_: /*Ignored*/*mut PhoshWayland) -> *mut zxdg_output_manager_v1;
    //pub fn phosh_wayland_has_wl_output(self_: /*Ignored*/*mut PhoshWayland, wl_output: *mut wl_output) -> gboolean;
    //pub fn phosh_wayland_roundtrip(self_: /*Ignored*/*mut PhoshWayland);

    //=========================================================================
    // PhoshWidgetBox
    //=========================================================================
    pub fn phosh_widget_box_get_type() -> GType;
    //pub fn phosh_widget_box_new(plugin_dirs: c_char) -> /*Ignored*/*mut PhoshWidgetBox;
    //pub fn phosh_widget_box_has_plugins(self_: /*Ignored*/*mut PhoshWidgetBox) -> gboolean;
    //pub fn phosh_widget_box_set_plugins(self_: /*Ignored*/*mut PhoshWidgetBox, plugins: c_char);

    //=========================================================================
    // PhoshWifiInfo
    //=========================================================================
    pub fn phosh_wifi_info_get_type() -> GType;
    pub fn phosh_wifi_info_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshWifiManager
    //=========================================================================
    pub fn phosh_wifi_manager_get_type() -> GType;
    //pub fn phosh_wifi_manager_new() -> /*Ignored*/*mut PhoshWifiManager;
    //pub fn phosh_wifi_manager_connect_network(self_: /*Ignored*/*mut PhoshWifiManager, network: /*Ignored*/*mut PhoshWifiNetwork);
    //pub fn phosh_wifi_manager_get_enabled(self_: /*Ignored*/*mut PhoshWifiManager) -> gboolean;
    //pub fn phosh_wifi_manager_get_icon_name(self_: /*Ignored*/*mut PhoshWifiManager) -> *const c_char;
    //pub fn phosh_wifi_manager_get_networks(self_: /*Ignored*/*mut PhoshWifiManager) -> *mut gio::GListStore;
    //pub fn phosh_wifi_manager_get_present(self_: /*Ignored*/*mut PhoshWifiManager) -> gboolean;
    //pub fn phosh_wifi_manager_get_ssid(self_: /*Ignored*/*mut PhoshWifiManager) -> *const c_char;
    //pub fn phosh_wifi_manager_get_state(self_: /*Ignored*/*mut PhoshWifiManager) -> nm::NMActiveConnectionState;
    //pub fn phosh_wifi_manager_get_strength(self_: /*Ignored*/*mut PhoshWifiManager) -> u8;
    //pub fn phosh_wifi_manager_is_hotspot_master(self_: /*Ignored*/*mut PhoshWifiManager) -> gboolean;
    //pub fn phosh_wifi_manager_request_scan(self_: /*Ignored*/*mut PhoshWifiManager);
    //pub fn phosh_wifi_manager_set_enabled(self_: /*Ignored*/*mut PhoshWifiManager, enabled: gboolean);
    //pub fn phosh_wifi_manager_set_hotspot_master(self_: /*Ignored*/*mut PhoshWifiManager, is_hotspot_master: gboolean);

    //=========================================================================
    // PhoshWifiNetwork
    //=========================================================================
    pub fn phosh_wifi_network_get_type() -> GType;
    //pub fn phosh_wifi_network_new_from_access_point(ap: *mut nm::NMAccessPoint, active: gboolean) -> /*Ignored*/*mut PhoshWifiNetwork;
    //pub fn phosh_wifi_network_add_access_point(self_: /*Ignored*/*mut PhoshWifiNetwork, ap: *mut nm::NMAccessPoint, active: gboolean);
    //pub fn phosh_wifi_network_get_active(self_: /*Ignored*/*mut PhoshWifiNetwork) -> gboolean;
    //pub fn phosh_wifi_network_get_best_access_point(self_: /*Ignored*/*mut PhoshWifiNetwork) -> *mut nm::NMAccessPoint;
    //pub fn phosh_wifi_network_get_is_connecting(self_: /*Ignored*/*mut PhoshWifiNetwork) -> gboolean;
    //pub fn phosh_wifi_network_get_mode(self_: /*Ignored*/*mut PhoshWifiNetwork) -> nm::NM80211Mode;
    //pub fn phosh_wifi_network_get_secured(self_: /*Ignored*/*mut PhoshWifiNetwork) -> gboolean;
    //pub fn phosh_wifi_network_get_ssid(self_: /*Ignored*/*mut PhoshWifiNetwork) -> *mut c_char;
    //pub fn phosh_wifi_network_get_strength(self_: /*Ignored*/*mut PhoshWifiNetwork) -> c_uint;
    //pub fn phosh_wifi_network_matches_access_point(self_: /*Ignored*/*mut PhoshWifiNetwork, ap: *mut nm::NMAccessPoint) -> gboolean;
    //pub fn phosh_wifi_network_remove_access_point(self_: /*Ignored*/*mut PhoshWifiNetwork, ap: *mut nm::NMAccessPoint) -> gboolean;
    //pub fn phosh_wifi_network_set_is_connecting(self_: /*Ignored*/*mut PhoshWifiNetwork, is_connecting: gboolean);
    //pub fn phosh_wifi_network_update_active(self_: /*Ignored*/*mut PhoshWifiNetwork, active_ap: *mut nm::NMAccessPoint);

    //=========================================================================
    // PhoshWifiNetworkRow
    //=========================================================================
    pub fn phosh_wifi_network_row_get_type() -> GType;
    //pub fn phosh_wifi_network_row_new(network: /*Ignored*/*mut PhoshWifiNetwork) -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshWifiStatusPage
    //=========================================================================
    pub fn phosh_wifi_status_page_get_type() -> GType;
    pub fn phosh_wifi_status_page_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // PhoshCallsDBusCallsCall
    //=========================================================================
    pub fn phosh_calls_dbus_calls_call_get_type() -> GType;
    pub fn phosh_calls_dbus_calls_call_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_calls_dbus_calls_call_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_calls_dbus_calls_call_call_accept(proxy: *mut PhoshCallsDBusCallsCall, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_calls_dbus_calls_call_call_accept_finish(proxy: *mut PhoshCallsDBusCallsCall, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_calls_dbus_calls_call_call_accept_sync(proxy: *mut PhoshCallsDBusCallsCall, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_calls_dbus_calls_call_call_hangup(proxy: *mut PhoshCallsDBusCallsCall, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_calls_dbus_calls_call_call_hangup_finish(proxy: *mut PhoshCallsDBusCallsCall, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_calls_dbus_calls_call_call_hangup_sync(proxy: *mut PhoshCallsDBusCallsCall, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_calls_dbus_calls_call_call_send_dtmf(proxy: *mut PhoshCallsDBusCallsCall, arg_Tone: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_calls_dbus_calls_call_call_send_dtmf_finish(proxy: *mut PhoshCallsDBusCallsCall, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_calls_dbus_calls_call_call_send_dtmf_sync(proxy: *mut PhoshCallsDBusCallsCall, arg_Tone: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_calls_dbus_calls_call_complete_accept(object: *mut PhoshCallsDBusCallsCall, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_calls_dbus_calls_call_complete_hangup(object: *mut PhoshCallsDBusCallsCall, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_calls_dbus_calls_call_complete_send_dtmf(object: *mut PhoshCallsDBusCallsCall, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_calls_dbus_calls_call_dup_display_name(object: *mut PhoshCallsDBusCallsCall) -> *mut c_char;
    pub fn phosh_calls_dbus_calls_call_dup_id(object: *mut PhoshCallsDBusCallsCall) -> *mut c_char;
    pub fn phosh_calls_dbus_calls_call_dup_image_path(object: *mut PhoshCallsDBusCallsCall) -> *mut c_char;
    pub fn phosh_calls_dbus_calls_call_dup_protocol(object: *mut PhoshCallsDBusCallsCall) -> *mut c_char;
    pub fn phosh_calls_dbus_calls_call_get_can_dtmf(object: *mut PhoshCallsDBusCallsCall) -> gboolean;
    pub fn phosh_calls_dbus_calls_call_get_display_name(object: *mut PhoshCallsDBusCallsCall) -> *const c_char;
    pub fn phosh_calls_dbus_calls_call_get_encrypted(object: *mut PhoshCallsDBusCallsCall) -> gboolean;
    pub fn phosh_calls_dbus_calls_call_get_id(object: *mut PhoshCallsDBusCallsCall) -> *const c_char;
    pub fn phosh_calls_dbus_calls_call_get_image_path(object: *mut PhoshCallsDBusCallsCall) -> *const c_char;
    pub fn phosh_calls_dbus_calls_call_get_inbound(object: *mut PhoshCallsDBusCallsCall) -> gboolean;
    pub fn phosh_calls_dbus_calls_call_get_protocol(object: *mut PhoshCallsDBusCallsCall) -> *const c_char;
    pub fn phosh_calls_dbus_calls_call_get_state(object: *mut PhoshCallsDBusCallsCall) -> c_uint;
    pub fn phosh_calls_dbus_calls_call_set_can_dtmf(object: *mut PhoshCallsDBusCallsCall, value: gboolean);
    pub fn phosh_calls_dbus_calls_call_set_display_name(object: *mut PhoshCallsDBusCallsCall, value: *const c_char);
    pub fn phosh_calls_dbus_calls_call_set_encrypted(object: *mut PhoshCallsDBusCallsCall, value: gboolean);
    pub fn phosh_calls_dbus_calls_call_set_id(object: *mut PhoshCallsDBusCallsCall, value: *const c_char);
    pub fn phosh_calls_dbus_calls_call_set_image_path(object: *mut PhoshCallsDBusCallsCall, value: *const c_char);
    pub fn phosh_calls_dbus_calls_call_set_inbound(object: *mut PhoshCallsDBusCallsCall, value: gboolean);
    pub fn phosh_calls_dbus_calls_call_set_protocol(object: *mut PhoshCallsDBusCallsCall, value: *const c_char);
    pub fn phosh_calls_dbus_calls_call_set_state(object: *mut PhoshCallsDBusCallsCall, value: c_uint);

    //=========================================================================
    // PhoshCallsDBusObject
    //=========================================================================
    pub fn phosh_calls_dbus_object_get_type() -> GType;
    pub fn phosh_calls_dbus_object_get_calls_call(object: *mut PhoshCallsDBusObject) -> *mut PhoshCallsDBusCallsCall;
    pub fn phosh_calls_dbus_object_peek_calls_call(object: *mut PhoshCallsDBusObject) -> *mut PhoshCallsDBusCallsCall;

    //=========================================================================
    // PhoshDBusColor
    //=========================================================================
    pub fn phosh_dbus_color_get_type() -> GType;
    pub fn phosh_dbus_color_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_color_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_color_get_night_light_active(object: *mut PhoshDBusColor) -> gboolean;
    pub fn phosh_dbus_color_get_temperature(object: *mut PhoshDBusColor) -> c_uint;
    pub fn phosh_dbus_color_set_night_light_active(object: *mut PhoshDBusColor, value: gboolean);
    pub fn phosh_dbus_color_set_temperature(object: *mut PhoshDBusColor, value: c_uint);

    //=========================================================================
    // PhoshDBusDisplayConfig
    //=========================================================================
    pub fn phosh_dbus_display_config_get_type() -> GType;
    pub fn phosh_dbus_display_config_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_display_config_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_display_config_call_apply_configuration(proxy: *mut PhoshDBusDisplayConfig, arg_serial: c_uint, arg_persistent: gboolean, arg_crtcs: *mut glib::GVariant, arg_outputs: *mut glib::GVariant, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_display_config_call_apply_configuration_finish(proxy: *mut PhoshDBusDisplayConfig, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_apply_configuration_sync(proxy: *mut PhoshDBusDisplayConfig, arg_serial: c_uint, arg_persistent: gboolean, arg_crtcs: *mut glib::GVariant, arg_outputs: *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_apply_monitors_config(proxy: *mut PhoshDBusDisplayConfig, arg_serial: c_uint, arg_method: c_uint, arg_logical_monitors: *mut glib::GVariant, arg_properties: *mut glib::GVariant, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_display_config_call_apply_monitors_config_finish(proxy: *mut PhoshDBusDisplayConfig, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_apply_monitors_config_sync(proxy: *mut PhoshDBusDisplayConfig, arg_serial: c_uint, arg_method: c_uint, arg_logical_monitors: *mut glib::GVariant, arg_properties: *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_change_backlight(proxy: *mut PhoshDBusDisplayConfig, arg_serial: c_uint, arg_output: c_uint, arg_value: c_int, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_display_config_call_change_backlight_finish(proxy: *mut PhoshDBusDisplayConfig, out_new_value: *mut c_int, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_change_backlight_sync(proxy: *mut PhoshDBusDisplayConfig, arg_serial: c_uint, arg_output: c_uint, arg_value: c_int, out_new_value: *mut c_int, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_get_crtc_gamma(proxy: *mut PhoshDBusDisplayConfig, arg_serial: c_uint, arg_crtc: c_uint, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_display_config_call_get_crtc_gamma_finish(proxy: *mut PhoshDBusDisplayConfig, out_red: *mut *mut glib::GVariant, out_green: *mut *mut glib::GVariant, out_blue: *mut *mut glib::GVariant, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_get_crtc_gamma_sync(proxy: *mut PhoshDBusDisplayConfig, arg_serial: c_uint, arg_crtc: c_uint, out_red: *mut *mut glib::GVariant, out_green: *mut *mut glib::GVariant, out_blue: *mut *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_get_current_state(proxy: *mut PhoshDBusDisplayConfig, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_display_config_call_get_current_state_finish(proxy: *mut PhoshDBusDisplayConfig, out_serial: *mut c_uint, out_monitors: *mut *mut glib::GVariant, out_logical_monitors: *mut *mut glib::GVariant, out_properties: *mut *mut glib::GVariant, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_get_current_state_sync(proxy: *mut PhoshDBusDisplayConfig, out_serial: *mut c_uint, out_monitors: *mut *mut glib::GVariant, out_logical_monitors: *mut *mut glib::GVariant, out_properties: *mut *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_get_resources(proxy: *mut PhoshDBusDisplayConfig, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_display_config_call_get_resources_finish(proxy: *mut PhoshDBusDisplayConfig, out_serial: *mut c_uint, out_crtcs: *mut *mut glib::GVariant, out_outputs: *mut *mut glib::GVariant, out_modes: *mut *mut glib::GVariant, out_max_screen_width: *mut c_int, out_max_screen_height: *mut c_int, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_get_resources_sync(proxy: *mut PhoshDBusDisplayConfig, out_serial: *mut c_uint, out_crtcs: *mut *mut glib::GVariant, out_outputs: *mut *mut glib::GVariant, out_modes: *mut *mut glib::GVariant, out_max_screen_width: *mut c_int, out_max_screen_height: *mut c_int, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_set_crtc_gamma(proxy: *mut PhoshDBusDisplayConfig, arg_serial: c_uint, arg_crtc: c_uint, arg_red: *mut glib::GVariant, arg_green: *mut glib::GVariant, arg_blue: *mut glib::GVariant, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_display_config_call_set_crtc_gamma_finish(proxy: *mut PhoshDBusDisplayConfig, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_set_crtc_gamma_sync(proxy: *mut PhoshDBusDisplayConfig, arg_serial: c_uint, arg_crtc: c_uint, arg_red: *mut glib::GVariant, arg_green: *mut glib::GVariant, arg_blue: *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_set_output_ctm(proxy: *mut PhoshDBusDisplayConfig, arg_serial: c_uint, arg_output: c_uint, arg_ctm: *mut glib::GVariant, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_display_config_call_set_output_ctm_finish(proxy: *mut PhoshDBusDisplayConfig, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_call_set_output_ctm_sync(proxy: *mut PhoshDBusDisplayConfig, arg_serial: c_uint, arg_output: c_uint, arg_ctm: *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_display_config_complete_apply_configuration(object: *mut PhoshDBusDisplayConfig, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_display_config_complete_apply_monitors_config(object: *mut PhoshDBusDisplayConfig, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_display_config_complete_change_backlight(object: *mut PhoshDBusDisplayConfig, invocation: *mut gio::GDBusMethodInvocation, new_value: c_int);
    pub fn phosh_dbus_display_config_complete_get_crtc_gamma(object: *mut PhoshDBusDisplayConfig, invocation: *mut gio::GDBusMethodInvocation, red: *mut glib::GVariant, green: *mut glib::GVariant, blue: *mut glib::GVariant);
    pub fn phosh_dbus_display_config_complete_get_current_state(object: *mut PhoshDBusDisplayConfig, invocation: *mut gio::GDBusMethodInvocation, serial: c_uint, monitors: *mut glib::GVariant, logical_monitors: *mut glib::GVariant, properties: *mut glib::GVariant);
    pub fn phosh_dbus_display_config_complete_get_resources(object: *mut PhoshDBusDisplayConfig, invocation: *mut gio::GDBusMethodInvocation, serial: c_uint, crtcs: *mut glib::GVariant, outputs: *mut glib::GVariant, modes: *mut glib::GVariant, max_screen_width: c_int, max_screen_height: c_int);
    pub fn phosh_dbus_display_config_complete_set_crtc_gamma(object: *mut PhoshDBusDisplayConfig, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_display_config_complete_set_output_ctm(object: *mut PhoshDBusDisplayConfig, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_display_config_emit_monitors_changed(object: *mut PhoshDBusDisplayConfig);
    pub fn phosh_dbus_display_config_get_apply_monitors_config_allowed(object: *mut PhoshDBusDisplayConfig) -> gboolean;
    pub fn phosh_dbus_display_config_get_night_light_supported(object: *mut PhoshDBusDisplayConfig) -> gboolean;
    pub fn phosh_dbus_display_config_get_panel_orientation_managed(object: *mut PhoshDBusDisplayConfig) -> gboolean;
    pub fn phosh_dbus_display_config_get_power_save_mode(object: *mut PhoshDBusDisplayConfig) -> c_int;
    pub fn phosh_dbus_display_config_set_apply_monitors_config_allowed(object: *mut PhoshDBusDisplayConfig, value: gboolean);
    pub fn phosh_dbus_display_config_set_night_light_supported(object: *mut PhoshDBusDisplayConfig, value: gboolean);
    pub fn phosh_dbus_display_config_set_panel_orientation_managed(object: *mut PhoshDBusDisplayConfig, value: gboolean);
    pub fn phosh_dbus_display_config_set_power_save_mode(object: *mut PhoshDBusDisplayConfig, value: c_int);

    //=========================================================================
    // PhoshDBusEndSessionDialog
    //=========================================================================
    pub fn phosh_dbus_end_session_dialog_get_type() -> GType;
    pub fn phosh_dbus_end_session_dialog_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_end_session_dialog_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_end_session_dialog_call_open(proxy: *mut PhoshDBusEndSessionDialog, arg_type: c_uint, arg_timestamp: c_uint, arg_seconds_to_stay_open: c_uint, arg_inhibitor_object_paths: *const *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_end_session_dialog_call_open_finish(proxy: *mut PhoshDBusEndSessionDialog, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_end_session_dialog_call_open_sync(proxy: *mut PhoshDBusEndSessionDialog, arg_type: c_uint, arg_timestamp: c_uint, arg_seconds_to_stay_open: c_uint, arg_inhibitor_object_paths: *const *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_end_session_dialog_complete_open(object: *mut PhoshDBusEndSessionDialog, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_end_session_dialog_emit_canceled(object: *mut PhoshDBusEndSessionDialog);
    pub fn phosh_dbus_end_session_dialog_emit_closed(object: *mut PhoshDBusEndSessionDialog);
    pub fn phosh_dbus_end_session_dialog_emit_confirmed_hibernate(object: *mut PhoshDBusEndSessionDialog);
    pub fn phosh_dbus_end_session_dialog_emit_confirmed_hybrid_sleep(object: *mut PhoshDBusEndSessionDialog);
    pub fn phosh_dbus_end_session_dialog_emit_confirmed_logout(object: *mut PhoshDBusEndSessionDialog);
    pub fn phosh_dbus_end_session_dialog_emit_confirmed_reboot(object: *mut PhoshDBusEndSessionDialog);
    pub fn phosh_dbus_end_session_dialog_emit_confirmed_shutdown(object: *mut PhoshDBusEndSessionDialog);
    pub fn phosh_dbus_end_session_dialog_emit_confirmed_suspend(object: *mut PhoshDBusEndSessionDialog);

    //=========================================================================
    // PhoshDBusGnomeShell
    //=========================================================================
    pub fn phosh_dbus_gnome_shell_get_type() -> GType;
    pub fn phosh_dbus_gnome_shell_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_gnome_shell_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_gnome_shell_call_grab_accelerator(proxy: *mut PhoshDBusGnomeShell, arg_accelerator: *const c_char, arg_modeFlags: c_uint, arg_grabFlags: c_uint, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_gnome_shell_call_grab_accelerator_finish(proxy: *mut PhoshDBusGnomeShell, out_action: *mut c_uint, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_call_grab_accelerator_sync(proxy: *mut PhoshDBusGnomeShell, arg_accelerator: *const c_char, arg_modeFlags: c_uint, arg_grabFlags: c_uint, out_action: *mut c_uint, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_call_grab_accelerators(proxy: *mut PhoshDBusGnomeShell, arg_accelerators: *mut glib::GVariant, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_gnome_shell_call_grab_accelerators_finish(proxy: *mut PhoshDBusGnomeShell, out_actions: *mut *mut glib::GVariant, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_call_grab_accelerators_sync(proxy: *mut PhoshDBusGnomeShell, arg_accelerators: *mut glib::GVariant, out_actions: *mut *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_call_hide_monitor_labels(proxy: *mut PhoshDBusGnomeShell, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_gnome_shell_call_hide_monitor_labels_finish(proxy: *mut PhoshDBusGnomeShell, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_call_hide_monitor_labels_sync(proxy: *mut PhoshDBusGnomeShell, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_call_show_monitor_labels(proxy: *mut PhoshDBusGnomeShell, arg_params: *mut glib::GVariant, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_gnome_shell_call_show_monitor_labels_finish(proxy: *mut PhoshDBusGnomeShell, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_call_show_monitor_labels_sync(proxy: *mut PhoshDBusGnomeShell, arg_params: *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_call_show_osd(proxy: *mut PhoshDBusGnomeShell, arg_params: *mut glib::GVariant, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_gnome_shell_call_show_osd_finish(proxy: *mut PhoshDBusGnomeShell, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_call_show_osd_sync(proxy: *mut PhoshDBusGnomeShell, arg_params: *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_call_ungrab_accelerator(proxy: *mut PhoshDBusGnomeShell, arg_action: c_uint, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_gnome_shell_call_ungrab_accelerator_finish(proxy: *mut PhoshDBusGnomeShell, out_success: *mut gboolean, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_call_ungrab_accelerator_sync(proxy: *mut PhoshDBusGnomeShell, arg_action: c_uint, out_success: *mut gboolean, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_call_ungrab_accelerators(proxy: *mut PhoshDBusGnomeShell, arg_action: *mut glib::GVariant, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_gnome_shell_call_ungrab_accelerators_finish(proxy: *mut PhoshDBusGnomeShell, out_success: *mut gboolean, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_call_ungrab_accelerators_sync(proxy: *mut PhoshDBusGnomeShell, arg_action: *mut glib::GVariant, out_success: *mut gboolean, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_gnome_shell_complete_grab_accelerator(object: *mut PhoshDBusGnomeShell, invocation: *mut gio::GDBusMethodInvocation, action: c_uint);
    pub fn phosh_dbus_gnome_shell_complete_grab_accelerators(object: *mut PhoshDBusGnomeShell, invocation: *mut gio::GDBusMethodInvocation, actions: *mut glib::GVariant);
    pub fn phosh_dbus_gnome_shell_complete_hide_monitor_labels(object: *mut PhoshDBusGnomeShell, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_gnome_shell_complete_show_monitor_labels(object: *mut PhoshDBusGnomeShell, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_gnome_shell_complete_show_osd(object: *mut PhoshDBusGnomeShell, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_gnome_shell_complete_ungrab_accelerator(object: *mut PhoshDBusGnomeShell, invocation: *mut gio::GDBusMethodInvocation, success: gboolean);
    pub fn phosh_dbus_gnome_shell_complete_ungrab_accelerators(object: *mut PhoshDBusGnomeShell, invocation: *mut gio::GDBusMethodInvocation, success: gboolean);
    pub fn phosh_dbus_gnome_shell_dup_shell_version(object: *mut PhoshDBusGnomeShell) -> *mut c_char;
    pub fn phosh_dbus_gnome_shell_emit_accelerator_activated(object: *mut PhoshDBusGnomeShell, arg_action: c_uint, arg_parameters: *mut glib::GVariant);
    pub fn phosh_dbus_gnome_shell_get_overview_active(object: *mut PhoshDBusGnomeShell) -> gboolean;
    pub fn phosh_dbus_gnome_shell_get_shell_version(object: *mut PhoshDBusGnomeShell) -> *const c_char;
    pub fn phosh_dbus_gnome_shell_set_overview_active(object: *mut PhoshDBusGnomeShell, value: gboolean);
    pub fn phosh_dbus_gnome_shell_set_shell_version(object: *mut PhoshDBusGnomeShell, value: *const c_char);

    //=========================================================================
    // PhoshDBusHostname1
    //=========================================================================
    pub fn phosh_dbus_hostname1_get_type() -> GType;
    pub fn phosh_dbus_hostname1_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_hostname1_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_hostname1_dup_chassis(object: *mut PhoshDBusHostname1) -> *mut c_char;
    pub fn phosh_dbus_hostname1_get_chassis(object: *mut PhoshDBusHostname1) -> *const c_char;
    pub fn phosh_dbus_hostname1_set_chassis(object: *mut PhoshDBusHostname1, value: *const c_char);

    //=========================================================================
    // PhoshDBusImplPortalAccess
    //=========================================================================
    pub fn phosh_dbus_impl_portal_access_get_type() -> GType;
    pub fn phosh_dbus_impl_portal_access_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_impl_portal_access_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_impl_portal_access_call_access_dialog(proxy: *mut PhoshDBusImplPortalAccess, arg_handle: *const c_char, arg_app_id: *const c_char, arg_parent_window: *const c_char, arg_title: *const c_char, arg_subtitle: *const c_char, arg_body: *const c_char, arg_options: *mut glib::GVariant, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_impl_portal_access_call_access_dialog_finish(proxy: *mut PhoshDBusImplPortalAccess, out_response: *mut c_uint, out_results: *mut *mut glib::GVariant, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_impl_portal_access_call_access_dialog_sync(proxy: *mut PhoshDBusImplPortalAccess, arg_handle: *const c_char, arg_app_id: *const c_char, arg_parent_window: *const c_char, arg_title: *const c_char, arg_subtitle: *const c_char, arg_body: *const c_char, arg_options: *mut glib::GVariant, out_response: *mut c_uint, out_results: *mut *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_impl_portal_access_complete_access_dialog(object: *mut PhoshDBusImplPortalAccess, invocation: *mut gio::GDBusMethodInvocation, response: c_uint, results: *mut glib::GVariant);

    //=========================================================================
    // PhoshDBusImplPortalRequest
    //=========================================================================
    pub fn phosh_dbus_impl_portal_request_get_type() -> GType;
    pub fn phosh_dbus_impl_portal_request_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_impl_portal_request_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_impl_portal_request_call_close(proxy: *mut PhoshDBusImplPortalRequest, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_impl_portal_request_call_close_finish(proxy: *mut PhoshDBusImplPortalRequest, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_impl_portal_request_call_close_sync(proxy: *mut PhoshDBusImplPortalRequest, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_impl_portal_request_complete_close(object: *mut PhoshDBusImplPortalRequest, invocation: *mut gio::GDBusMethodInvocation);

    //=========================================================================
    // PhoshDBusLoginManager
    //=========================================================================
    pub fn phosh_dbus_login_manager_get_type() -> GType;
    pub fn phosh_dbus_login_manager_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_login_manager_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_login_manager_call_get_session(proxy: *mut PhoshDBusLoginManager, arg_session_id: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_login_manager_call_get_session_finish(proxy: *mut PhoshDBusLoginManager, out_object_path: *mut *mut c_char, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_login_manager_call_get_session_sync(proxy: *mut PhoshDBusLoginManager, arg_session_id: *const c_char, out_object_path: *mut *mut c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_login_manager_call_inhibit(proxy: *mut PhoshDBusLoginManager, arg_what: *const c_char, arg_who: *const c_char, arg_why: *const c_char, arg_mode: *const c_char, fd_list: *mut gio::GUnixFDList, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_login_manager_call_inhibit_finish(proxy: *mut PhoshDBusLoginManager, out_pipe_fd: *mut *mut glib::GVariant, out_fd_list: *mut *mut gio::GUnixFDList, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_login_manager_call_inhibit_sync(proxy: *mut PhoshDBusLoginManager, arg_what: *const c_char, arg_who: *const c_char, arg_why: *const c_char, arg_mode: *const c_char, fd_list: *mut gio::GUnixFDList, out_pipe_fd: *mut *mut glib::GVariant, out_fd_list: *mut *mut gio::GUnixFDList, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_login_manager_call_suspend(proxy: *mut PhoshDBusLoginManager, arg_unnamed_arg0: gboolean, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_login_manager_call_suspend_finish(proxy: *mut PhoshDBusLoginManager, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_login_manager_call_suspend_sync(proxy: *mut PhoshDBusLoginManager, arg_unnamed_arg0: gboolean, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_login_manager_complete_get_session(object: *mut PhoshDBusLoginManager, invocation: *mut gio::GDBusMethodInvocation, object_path: *const c_char);
    pub fn phosh_dbus_login_manager_complete_inhibit(object: *mut PhoshDBusLoginManager, invocation: *mut gio::GDBusMethodInvocation, fd_list: *mut gio::GUnixFDList, pipe_fd: *mut glib::GVariant);
    pub fn phosh_dbus_login_manager_complete_suspend(object: *mut PhoshDBusLoginManager, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_login_manager_emit_prepare_for_sleep(object: *mut PhoshDBusLoginManager, arg_suspending: gboolean);

    //=========================================================================
    // PhoshDBusLoginSession
    //=========================================================================
    pub fn phosh_dbus_login_session_get_type() -> GType;
    pub fn phosh_dbus_login_session_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_login_session_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_login_session_call_set_brightness(proxy: *mut PhoshDBusLoginSession, arg_subsystem: *const c_char, arg_name: *const c_char, arg_brightness: c_uint, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_login_session_call_set_brightness_finish(proxy: *mut PhoshDBusLoginSession, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_login_session_call_set_brightness_sync(proxy: *mut PhoshDBusLoginSession, arg_subsystem: *const c_char, arg_name: *const c_char, arg_brightness: c_uint, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_login_session_call_set_locked_hint(proxy: *mut PhoshDBusLoginSession, arg_unnamed_arg0: gboolean, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_login_session_call_set_locked_hint_finish(proxy: *mut PhoshDBusLoginSession, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_login_session_call_set_locked_hint_sync(proxy: *mut PhoshDBusLoginSession, arg_unnamed_arg0: gboolean, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_login_session_complete_set_brightness(object: *mut PhoshDBusLoginSession, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_login_session_complete_set_locked_hint(object: *mut PhoshDBusLoginSession, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_login_session_emit_lock(object: *mut PhoshDBusLoginSession);
    pub fn phosh_dbus_login_session_emit_unlock(object: *mut PhoshDBusLoginSession);
    pub fn phosh_dbus_login_session_get_active(object: *mut PhoshDBusLoginSession) -> gboolean;
    pub fn phosh_dbus_login_session_get_locked_hint(object: *mut PhoshDBusLoginSession) -> gboolean;
    pub fn phosh_dbus_login_session_set_active(object: *mut PhoshDBusLoginSession, value: gboolean);
    pub fn phosh_dbus_login_session_set_locked_hint(object: *mut PhoshDBusLoginSession, value: gboolean);

    //=========================================================================
    // PhoshDBusMountOperationHandler
    //=========================================================================
    pub fn phosh_dbus_mount_operation_handler_get_type() -> GType;
    pub fn phosh_dbus_mount_operation_handler_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_mount_operation_handler_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_mount_operation_handler_call_ask_password(proxy: *mut PhoshDBusMountOperationHandler, arg_object_id: *const c_char, arg_message: *const c_char, arg_icon_name: *const c_char, arg_default_user: *const c_char, arg_default_domain: *const c_char, arg_flags: c_uint, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_mount_operation_handler_call_ask_password_finish(proxy: *mut PhoshDBusMountOperationHandler, out_response: *mut c_uint, out_response_details: *mut *mut glib::GVariant, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_mount_operation_handler_call_ask_password_sync(proxy: *mut PhoshDBusMountOperationHandler, arg_object_id: *const c_char, arg_message: *const c_char, arg_icon_name: *const c_char, arg_default_user: *const c_char, arg_default_domain: *const c_char, arg_flags: c_uint, out_response: *mut c_uint, out_response_details: *mut *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_mount_operation_handler_call_ask_question(proxy: *mut PhoshDBusMountOperationHandler, arg_object_id: *const c_char, arg_message: *const c_char, arg_icon_name: *const c_char, arg_choices: *const *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_mount_operation_handler_call_ask_question_finish(proxy: *mut PhoshDBusMountOperationHandler, out_response: *mut c_uint, out_response_details: *mut *mut glib::GVariant, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_mount_operation_handler_call_ask_question_sync(proxy: *mut PhoshDBusMountOperationHandler, arg_object_id: *const c_char, arg_message: *const c_char, arg_icon_name: *const c_char, arg_choices: *const *const c_char, out_response: *mut c_uint, out_response_details: *mut *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_mount_operation_handler_call_close(proxy: *mut PhoshDBusMountOperationHandler, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_mount_operation_handler_call_close_finish(proxy: *mut PhoshDBusMountOperationHandler, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_mount_operation_handler_call_close_sync(proxy: *mut PhoshDBusMountOperationHandler, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_mount_operation_handler_call_show_processes(proxy: *mut PhoshDBusMountOperationHandler, arg_object_id: *const c_char, arg_message: *const c_char, arg_icon_name: *const c_char, arg_application_pids: *mut glib::GVariant, arg_choices: *const *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_mount_operation_handler_call_show_processes_finish(proxy: *mut PhoshDBusMountOperationHandler, out_response: *mut c_uint, out_response_details: *mut *mut glib::GVariant, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_mount_operation_handler_call_show_processes_sync(proxy: *mut PhoshDBusMountOperationHandler, arg_object_id: *const c_char, arg_message: *const c_char, arg_icon_name: *const c_char, arg_application_pids: *mut glib::GVariant, arg_choices: *const *const c_char, out_response: *mut c_uint, out_response_details: *mut *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_mount_operation_handler_complete_ask_password(object: *mut PhoshDBusMountOperationHandler, invocation: *mut gio::GDBusMethodInvocation, response: c_uint, response_details: *mut glib::GVariant);
    pub fn phosh_dbus_mount_operation_handler_complete_ask_question(object: *mut PhoshDBusMountOperationHandler, invocation: *mut gio::GDBusMethodInvocation, response: c_uint, response_details: *mut glib::GVariant);
    pub fn phosh_dbus_mount_operation_handler_complete_close(object: *mut PhoshDBusMountOperationHandler, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_mount_operation_handler_complete_show_processes(object: *mut PhoshDBusMountOperationHandler, invocation: *mut gio::GDBusMethodInvocation, response: c_uint, response_details: *mut glib::GVariant);

    //=========================================================================
    // PhoshDBusScreenSaver
    //=========================================================================
    pub fn phosh_dbus_screen_saver_get_type() -> GType;
    pub fn phosh_dbus_screen_saver_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_screen_saver_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_screen_saver_call_get_active(proxy: *mut PhoshDBusScreenSaver, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_screen_saver_call_get_active_finish(proxy: *mut PhoshDBusScreenSaver, out_active: *mut gboolean, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screen_saver_call_get_active_sync(proxy: *mut PhoshDBusScreenSaver, out_active: *mut gboolean, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screen_saver_call_get_active_time(proxy: *mut PhoshDBusScreenSaver, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_screen_saver_call_get_active_time_finish(proxy: *mut PhoshDBusScreenSaver, out_value: *mut c_uint, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screen_saver_call_get_active_time_sync(proxy: *mut PhoshDBusScreenSaver, out_value: *mut c_uint, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screen_saver_call_lock(proxy: *mut PhoshDBusScreenSaver, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_screen_saver_call_lock_finish(proxy: *mut PhoshDBusScreenSaver, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screen_saver_call_lock_sync(proxy: *mut PhoshDBusScreenSaver, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screen_saver_call_set_active(proxy: *mut PhoshDBusScreenSaver, arg_value: gboolean, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_screen_saver_call_set_active_finish(proxy: *mut PhoshDBusScreenSaver, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screen_saver_call_set_active_sync(proxy: *mut PhoshDBusScreenSaver, arg_value: gboolean, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screen_saver_complete_get_active(object: *mut PhoshDBusScreenSaver, invocation: *mut gio::GDBusMethodInvocation, active: gboolean);
    pub fn phosh_dbus_screen_saver_complete_get_active_time(object: *mut PhoshDBusScreenSaver, invocation: *mut gio::GDBusMethodInvocation, value: c_uint);
    pub fn phosh_dbus_screen_saver_complete_lock(object: *mut PhoshDBusScreenSaver, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_screen_saver_complete_set_active(object: *mut PhoshDBusScreenSaver, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_screen_saver_emit_active_changed(object: *mut PhoshDBusScreenSaver, arg_new_value: gboolean);
    pub fn phosh_dbus_screen_saver_emit_wake_up_screen(object: *mut PhoshDBusScreenSaver);

    //=========================================================================
    // PhoshDBusScreenshot
    //=========================================================================
    pub fn phosh_dbus_screenshot_get_type() -> GType;
    pub fn phosh_dbus_screenshot_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_screenshot_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_screenshot_call_flash_area(proxy: *mut PhoshDBusScreenshot, arg_x: c_int, arg_y: c_int, arg_width: c_int, arg_height: c_int, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_screenshot_call_flash_area_finish(proxy: *mut PhoshDBusScreenshot, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screenshot_call_flash_area_sync(proxy: *mut PhoshDBusScreenshot, arg_x: c_int, arg_y: c_int, arg_width: c_int, arg_height: c_int, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screenshot_call_pick_color(proxy: *mut PhoshDBusScreenshot, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_screenshot_call_pick_color_finish(proxy: *mut PhoshDBusScreenshot, out_result: *mut *mut glib::GVariant, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screenshot_call_pick_color_sync(proxy: *mut PhoshDBusScreenshot, out_result: *mut *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screenshot_call_screenshot(proxy: *mut PhoshDBusScreenshot, arg_include_cursor: gboolean, arg_flash: gboolean, arg_filename: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_screenshot_call_screenshot_area(proxy: *mut PhoshDBusScreenshot, arg_x: c_int, arg_y: c_int, arg_width: c_int, arg_height: c_int, arg_flash: gboolean, arg_filename: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_screenshot_call_screenshot_area_finish(proxy: *mut PhoshDBusScreenshot, out_success: *mut gboolean, out_filename_used: *mut *mut c_char, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screenshot_call_screenshot_area_sync(proxy: *mut PhoshDBusScreenshot, arg_x: c_int, arg_y: c_int, arg_width: c_int, arg_height: c_int, arg_flash: gboolean, arg_filename: *const c_char, out_success: *mut gboolean, out_filename_used: *mut *mut c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screenshot_call_screenshot_finish(proxy: *mut PhoshDBusScreenshot, out_success: *mut gboolean, out_filename_used: *mut *mut c_char, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screenshot_call_screenshot_sync(proxy: *mut PhoshDBusScreenshot, arg_include_cursor: gboolean, arg_flash: gboolean, arg_filename: *const c_char, out_success: *mut gboolean, out_filename_used: *mut *mut c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screenshot_call_screenshot_window(proxy: *mut PhoshDBusScreenshot, arg_include_frame: gboolean, arg_include_cursor: gboolean, arg_flash: gboolean, arg_filename: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_screenshot_call_screenshot_window_finish(proxy: *mut PhoshDBusScreenshot, out_success: *mut gboolean, out_filename_used: *mut *mut c_char, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screenshot_call_screenshot_window_sync(proxy: *mut PhoshDBusScreenshot, arg_include_frame: gboolean, arg_include_cursor: gboolean, arg_flash: gboolean, arg_filename: *const c_char, out_success: *mut gboolean, out_filename_used: *mut *mut c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screenshot_call_select_area(proxy: *mut PhoshDBusScreenshot, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_screenshot_call_select_area_finish(proxy: *mut PhoshDBusScreenshot, out_x: *mut c_int, out_y: *mut c_int, out_width: *mut c_int, out_height: *mut c_int, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screenshot_call_select_area_sync(proxy: *mut PhoshDBusScreenshot, out_x: *mut c_int, out_y: *mut c_int, out_width: *mut c_int, out_height: *mut c_int, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_screenshot_complete_flash_area(object: *mut PhoshDBusScreenshot, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_screenshot_complete_pick_color(object: *mut PhoshDBusScreenshot, invocation: *mut gio::GDBusMethodInvocation, result: *mut glib::GVariant);
    pub fn phosh_dbus_screenshot_complete_screenshot(object: *mut PhoshDBusScreenshot, invocation: *mut gio::GDBusMethodInvocation, success: gboolean, filename_used: *const c_char);
    pub fn phosh_dbus_screenshot_complete_screenshot_area(object: *mut PhoshDBusScreenshot, invocation: *mut gio::GDBusMethodInvocation, success: gboolean, filename_used: *const c_char);
    pub fn phosh_dbus_screenshot_complete_screenshot_window(object: *mut PhoshDBusScreenshot, invocation: *mut gio::GDBusMethodInvocation, success: gboolean, filename_used: *const c_char);
    pub fn phosh_dbus_screenshot_complete_select_area(object: *mut PhoshDBusScreenshot, invocation: *mut gio::GDBusMethodInvocation, x: c_int, y: c_int, width: c_int, height: c_int);

    //=========================================================================
    // PhoshDBusSensorProxy
    //=========================================================================
    pub fn phosh_dbus_sensor_proxy_get_type() -> GType;
    pub fn phosh_dbus_sensor_proxy_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_sensor_proxy_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_sensor_proxy_call_claim_accelerometer(proxy: *mut PhoshDBusSensorProxy, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_sensor_proxy_call_claim_accelerometer_finish(proxy: *mut PhoshDBusSensorProxy, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_call_claim_accelerometer_sync(proxy: *mut PhoshDBusSensorProxy, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_call_claim_light(proxy: *mut PhoshDBusSensorProxy, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_sensor_proxy_call_claim_light_finish(proxy: *mut PhoshDBusSensorProxy, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_call_claim_light_sync(proxy: *mut PhoshDBusSensorProxy, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_call_claim_proximity(proxy: *mut PhoshDBusSensorProxy, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_sensor_proxy_call_claim_proximity_finish(proxy: *mut PhoshDBusSensorProxy, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_call_claim_proximity_sync(proxy: *mut PhoshDBusSensorProxy, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_call_release_accelerometer(proxy: *mut PhoshDBusSensorProxy, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_sensor_proxy_call_release_accelerometer_finish(proxy: *mut PhoshDBusSensorProxy, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_call_release_accelerometer_sync(proxy: *mut PhoshDBusSensorProxy, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_call_release_light(proxy: *mut PhoshDBusSensorProxy, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_sensor_proxy_call_release_light_finish(proxy: *mut PhoshDBusSensorProxy, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_call_release_light_sync(proxy: *mut PhoshDBusSensorProxy, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_call_release_proximity(proxy: *mut PhoshDBusSensorProxy, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_sensor_proxy_call_release_proximity_finish(proxy: *mut PhoshDBusSensorProxy, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_call_release_proximity_sync(proxy: *mut PhoshDBusSensorProxy, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_complete_claim_accelerometer(object: *mut PhoshDBusSensorProxy, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_sensor_proxy_complete_claim_light(object: *mut PhoshDBusSensorProxy, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_sensor_proxy_complete_claim_proximity(object: *mut PhoshDBusSensorProxy, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_sensor_proxy_complete_release_accelerometer(object: *mut PhoshDBusSensorProxy, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_sensor_proxy_complete_release_light(object: *mut PhoshDBusSensorProxy, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_sensor_proxy_complete_release_proximity(object: *mut PhoshDBusSensorProxy, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_sensor_proxy_dup_accelerometer_orientation(object: *mut PhoshDBusSensorProxy) -> *mut c_char;
    pub fn phosh_dbus_sensor_proxy_dup_light_level_unit(object: *mut PhoshDBusSensorProxy) -> *mut c_char;
    pub fn phosh_dbus_sensor_proxy_get_accelerometer_orientation(object: *mut PhoshDBusSensorProxy) -> *const c_char;
    pub fn phosh_dbus_sensor_proxy_get_has_accelerometer(object: *mut PhoshDBusSensorProxy) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_get_has_ambient_light(object: *mut PhoshDBusSensorProxy) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_get_has_proximity(object: *mut PhoshDBusSensorProxy) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_get_light_level(object: *mut PhoshDBusSensorProxy) -> c_double;
    pub fn phosh_dbus_sensor_proxy_get_light_level_unit(object: *mut PhoshDBusSensorProxy) -> *const c_char;
    pub fn phosh_dbus_sensor_proxy_get_proximity_near(object: *mut PhoshDBusSensorProxy) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_set_accelerometer_orientation(object: *mut PhoshDBusSensorProxy, value: *const c_char);
    pub fn phosh_dbus_sensor_proxy_set_has_accelerometer(object: *mut PhoshDBusSensorProxy, value: gboolean);
    pub fn phosh_dbus_sensor_proxy_set_has_ambient_light(object: *mut PhoshDBusSensorProxy, value: gboolean);
    pub fn phosh_dbus_sensor_proxy_set_has_proximity(object: *mut PhoshDBusSensorProxy, value: gboolean);
    pub fn phosh_dbus_sensor_proxy_set_light_level(object: *mut PhoshDBusSensorProxy, value: c_double);
    pub fn phosh_dbus_sensor_proxy_set_light_level_unit(object: *mut PhoshDBusSensorProxy, value: *const c_char);
    pub fn phosh_dbus_sensor_proxy_set_proximity_near(object: *mut PhoshDBusSensorProxy, value: gboolean);

    //=========================================================================
    // PhoshDBusSensorProxyCompass
    //=========================================================================
    pub fn phosh_dbus_sensor_proxy_compass_get_type() -> GType;
    pub fn phosh_dbus_sensor_proxy_compass_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_sensor_proxy_compass_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_sensor_proxy_compass_call_claim_compass(proxy: *mut PhoshDBusSensorProxyCompass, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_sensor_proxy_compass_call_claim_compass_finish(proxy: *mut PhoshDBusSensorProxyCompass, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_compass_call_claim_compass_sync(proxy: *mut PhoshDBusSensorProxyCompass, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_compass_call_release_compass(proxy: *mut PhoshDBusSensorProxyCompass, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_sensor_proxy_compass_call_release_compass_finish(proxy: *mut PhoshDBusSensorProxyCompass, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_compass_call_release_compass_sync(proxy: *mut PhoshDBusSensorProxyCompass, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_compass_complete_claim_compass(object: *mut PhoshDBusSensorProxyCompass, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_sensor_proxy_compass_complete_release_compass(object: *mut PhoshDBusSensorProxyCompass, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_sensor_proxy_compass_get_compass_heading(object: *mut PhoshDBusSensorProxyCompass) -> c_double;
    pub fn phosh_dbus_sensor_proxy_compass_get_has_compass(object: *mut PhoshDBusSensorProxyCompass) -> gboolean;
    pub fn phosh_dbus_sensor_proxy_compass_set_compass_heading(object: *mut PhoshDBusSensorProxyCompass, value: c_double);
    pub fn phosh_dbus_sensor_proxy_compass_set_has_compass(object: *mut PhoshDBusSensorProxyCompass, value: gboolean);

    //=========================================================================
    // PhoshDBusSessionManager
    //=========================================================================
    pub fn phosh_dbus_session_manager_get_type() -> GType;
    pub fn phosh_dbus_session_manager_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_dbus_session_manager_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_dbus_session_manager_call_can_shutdown(proxy: *mut PhoshDBusSessionManager, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_session_manager_call_can_shutdown_finish(proxy: *mut PhoshDBusSessionManager, out_unnamed_arg0: *mut gboolean, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_can_shutdown_sync(proxy: *mut PhoshDBusSessionManager, out_unnamed_arg0: *mut gboolean, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_inhibit(proxy: *mut PhoshDBusSessionManager, arg_app_id: *const c_char, arg_toplevel_xid: c_uint, arg_reason: *const c_char, arg_flags: c_uint, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_session_manager_call_inhibit_finish(proxy: *mut PhoshDBusSessionManager, out_inhibit_cookie: *mut c_uint, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_inhibit_sync(proxy: *mut PhoshDBusSessionManager, arg_app_id: *const c_char, arg_toplevel_xid: c_uint, arg_reason: *const c_char, arg_flags: c_uint, out_inhibit_cookie: *mut c_uint, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_is_inhibited(proxy: *mut PhoshDBusSessionManager, arg_unnamed_arg0: c_uint, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_session_manager_call_is_inhibited_finish(proxy: *mut PhoshDBusSessionManager, out_unnamed_arg1: *mut gboolean, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_is_inhibited_sync(proxy: *mut PhoshDBusSessionManager, arg_unnamed_arg0: c_uint, out_unnamed_arg1: *mut gboolean, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_logout(proxy: *mut PhoshDBusSessionManager, arg_mode: c_uint, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_session_manager_call_logout_finish(proxy: *mut PhoshDBusSessionManager, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_logout_sync(proxy: *mut PhoshDBusSessionManager, arg_mode: c_uint, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_reboot(proxy: *mut PhoshDBusSessionManager, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_session_manager_call_reboot_finish(proxy: *mut PhoshDBusSessionManager, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_reboot_sync(proxy: *mut PhoshDBusSessionManager, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_register_client(proxy: *mut PhoshDBusSessionManager, arg_app_id: *const c_char, arg_client_startup_id: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_session_manager_call_register_client_finish(proxy: *mut PhoshDBusSessionManager, out_client_id: *mut *mut c_char, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_register_client_sync(proxy: *mut PhoshDBusSessionManager, arg_app_id: *const c_char, arg_client_startup_id: *const c_char, out_client_id: *mut *mut c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_shutdown(proxy: *mut PhoshDBusSessionManager, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_session_manager_call_shutdown_finish(proxy: *mut PhoshDBusSessionManager, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_shutdown_sync(proxy: *mut PhoshDBusSessionManager, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_uninhibit(proxy: *mut PhoshDBusSessionManager, arg_inhibit_cookie: c_uint, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_dbus_session_manager_call_uninhibit_finish(proxy: *mut PhoshDBusSessionManager, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_call_uninhibit_sync(proxy: *mut PhoshDBusSessionManager, arg_inhibit_cookie: c_uint, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_dbus_session_manager_complete_can_shutdown(object: *mut PhoshDBusSessionManager, invocation: *mut gio::GDBusMethodInvocation, unnamed_arg0: gboolean);
    pub fn phosh_dbus_session_manager_complete_inhibit(object: *mut PhoshDBusSessionManager, invocation: *mut gio::GDBusMethodInvocation, inhibit_cookie: c_uint);
    pub fn phosh_dbus_session_manager_complete_is_inhibited(object: *mut PhoshDBusSessionManager, invocation: *mut gio::GDBusMethodInvocation, unnamed_arg1: gboolean);
    pub fn phosh_dbus_session_manager_complete_logout(object: *mut PhoshDBusSessionManager, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_session_manager_complete_reboot(object: *mut PhoshDBusSessionManager, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_session_manager_complete_register_client(object: *mut PhoshDBusSessionManager, invocation: *mut gio::GDBusMethodInvocation, client_id: *const c_char);
    pub fn phosh_dbus_session_manager_complete_shutdown(object: *mut PhoshDBusSessionManager, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_session_manager_complete_uninhibit(object: *mut PhoshDBusSessionManager, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_dbus_session_manager_emit_inhibitor_added(object: *mut PhoshDBusSessionManager, arg_unnamed_arg0: *const c_char);
    pub fn phosh_dbus_session_manager_emit_inhibitor_removed(object: *mut PhoshDBusSessionManager, arg_unnamed_arg0: *const c_char);
    pub fn phosh_dbus_session_manager_get_session_is_active(object: *mut PhoshDBusSessionManager) -> gboolean;
    pub fn phosh_dbus_session_manager_set_session_is_active(object: *mut PhoshDBusSessionManager, value: gboolean);

    //=========================================================================
    // PhoshEmergencyCalls
    //=========================================================================
    pub fn phosh_emergency_calls_get_type() -> GType;
    pub fn phosh_emergency_calls_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_emergency_calls_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_emergency_calls_call_call_emergency_contact(proxy: *mut PhoshEmergencyCalls, arg_id: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_emergency_calls_call_call_emergency_contact_finish(proxy: *mut PhoshEmergencyCalls, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_emergency_calls_call_call_emergency_contact_sync(proxy: *mut PhoshEmergencyCalls, arg_id: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_emergency_calls_call_get_emergency_contacts(proxy: *mut PhoshEmergencyCalls, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_emergency_calls_call_get_emergency_contacts_finish(proxy: *mut PhoshEmergencyCalls, out_contacts: *mut *mut glib::GVariant, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_emergency_calls_call_get_emergency_contacts_sync(proxy: *mut PhoshEmergencyCalls, out_contacts: *mut *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_emergency_calls_complete_call_emergency_contact(object: *mut PhoshEmergencyCalls, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_emergency_calls_complete_get_emergency_contacts(object: *mut PhoshEmergencyCalls, invocation: *mut gio::GDBusMethodInvocation, contacts: *mut glib::GVariant);
    pub fn phosh_emergency_calls_emit_emergency_numbers_changed(object: *mut PhoshEmergencyCalls);

    //=========================================================================
    // PhoshGeoClueDBusManager
    //=========================================================================
    pub fn phosh_geo_clue_dbus_manager_get_type() -> GType;
    pub fn phosh_geo_clue_dbus_manager_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_geo_clue_dbus_manager_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_geo_clue_dbus_manager_call_add_agent(proxy: *mut PhoshGeoClueDBusManager, arg_id: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_geo_clue_dbus_manager_call_add_agent_finish(proxy: *mut PhoshGeoClueDBusManager, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_geo_clue_dbus_manager_call_add_agent_sync(proxy: *mut PhoshGeoClueDBusManager, arg_id: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_geo_clue_dbus_manager_complete_add_agent(object: *mut PhoshGeoClueDBusManager, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_geo_clue_dbus_manager_get_available_accuracy_level(object: *mut PhoshGeoClueDBusManager) -> c_uint;
    pub fn phosh_geo_clue_dbus_manager_get_in_use(object: *mut PhoshGeoClueDBusManager) -> gboolean;
    pub fn phosh_geo_clue_dbus_manager_set_available_accuracy_level(object: *mut PhoshGeoClueDBusManager, value: c_uint);
    pub fn phosh_geo_clue_dbus_manager_set_in_use(object: *mut PhoshGeoClueDBusManager, value: gboolean);

    //=========================================================================
    // PhoshGeoClueDBusOrgFreedesktopGeoClue2Agent
    //=========================================================================
    pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_get_type() -> GType;
    pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_call_authorize_app(proxy: *mut PhoshGeoClueDBusOrgFreedesktopGeoClue2Agent, arg_desktop_id: *const c_char, arg_req_accuracy_level: c_uint, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_call_authorize_app_finish(proxy: *mut PhoshGeoClueDBusOrgFreedesktopGeoClue2Agent, out_authorized: *mut gboolean, out_allowed_accuracy_level: *mut c_uint, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_call_authorize_app_sync(proxy: *mut PhoshGeoClueDBusOrgFreedesktopGeoClue2Agent, arg_desktop_id: *const c_char, arg_req_accuracy_level: c_uint, out_authorized: *mut gboolean, out_allowed_accuracy_level: *mut c_uint, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_complete_authorize_app(object: *mut PhoshGeoClueDBusOrgFreedesktopGeoClue2Agent, invocation: *mut gio::GDBusMethodInvocation, authorized: gboolean, allowed_accuracy_level: c_uint);
    pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_get_max_accuracy_level(object: *mut PhoshGeoClueDBusOrgFreedesktopGeoClue2Agent) -> c_uint;
    pub fn phosh_geo_clue_dbus_org_freedesktop_geo_clue2_agent_set_max_accuracy_level(object: *mut PhoshGeoClueDBusOrgFreedesktopGeoClue2Agent, value: c_uint);

    //=========================================================================
    // PhoshIdleDBusIdleMonitor
    //=========================================================================
    pub fn phosh_idle_dbus_idle_monitor_get_type() -> GType;
    pub fn phosh_idle_dbus_idle_monitor_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_idle_dbus_idle_monitor_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_idle_dbus_idle_monitor_call_add_idle_watch(proxy: *mut PhoshIdleDBusIdleMonitor, arg_interval: u64, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_idle_dbus_idle_monitor_call_add_idle_watch_finish(proxy: *mut PhoshIdleDBusIdleMonitor, out_id: *mut c_uint, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_idle_dbus_idle_monitor_call_add_idle_watch_sync(proxy: *mut PhoshIdleDBusIdleMonitor, arg_interval: u64, out_id: *mut c_uint, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_idle_dbus_idle_monitor_call_add_user_active_watch(proxy: *mut PhoshIdleDBusIdleMonitor, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_idle_dbus_idle_monitor_call_add_user_active_watch_finish(proxy: *mut PhoshIdleDBusIdleMonitor, out_id: *mut c_uint, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_idle_dbus_idle_monitor_call_add_user_active_watch_sync(proxy: *mut PhoshIdleDBusIdleMonitor, out_id: *mut c_uint, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_idle_dbus_idle_monitor_call_get_idletime(proxy: *mut PhoshIdleDBusIdleMonitor, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_idle_dbus_idle_monitor_call_get_idletime_finish(proxy: *mut PhoshIdleDBusIdleMonitor, out_idletime: *mut u64, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_idle_dbus_idle_monitor_call_get_idletime_sync(proxy: *mut PhoshIdleDBusIdleMonitor, out_idletime: *mut u64, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_idle_dbus_idle_monitor_call_remove_watch(proxy: *mut PhoshIdleDBusIdleMonitor, arg_id: c_uint, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_idle_dbus_idle_monitor_call_remove_watch_finish(proxy: *mut PhoshIdleDBusIdleMonitor, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_idle_dbus_idle_monitor_call_remove_watch_sync(proxy: *mut PhoshIdleDBusIdleMonitor, arg_id: c_uint, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_idle_dbus_idle_monitor_complete_add_idle_watch(object: *mut PhoshIdleDBusIdleMonitor, invocation: *mut gio::GDBusMethodInvocation, id: c_uint);
    pub fn phosh_idle_dbus_idle_monitor_complete_add_user_active_watch(object: *mut PhoshIdleDBusIdleMonitor, invocation: *mut gio::GDBusMethodInvocation, id: c_uint);
    pub fn phosh_idle_dbus_idle_monitor_complete_get_idletime(object: *mut PhoshIdleDBusIdleMonitor, invocation: *mut gio::GDBusMethodInvocation, idletime: u64);
    pub fn phosh_idle_dbus_idle_monitor_complete_remove_watch(object: *mut PhoshIdleDBusIdleMonitor, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_idle_dbus_idle_monitor_emit_watch_fired(object: *mut PhoshIdleDBusIdleMonitor, arg_id: c_uint);

    //=========================================================================
    // PhoshIdleDBusObject
    //=========================================================================
    pub fn phosh_idle_dbus_object_get_type() -> GType;
    pub fn phosh_idle_dbus_object_get_idle_monitor(object: *mut PhoshIdleDBusObject) -> *mut PhoshIdleDBusIdleMonitor;
    pub fn phosh_idle_dbus_object_peek_idle_monitor(object: *mut PhoshIdleDBusObject) -> *mut PhoshIdleDBusIdleMonitor;

    //=========================================================================
    // PhoshMMDBusModem
    //=========================================================================
    pub fn phosh_mm_dbus_modem_get_type() -> GType;
    pub fn phosh_mm_dbus_modem_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_mm_dbus_modem_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_mm_dbus_modem_dup_signal_quality(object: *mut PhoshMMDBusModem) -> *mut glib::GVariant;
    pub fn phosh_mm_dbus_modem_dup_sim(object: *mut PhoshMMDBusModem) -> *mut c_char;
    pub fn phosh_mm_dbus_modem_get_access_technologies(object: *mut PhoshMMDBusModem) -> c_uint;
    pub fn phosh_mm_dbus_modem_get_signal_quality(object: *mut PhoshMMDBusModem) -> *mut glib::GVariant;
    pub fn phosh_mm_dbus_modem_get_sim(object: *mut PhoshMMDBusModem) -> *const c_char;
    pub fn phosh_mm_dbus_modem_get_state(object: *mut PhoshMMDBusModem) -> c_int;
    pub fn phosh_mm_dbus_modem_get_unlock_required(object: *mut PhoshMMDBusModem) -> c_uint;
    pub fn phosh_mm_dbus_modem_set_access_technologies(object: *mut PhoshMMDBusModem, value: c_uint);
    pub fn phosh_mm_dbus_modem_set_signal_quality(object: *mut PhoshMMDBusModem, value: *mut glib::GVariant);
    pub fn phosh_mm_dbus_modem_set_sim(object: *mut PhoshMMDBusModem, value: *const c_char);
    pub fn phosh_mm_dbus_modem_set_state(object: *mut PhoshMMDBusModem, value: c_int);
    pub fn phosh_mm_dbus_modem_set_unlock_required(object: *mut PhoshMMDBusModem, value: c_uint);

    //=========================================================================
    // PhoshMMDBusModemModem3gpp
    //=========================================================================
    pub fn phosh_mm_dbus_modem_modem3gpp_get_type() -> GType;
    pub fn phosh_mm_dbus_modem_modem3gpp_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_mm_dbus_modem_modem3gpp_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_mm_dbus_modem_modem3gpp_dup_operator_name(object: *mut PhoshMMDBusModemModem3gpp) -> *mut c_char;
    pub fn phosh_mm_dbus_modem_modem3gpp_get_operator_name(object: *mut PhoshMMDBusModemModem3gpp) -> *const c_char;
    pub fn phosh_mm_dbus_modem_modem3gpp_set_operator_name(object: *mut PhoshMMDBusModemModem3gpp, value: *const c_char);

    //=========================================================================
    // PhoshMMDBusObject
    //=========================================================================
    pub fn phosh_mm_dbus_object_get_type() -> GType;
    pub fn phosh_mm_dbus_object_get_modem(object: *mut PhoshMMDBusObject) -> *mut PhoshMMDBusModem;
    pub fn phosh_mm_dbus_object_get_modem_modem3gpp(object: *mut PhoshMMDBusObject) -> *mut PhoshMMDBusModemModem3gpp;
    pub fn phosh_mm_dbus_object_peek_modem(object: *mut PhoshMMDBusObject) -> *mut PhoshMMDBusModem;
    pub fn phosh_mm_dbus_object_peek_modem_modem3gpp(object: *mut PhoshMMDBusObject) -> *mut PhoshMMDBusModemModem3gpp;

    //=========================================================================
    // PhoshMprisDBusMediaPlayer2
    //=========================================================================
    pub fn phosh_mpris_dbus_media_player2_get_type() -> GType;
    pub fn phosh_mpris_dbus_media_player2_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_mpris_dbus_media_player2_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_mpris_dbus_media_player2_call_raise(proxy: *mut PhoshMprisDBusMediaPlayer2, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_mpris_dbus_media_player2_call_raise_finish(proxy: *mut PhoshMprisDBusMediaPlayer2, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_call_raise_sync(proxy: *mut PhoshMprisDBusMediaPlayer2, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_complete_raise(object: *mut PhoshMprisDBusMediaPlayer2, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_mpris_dbus_media_player2_dup_desktop_entry(object: *mut PhoshMprisDBusMediaPlayer2) -> *mut c_char;
    pub fn phosh_mpris_dbus_media_player2_get_can_raise(object: *mut PhoshMprisDBusMediaPlayer2) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_get_desktop_entry(object: *mut PhoshMprisDBusMediaPlayer2) -> *const c_char;
    pub fn phosh_mpris_dbus_media_player2_set_can_raise(object: *mut PhoshMprisDBusMediaPlayer2, value: gboolean);
    pub fn phosh_mpris_dbus_media_player2_set_desktop_entry(object: *mut PhoshMprisDBusMediaPlayer2, value: *const c_char);

    //=========================================================================
    // PhoshMprisDBusMediaPlayer2Player
    //=========================================================================
    pub fn phosh_mpris_dbus_media_player2_player_get_type() -> GType;
    pub fn phosh_mpris_dbus_media_player2_player_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_mpris_dbus_media_player2_player_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_mpris_dbus_media_player2_player_call_next(proxy: *mut PhoshMprisDBusMediaPlayer2Player, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_mpris_dbus_media_player2_player_call_next_finish(proxy: *mut PhoshMprisDBusMediaPlayer2Player, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_player_call_next_sync(proxy: *mut PhoshMprisDBusMediaPlayer2Player, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_player_call_play_pause(proxy: *mut PhoshMprisDBusMediaPlayer2Player, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_mpris_dbus_media_player2_player_call_play_pause_finish(proxy: *mut PhoshMprisDBusMediaPlayer2Player, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_player_call_play_pause_sync(proxy: *mut PhoshMprisDBusMediaPlayer2Player, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_player_call_previous(proxy: *mut PhoshMprisDBusMediaPlayer2Player, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_mpris_dbus_media_player2_player_call_previous_finish(proxy: *mut PhoshMprisDBusMediaPlayer2Player, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_player_call_previous_sync(proxy: *mut PhoshMprisDBusMediaPlayer2Player, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_player_call_seek(proxy: *mut PhoshMprisDBusMediaPlayer2Player, arg_Offset: i64, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_mpris_dbus_media_player2_player_call_seek_finish(proxy: *mut PhoshMprisDBusMediaPlayer2Player, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_player_call_seek_sync(proxy: *mut PhoshMprisDBusMediaPlayer2Player, arg_Offset: i64, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_player_complete_next(object: *mut PhoshMprisDBusMediaPlayer2Player, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_mpris_dbus_media_player2_player_complete_play_pause(object: *mut PhoshMprisDBusMediaPlayer2Player, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_mpris_dbus_media_player2_player_complete_previous(object: *mut PhoshMprisDBusMediaPlayer2Player, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_mpris_dbus_media_player2_player_complete_seek(object: *mut PhoshMprisDBusMediaPlayer2Player, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_mpris_dbus_media_player2_player_dup_metadata(object: *mut PhoshMprisDBusMediaPlayer2Player) -> *mut glib::GVariant;
    pub fn phosh_mpris_dbus_media_player2_player_dup_playback_status(object: *mut PhoshMprisDBusMediaPlayer2Player) -> *mut c_char;
    pub fn phosh_mpris_dbus_media_player2_player_get_can_go_next(object: *mut PhoshMprisDBusMediaPlayer2Player) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_player_get_can_go_previous(object: *mut PhoshMprisDBusMediaPlayer2Player) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_player_get_can_play(object: *mut PhoshMprisDBusMediaPlayer2Player) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_player_get_can_seek(object: *mut PhoshMprisDBusMediaPlayer2Player) -> gboolean;
    pub fn phosh_mpris_dbus_media_player2_player_get_metadata(object: *mut PhoshMprisDBusMediaPlayer2Player) -> *mut glib::GVariant;
    pub fn phosh_mpris_dbus_media_player2_player_get_playback_status(object: *mut PhoshMprisDBusMediaPlayer2Player) -> *const c_char;
    pub fn phosh_mpris_dbus_media_player2_player_set_can_go_next(object: *mut PhoshMprisDBusMediaPlayer2Player, value: gboolean);
    pub fn phosh_mpris_dbus_media_player2_player_set_can_go_previous(object: *mut PhoshMprisDBusMediaPlayer2Player, value: gboolean);
    pub fn phosh_mpris_dbus_media_player2_player_set_can_play(object: *mut PhoshMprisDBusMediaPlayer2Player, value: gboolean);
    pub fn phosh_mpris_dbus_media_player2_player_set_can_seek(object: *mut PhoshMprisDBusMediaPlayer2Player, value: gboolean);
    pub fn phosh_mpris_dbus_media_player2_player_set_metadata(object: *mut PhoshMprisDBusMediaPlayer2Player, value: *mut glib::GVariant);
    pub fn phosh_mpris_dbus_media_player2_player_set_playback_status(object: *mut PhoshMprisDBusMediaPlayer2Player, value: *const c_char);

    //=========================================================================
    // PhoshNotifyDBusNotifications
    //=========================================================================
    pub fn phosh_notify_dbus_notifications_get_type() -> GType;
    pub fn phosh_notify_dbus_notifications_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_notify_dbus_notifications_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_notify_dbus_notifications_call_close_notification(proxy: *mut PhoshNotifyDBusNotifications, arg_id: c_uint, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_notify_dbus_notifications_call_close_notification_finish(proxy: *mut PhoshNotifyDBusNotifications, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_notify_dbus_notifications_call_close_notification_sync(proxy: *mut PhoshNotifyDBusNotifications, arg_id: c_uint, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_notify_dbus_notifications_call_get_capabilities(proxy: *mut PhoshNotifyDBusNotifications, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_notify_dbus_notifications_call_get_capabilities_finish(proxy: *mut PhoshNotifyDBusNotifications, out_capabilities: *mut *mut *mut c_char, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_notify_dbus_notifications_call_get_capabilities_sync(proxy: *mut PhoshNotifyDBusNotifications, out_capabilities: *mut *mut *mut c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_notify_dbus_notifications_call_get_server_information(proxy: *mut PhoshNotifyDBusNotifications, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_notify_dbus_notifications_call_get_server_information_finish(proxy: *mut PhoshNotifyDBusNotifications, out_name: *mut *mut c_char, out_vendor: *mut *mut c_char, out_version: *mut *mut c_char, out_spec_version: *mut *mut c_char, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_notify_dbus_notifications_call_get_server_information_sync(proxy: *mut PhoshNotifyDBusNotifications, out_name: *mut *mut c_char, out_vendor: *mut *mut c_char, out_version: *mut *mut c_char, out_spec_version: *mut *mut c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_notify_dbus_notifications_call_notify(proxy: *mut PhoshNotifyDBusNotifications, arg_app_name: *const c_char, arg_replaces_id: c_uint, arg_app_icon: *const c_char, arg_summary: *const c_char, arg_body: *const c_char, arg_actions: *const *const c_char, arg_hints: *mut glib::GVariant, arg_expire_timeout: c_int, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_notify_dbus_notifications_call_notify_finish(proxy: *mut PhoshNotifyDBusNotifications, out_id: *mut c_uint, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_notify_dbus_notifications_call_notify_sync(proxy: *mut PhoshNotifyDBusNotifications, arg_app_name: *const c_char, arg_replaces_id: c_uint, arg_app_icon: *const c_char, arg_summary: *const c_char, arg_body: *const c_char, arg_actions: *const *const c_char, arg_hints: *mut glib::GVariant, arg_expire_timeout: c_int, out_id: *mut c_uint, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_notify_dbus_notifications_complete_close_notification(object: *mut PhoshNotifyDBusNotifications, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_notify_dbus_notifications_complete_get_capabilities(object: *mut PhoshNotifyDBusNotifications, invocation: *mut gio::GDBusMethodInvocation, capabilities: *const *const c_char);
    pub fn phosh_notify_dbus_notifications_complete_get_server_information(object: *mut PhoshNotifyDBusNotifications, invocation: *mut gio::GDBusMethodInvocation, name: *const c_char, vendor: *const c_char, version: *const c_char, spec_version: *const c_char);
    pub fn phosh_notify_dbus_notifications_complete_notify(object: *mut PhoshNotifyDBusNotifications, invocation: *mut gio::GDBusMethodInvocation, id: c_uint);
    pub fn phosh_notify_dbus_notifications_emit_action_invoked(object: *mut PhoshNotifyDBusNotifications, arg_id: c_uint, arg_action_key: *const c_char);
    pub fn phosh_notify_dbus_notifications_emit_notification_closed(object: *mut PhoshNotifyDBusNotifications, arg_id: c_uint, arg_reason: c_uint);

    //=========================================================================
    // PhoshOfonoDBusManager
    //=========================================================================
    pub fn phosh_ofono_dbus_manager_get_type() -> GType;
    pub fn phosh_ofono_dbus_manager_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_ofono_dbus_manager_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_ofono_dbus_manager_call_get_modems(proxy: *mut PhoshOfonoDBusManager, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_ofono_dbus_manager_call_get_modems_finish(proxy: *mut PhoshOfonoDBusManager, out_unnamed_arg0: *mut *mut glib::GVariant, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_ofono_dbus_manager_call_get_modems_sync(proxy: *mut PhoshOfonoDBusManager, out_unnamed_arg0: *mut *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_ofono_dbus_manager_complete_get_modems(object: *mut PhoshOfonoDBusManager, invocation: *mut gio::GDBusMethodInvocation, unnamed_arg0: *mut glib::GVariant);
    pub fn phosh_ofono_dbus_manager_emit_modem_added(object: *mut PhoshOfonoDBusManager, arg_unnamed_arg0: *const c_char, arg_unnamed_arg1: *mut glib::GVariant);
    pub fn phosh_ofono_dbus_manager_emit_modem_removed(object: *mut PhoshOfonoDBusManager, arg_unnamed_arg0: *const c_char);

    //=========================================================================
    // PhoshOfonoDBusNetworkRegistration
    //=========================================================================
    pub fn phosh_ofono_dbus_network_registration_get_type() -> GType;
    pub fn phosh_ofono_dbus_network_registration_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_ofono_dbus_network_registration_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_ofono_dbus_network_registration_call_get_properties(proxy: *mut PhoshOfonoDBusNetworkRegistration, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_ofono_dbus_network_registration_call_get_properties_finish(proxy: *mut PhoshOfonoDBusNetworkRegistration, out_properties: *mut *mut glib::GVariant, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_ofono_dbus_network_registration_call_get_properties_sync(proxy: *mut PhoshOfonoDBusNetworkRegistration, out_properties: *mut *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_ofono_dbus_network_registration_complete_get_properties(object: *mut PhoshOfonoDBusNetworkRegistration, invocation: *mut gio::GDBusMethodInvocation, properties: *mut glib::GVariant);
    pub fn phosh_ofono_dbus_network_registration_emit_property_changed(object: *mut PhoshOfonoDBusNetworkRegistration, arg_unnamed_arg0: *const c_char, arg_unnamed_arg1: *mut glib::GVariant);

    //=========================================================================
    // PhoshOfonoDBusSimManager
    //=========================================================================
    pub fn phosh_ofono_dbus_sim_manager_get_type() -> GType;
    pub fn phosh_ofono_dbus_sim_manager_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_ofono_dbus_sim_manager_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_ofono_dbus_sim_manager_call_get_properties(proxy: *mut PhoshOfonoDBusSimManager, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_ofono_dbus_sim_manager_call_get_properties_finish(proxy: *mut PhoshOfonoDBusSimManager, out_properties: *mut *mut glib::GVariant, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_ofono_dbus_sim_manager_call_get_properties_sync(proxy: *mut PhoshOfonoDBusSimManager, out_properties: *mut *mut glib::GVariant, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_ofono_dbus_sim_manager_complete_get_properties(object: *mut PhoshOfonoDBusSimManager, invocation: *mut gio::GDBusMethodInvocation, properties: *mut glib::GVariant);
    pub fn phosh_ofono_dbus_sim_manager_emit_property_changed(object: *mut PhoshOfonoDBusSimManager, arg_unnamed_arg0: *const c_char, arg_unnamed_arg1: *mut glib::GVariant);

    //=========================================================================
    // PhoshOsk0SmPuriOSK0
    //=========================================================================
    pub fn phosh_osk0_sm_puri_osk0_get_type() -> GType;
    pub fn phosh_osk0_sm_puri_osk0_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_osk0_sm_puri_osk0_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_osk0_sm_puri_osk0_call_set_visible(proxy: *mut PhoshOsk0SmPuriOSK0, arg_visible: gboolean, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_osk0_sm_puri_osk0_call_set_visible_finish(proxy: *mut PhoshOsk0SmPuriOSK0, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_osk0_sm_puri_osk0_call_set_visible_sync(proxy: *mut PhoshOsk0SmPuriOSK0, arg_visible: gboolean, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_osk0_sm_puri_osk0_complete_set_visible(object: *mut PhoshOsk0SmPuriOSK0, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_osk0_sm_puri_osk0_get_visible(object: *mut PhoshOsk0SmPuriOSK0) -> gboolean;
    pub fn phosh_osk0_sm_puri_osk0_set_visible(object: *mut PhoshOsk0SmPuriOSK0, value: gboolean);

    //=========================================================================
    // PhoshRfkillDBusRfkill
    //=========================================================================
    pub fn phosh_rfkill_dbus_rfkill_get_type() -> GType;
    pub fn phosh_rfkill_dbus_rfkill_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_rfkill_dbus_rfkill_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_rfkill_dbus_rfkill_get_airplane_mode(object: *mut PhoshRfkillDBusRfkill) -> gboolean;
    pub fn phosh_rfkill_dbus_rfkill_get_bluetooth_airplane_mode(object: *mut PhoshRfkillDBusRfkill) -> gboolean;
    pub fn phosh_rfkill_dbus_rfkill_get_bluetooth_hardware_airplane_mode(object: *mut PhoshRfkillDBusRfkill) -> gboolean;
    pub fn phosh_rfkill_dbus_rfkill_get_bluetooth_has_airplane_mode(object: *mut PhoshRfkillDBusRfkill) -> gboolean;
    pub fn phosh_rfkill_dbus_rfkill_get_hardware_airplane_mode(object: *mut PhoshRfkillDBusRfkill) -> gboolean;
    pub fn phosh_rfkill_dbus_rfkill_get_should_show_airplane_mode(object: *mut PhoshRfkillDBusRfkill) -> gboolean;
    pub fn phosh_rfkill_dbus_rfkill_set_airplane_mode(object: *mut PhoshRfkillDBusRfkill, value: gboolean);
    pub fn phosh_rfkill_dbus_rfkill_set_bluetooth_airplane_mode(object: *mut PhoshRfkillDBusRfkill, value: gboolean);
    pub fn phosh_rfkill_dbus_rfkill_set_bluetooth_hardware_airplane_mode(object: *mut PhoshRfkillDBusRfkill, value: gboolean);
    pub fn phosh_rfkill_dbus_rfkill_set_bluetooth_has_airplane_mode(object: *mut PhoshRfkillDBusRfkill, value: gboolean);
    pub fn phosh_rfkill_dbus_rfkill_set_hardware_airplane_mode(object: *mut PhoshRfkillDBusRfkill, value: gboolean);
    pub fn phosh_rfkill_dbus_rfkill_set_should_show_airplane_mode(object: *mut PhoshRfkillDBusRfkill, value: gboolean);

    //=========================================================================
    // PhoshSessionClientPrivateDBusClientPrivate
    //=========================================================================
    pub fn phosh_session_client_private_dbus_client_private_get_type() -> GType;
    pub fn phosh_session_client_private_dbus_client_private_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_session_client_private_dbus_client_private_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_session_client_private_dbus_client_private_call_end_session_response(proxy: *mut PhoshSessionClientPrivateDBusClientPrivate, arg_is_ok: gboolean, arg_reason: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn phosh_session_client_private_dbus_client_private_call_end_session_response_finish(proxy: *mut PhoshSessionClientPrivateDBusClientPrivate, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_session_client_private_dbus_client_private_call_end_session_response_sync(proxy: *mut PhoshSessionClientPrivateDBusClientPrivate, arg_is_ok: gboolean, arg_reason: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_session_client_private_dbus_client_private_complete_end_session_response(object: *mut PhoshSessionClientPrivateDBusClientPrivate, invocation: *mut gio::GDBusMethodInvocation);
    pub fn phosh_session_client_private_dbus_client_private_emit_cancel_end_session(object: *mut PhoshSessionClientPrivateDBusClientPrivate);
    pub fn phosh_session_client_private_dbus_client_private_emit_end_session(object: *mut PhoshSessionClientPrivateDBusClientPrivate, arg_flags: c_uint);
    pub fn phosh_session_client_private_dbus_client_private_emit_query_end_session(object: *mut PhoshSessionClientPrivateDBusClientPrivate, arg_flags: c_uint);
    pub fn phosh_session_client_private_dbus_client_private_emit_stop(object: *mut PhoshSessionClientPrivateDBusClientPrivate);

    //=========================================================================
    // PhoshSessionPresenceDBusPresence
    //=========================================================================
    pub fn phosh_session_presence_dbus_presence_get_type() -> GType;
    pub fn phosh_session_presence_dbus_presence_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn phosh_session_presence_dbus_presence_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn phosh_session_presence_dbus_presence_emit_status_changed(object: *mut PhoshSessionPresenceDBusPresence, arg_status: c_uint);
    pub fn phosh_session_presence_dbus_presence_get_status(object: *mut PhoshSessionPresenceDBusPresence) -> c_uint;
    pub fn phosh_session_presence_dbus_presence_set_status(object: *mut PhoshSessionPresenceDBusPresence, value: c_uint);

    //=========================================================================
    // PhoshWWan
    //=========================================================================
    pub fn phosh_wwan_get_type() -> GType;
    pub fn phosh_wwan_get_access_tec(self_: *mut PhoshWWan) -> *const c_char;
    pub fn phosh_wwan_get_operator(self_: *mut PhoshWWan) -> *const c_char;
    pub fn phosh_wwan_get_signal_quality(self_: *mut PhoshWWan) -> c_uint;
    pub fn phosh_wwan_has_sim(self_: *mut PhoshWWan) -> gboolean;
    pub fn phosh_wwan_is_enabled(self_: *mut PhoshWWan) -> gboolean;
    pub fn phosh_wwan_is_present(self_: *mut PhoshWWan) -> gboolean;
    pub fn phosh_wwan_is_unlocked(self_: *mut PhoshWWan) -> gboolean;
    pub fn phosh_wwan_set_data_enabled(self_: *mut PhoshWWan, enabled: gboolean);
    pub fn phosh_wwan_set_enabled(self_: *mut PhoshWWan, enabled: gboolean);

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn phosh_clear_fd(fd: *mut c_int, error: *mut *mut glib::GError) -> gboolean;
    pub fn phosh_connect_feedback(widget: *mut gtk::GtkWidget);
    pub fn phosh_cp_widget_destroy(widget: *mut c_void);
    pub fn phosh_error_warnv(log_domain: *const c_char, err: *mut glib::GError, domain: glib::GQuark, code: c_int, fmt: *const c_char, ...) -> gboolean;
    pub fn phosh_find_base_dir(text: *const c_char, length: c_int) -> pango::PangoDirection;
    pub fn phosh_find_systemd_session(session_id: *mut *mut c_char) -> gboolean;
    pub fn phosh_gamma_table_fill(table: *mut u16, ramp_size: u32, temp: u32);
    pub fn phosh_get_desktop_app_info_for_app_id(app_id: *const c_char) -> *mut gio::GDesktopAppInfo;
    pub fn phosh_get_resource() -> *mut gio::GResource;
    pub fn phosh_log_set_log_domains(domains: *const c_char);
    pub fn phosh_munge_app_id(app_id: *const c_char) -> *mut c_char;
    pub fn phosh_strip_suffix_from_app_id(app_id: *const c_char) -> *mut c_char;
    pub fn phosh_system_prompter_unregister();
    pub fn phosh_trigger_feedback(name: *const c_char);
    pub fn phosh_util_append_to_strv(array: c_char, element: *const c_char) -> c_char;
    pub fn phosh_util_data_uri_to_pixbuf(uri: *const c_char, error: *mut *mut glib::GError) -> *mut gdk_pixbuf::GdkPixbuf;
    pub fn phosh_util_escape_markup(markup: *const c_char, allow_markup: gboolean) -> *mut c_char;
    pub fn phosh_util_file_equal(file1: *mut gio::GFile, file2: *mut gio::GFile) -> gboolean;
    pub fn phosh_util_gesture_is_touch(gesture: *mut gtk::GtkGestureSingle) -> gboolean;
    pub fn phosh_util_get_icon_by_wifi_strength(strength: c_uint, is_connecting: gboolean) -> *const c_char;
    pub fn phosh_util_get_stylesheet(theme_name: *const c_char) -> *const c_char;
    pub fn phosh_util_have_gnome_software(scan: gboolean) -> gboolean;
    pub fn phosh_util_matches_app_info(info: *mut gio::GAppInfo, search: *const c_char) -> gboolean;
    pub fn phosh_util_remove_from_strv(array: c_char, element: *const c_char) -> c_char;
    pub fn phosh_util_toggle_style_class(widget: *mut gtk::GtkWidget, style_class: *const c_char, toggle: gboolean);

}