// Generated by gir (https://github.com/gtk-rs/gir @ 23d7c100187c)
// from
// from gir-files (https://github.com/gtk-rs/gir-files.git @ 6415239ef435)
// 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))]

#[allow(unused_imports)]
use libc::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
    intptr_t, size_t, ssize_t, uintptr_t, FILE,
};

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

// Enums
pub type DzlAnimationMode = c_int;
pub const DZL_ANIMATION_LINEAR: DzlAnimationMode = 0;
pub const DZL_ANIMATION_EASE_IN_QUAD: DzlAnimationMode = 1;
pub const DZL_ANIMATION_EASE_IN_OUT_QUAD: DzlAnimationMode = 3;
pub const DZL_ANIMATION_EASE_OUT_QUAD: DzlAnimationMode = 2;
pub const DZL_ANIMATION_EASE_IN_CUBIC: DzlAnimationMode = 4;
pub const DZL_ANIMATION_EASE_OUT_CUBIC: DzlAnimationMode = 5;
pub const DZL_ANIMATION_EASE_IN_OUT_CUBIC: DzlAnimationMode = 6;

pub type DzlDockRevealerTransitionType = c_int;
pub const DZL_DOCK_REVEALER_TRANSITION_TYPE_NONE: DzlDockRevealerTransitionType = 0;
pub const DZL_DOCK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT: DzlDockRevealerTransitionType = 1;
pub const DZL_DOCK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT: DzlDockRevealerTransitionType = 2;
pub const DZL_DOCK_REVEALER_TRANSITION_TYPE_SLIDE_UP: DzlDockRevealerTransitionType = 3;
pub const DZL_DOCK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN: DzlDockRevealerTransitionType = 4;

pub type DzlShortcutMatch = c_int;
pub const DZL_SHORTCUT_MATCH_NONE: DzlShortcutMatch = 0;
pub const DZL_SHORTCUT_MATCH_EQUAL: DzlShortcutMatch = 1;
pub const DZL_SHORTCUT_MATCH_PARTIAL: DzlShortcutMatch = 2;

pub type DzlShortcutType = c_int;
pub const DZL_SHORTCUT_ACCELERATOR: DzlShortcutType = 0;
pub const DZL_SHORTCUT_GESTURE_PINCH: DzlShortcutType = 1;
pub const DZL_SHORTCUT_GESTURE_STRETCH: DzlShortcutType = 2;
pub const DZL_SHORTCUT_GESTURE_ROTATE_CLOCKWISE: DzlShortcutType = 3;
pub const DZL_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE: DzlShortcutType = 4;
pub const DZL_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT: DzlShortcutType = 5;
pub const DZL_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT: DzlShortcutType = 6;
pub const DZL_SHORTCUT_GESTURE: DzlShortcutType = 7;

pub type DzlSliderPosition = c_int;
pub const DZL_SLIDER_NONE: DzlSliderPosition = 0;
pub const DZL_SLIDER_TOP: DzlSliderPosition = 1;
pub const DZL_SLIDER_RIGHT: DzlSliderPosition = 2;
pub const DZL_SLIDER_BOTTOM: DzlSliderPosition = 3;
pub const DZL_SLIDER_LEFT: DzlSliderPosition = 4;

pub type DzlThreeGridColumn = c_int;
pub const DZL_THREE_GRID_COLUMN_LEFT: DzlThreeGridColumn = 0;
pub const DZL_THREE_GRID_COLUMN_CENTER: DzlThreeGridColumn = 1;
pub const DZL_THREE_GRID_COLUMN_RIGHT: DzlThreeGridColumn = 2;

pub type DzlTitlebarAnimation = c_int;
pub const DZL_TITLEBAR_ANIMATION_HIDDEN: DzlTitlebarAnimation = 0;
pub const DZL_TITLEBAR_ANIMATION_SHOWING: DzlTitlebarAnimation = 1;
pub const DZL_TITLEBAR_ANIMATION_SHOWN: DzlTitlebarAnimation = 2;
pub const DZL_TITLEBAR_ANIMATION_HIDING: DzlTitlebarAnimation = 3;

pub type DzlTreeDropPosition = c_int;
pub const DZL_TREE_DROP_INTO: DzlTreeDropPosition = 0;
pub const DZL_TREE_DROP_BEFORE: DzlTreeDropPosition = 1;
pub const DZL_TREE_DROP_AFTER: DzlTreeDropPosition = 2;

// Constants
pub const DZL_DOCK_BIN_STYLE_CLASS_PINNED: &[u8] = b"pinned\0";

// Flags
pub type DzlFileTransferFlags = c_uint;
pub const DZL_FILE_TRANSFER_FLAGS_NONE: DzlFileTransferFlags = 0;
pub const DZL_FILE_TRANSFER_FLAGS_MOVE: DzlFileTransferFlags = 1;

pub type DzlPropertiesFlags = c_uint;
pub const DZL_PROPERTIES_FLAGS_NONE: DzlPropertiesFlags = 0;
pub const DZL_PROPERTIES_FLAGS_STATEFUL_BOOLEANS: DzlPropertiesFlags = 1;

pub type DzlShortcutPhase = c_uint;
pub const DZL_SHORTCUT_PHASE_DISPATCH: DzlShortcutPhase = 0;
pub const DZL_SHORTCUT_PHASE_CAPTURE: DzlShortcutPhase = 1;
pub const DZL_SHORTCUT_PHASE_BUBBLE: DzlShortcutPhase = 2;
pub const DZL_SHORTCUT_PHASE_GLOBAL: DzlShortcutPhase = 4;

pub type DzlTabStyle = c_uint;
pub const DZL_TAB_ICONS: DzlTabStyle = 2;
pub const DZL_TAB_TEXT: DzlTabStyle = 1;
pub const DZL_TAB_BOTH: DzlTabStyle = 3;

// Callbacks
pub type DzlCounterForeachFunc = Option<unsafe extern "C" fn(*mut DzlCounter, gpointer)>;
pub type DzlDirectoryModelVisibleFunc = Option<
    unsafe extern "C" fn(
        *mut DzlDirectoryModel,
        *mut gio::GFile,
        *mut gio::GFileInfo,
        gpointer,
    ) -> gboolean,
>;
pub type DzlListModelFilterFunc =
    Option<unsafe extern "C" fn(*mut gobject::GObject, gpointer) -> gboolean>;
pub type DzlRecursiveIgnoreFunc =
    Option<unsafe extern "C" fn(*mut gio::GFile, gpointer) -> gboolean>;
pub type DzlShortcutChordTableForeach =
    Option<unsafe extern "C" fn(*const DzlShortcutChord, gpointer, gpointer)>;
pub type DzlStackListCreateWidgetFunc =
    Option<unsafe extern "C" fn(*mut gobject::GObject, gpointer) -> *mut gtk::GtkWidget>;
pub type DzlSuggestionPositionFunc = Option<
    unsafe extern "C" fn(*mut DzlSuggestionEntry, *mut gdk::GdkRectangle, *mut gboolean, gpointer),
>;
pub type DzlTaskCacheCallback =
    Option<unsafe extern "C" fn(*mut DzlTaskCache, gconstpointer, *mut gio::GTask, gpointer)>;
pub type DzlTreeFilterFunc =
    Option<unsafe extern "C" fn(*mut DzlTree, *mut DzlTreeNode, gpointer) -> gboolean>;
pub type DzlTreeFindFunc = Option<
    unsafe extern "C" fn(*mut DzlTree, *mut DzlTreeNode, *mut DzlTreeNode, gpointer) -> gboolean,
>;
pub type DzlTreeNodeCompareFunc =
    Option<unsafe extern "C" fn(*mut DzlTreeNode, *mut DzlTreeNode, gpointer) -> c_int>;
pub type DzlTrieTraverseFunc =
    Option<unsafe extern "C" fn(*mut DzlTrie, *const c_char, gpointer, gpointer) -> gboolean>;

// Records
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlAnimationClass {
    pub parent_class: gobject::GInitiallyUnownedClass,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlApplicationClass {
    pub parent_class: gtk::GtkApplicationClass,
    pub add_resources: Option<unsafe extern "C" fn(*mut DzlApplication, *const c_char)>,
    pub remove_resources: Option<unsafe extern "C" fn(*mut DzlApplication, *const c_char)>,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlApplicationClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlApplicationClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("add_resources", &self.add_resources)
            .field("remove_resources", &self.remove_resources)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlApplicationWindowClass {
    pub parent_class: gtk::GtkApplicationWindowClass,
    pub get_fullscreen: Option<unsafe extern "C" fn(*mut DzlApplicationWindow) -> gboolean>,
    pub set_fullscreen: Option<unsafe extern "C" fn(*mut DzlApplicationWindow, gboolean)>,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlApplicationWindowClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlApplicationWindowClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("get_fullscreen", &self.get_fullscreen)
            .field("set_fullscreen", &self.set_fullscreen)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlColumnLayoutClass {
    pub parent: gtk::GtkContainerClass,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlCounter {
    pub values: *mut DzlCounterValue,
    pub category: *const c_char,
    pub name: *const c_char,
    pub description: *const c_char,
}

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlCounterValue {
    pub value: i64,
    pub padding: [i64; 7],
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlCountersWindowClass {
    pub parent_class: gtk::GtkWindowClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
}

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

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

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

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

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

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockBinClass {
    pub parent: gtk::GtkContainerClass,
    pub create_edge:
        Option<unsafe extern "C" fn(*mut DzlDockBin, gtk::GtkPositionType) -> *mut gtk::GtkWidget>,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlDockBinClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlDockBinClass @ {self:p}"))
            .field("parent", &self.parent)
            .field("create_edge", &self.create_edge)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockBinEdgeClass {
    pub parent: DzlDockRevealerClass,
    pub move_to_bin_child: Option<unsafe extern "C" fn(*mut DzlDockBinEdge)>,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlDockBinEdgeClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlDockBinEdgeClass @ {self:p}"))
            .field("parent", &self.parent)
            .field("move_to_bin_child", &self.move_to_bin_child)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockItemInterface {
    pub parent: gobject::GTypeInterface,
    pub set_manager: Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockManager)>,
    pub get_manager: Option<unsafe extern "C" fn(*mut DzlDockItem) -> *mut DzlDockManager>,
    pub manager_set: Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockManager)>,
    pub present_child: Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockItem)>,
    pub update_visibility: Option<unsafe extern "C" fn(*mut DzlDockItem)>,
    pub get_child_visible:
        Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockItem) -> gboolean>,
    pub set_child_visible:
        Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockItem, gboolean)>,
    pub get_title: Option<unsafe extern "C" fn(*mut DzlDockItem) -> *mut c_char>,
    pub get_icon_name: Option<unsafe extern "C" fn(*mut DzlDockItem) -> *mut c_char>,
    pub get_can_close: Option<unsafe extern "C" fn(*mut DzlDockItem) -> gboolean>,
    pub can_minimize: Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockItem) -> gboolean>,
    pub close: Option<unsafe extern "C" fn(*mut DzlDockItem) -> gboolean>,
    pub minimize: Option<
        unsafe extern "C" fn(
            *mut DzlDockItem,
            *mut DzlDockItem,
            *mut gtk::GtkPositionType,
        ) -> gboolean,
    >,
    pub release: Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockItem)>,
    pub presented: Option<unsafe extern "C" fn(*mut DzlDockItem)>,
    pub ref_gicon: Option<unsafe extern "C" fn(*mut DzlDockItem) -> *mut gio::GIcon>,
    pub needs_attention: Option<unsafe extern "C" fn(*mut DzlDockItem)>,
}

impl ::std::fmt::Debug for DzlDockItemInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlDockItemInterface @ {self:p}"))
            .field("parent", &self.parent)
            .field("set_manager", &self.set_manager)
            .field("get_manager", &self.get_manager)
            .field("manager_set", &self.manager_set)
            .field("present_child", &self.present_child)
            .field("update_visibility", &self.update_visibility)
            .field("get_child_visible", &self.get_child_visible)
            .field("set_child_visible", &self.set_child_visible)
            .field("get_title", &self.get_title)
            .field("get_icon_name", &self.get_icon_name)
            .field("get_can_close", &self.get_can_close)
            .field("can_minimize", &self.can_minimize)
            .field("close", &self.close)
            .field("minimize", &self.minimize)
            .field("release", &self.release)
            .field("presented", &self.presented)
            .field("ref_gicon", &self.ref_gicon)
            .field("needs_attention", &self.needs_attention)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockManagerClass {
    pub parent: gobject::GObjectClass,
    pub register_dock: Option<unsafe extern "C" fn(*mut DzlDockManager, *mut DzlDock)>,
    pub unregister_dock: Option<unsafe extern "C" fn(*mut DzlDockManager, *mut DzlDock)>,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlDockManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlDockManagerClass @ {self:p}"))
            .field("parent", &self.parent)
            .field("register_dock", &self.register_dock)
            .field("unregister_dock", &self.unregister_dock)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockOverlayClass {
    pub parent: gtk::GtkEventBoxClass,
    pub hide_edges: Option<unsafe extern "C" fn(*mut DzlDockOverlay)>,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlDockOverlayClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlDockOverlayClass @ {self:p}"))
            .field("parent", &self.parent)
            .field("hide_edges", &self.hide_edges)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockPanedClass {
    pub parent: DzlMultiPanedClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlDockPanedClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlDockPanedClass @ {self:p}"))
            .field("parent", &self.parent)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockRevealerClass {
    pub parent: DzlBinClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlDockRevealerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlDockRevealerClass @ {self:p}"))
            .field("parent", &self.parent)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockStackClass {
    pub parent: gtk::GtkBoxClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
}

impl ::std::fmt::Debug for DzlDockStackClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlDockStackClass @ {self:p}"))
            .field("parent", &self.parent)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .finish()
    }
}

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockWidgetClass {
    pub parent: DzlBinClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlDockWidgetClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlDockWidgetClass @ {self:p}"))
            .field("parent", &self.parent)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockWindowClass {
    pub parent: gtk::GtkWindowClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlDockWindowClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlDockWindowClass @ {self:p}"))
            .field("parent", &self.parent)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlElasticBinClass {
    pub parent_class: gtk::GtkBinClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
}

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFileChooserEntryClass {
    pub parent_class: gtk::GtkBinClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFileTransferClass {
    pub parent_class: gobject::GObjectClass,
    pub _padding: [gpointer; 12],
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFileTransferStat {
    pub n_files_total: i64,
    pub n_files: i64,
    pub n_dirs_total: i64,
    pub n_dirs: i64,
    pub n_bytes_total: i64,
    pub n_bytes: i64,
    pub _padding: [i64; 10],
}

impl ::std::fmt::Debug for DzlFileTransferStat {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlFileTransferStat @ {self:p}"))
            .field("n_files_total", &self.n_files_total)
            .field("n_files", &self.n_files)
            .field("n_dirs_total", &self.n_dirs_total)
            .field("n_dirs", &self.n_dirs)
            .field("n_bytes_total", &self.n_bytes_total)
            .field("n_bytes", &self.n_bytes)
            .finish()
    }
}

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

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

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

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

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFuzzyMutableIndexMatch {
    pub key: *const c_char,
    pub value: gpointer,
    pub score: c_float,
    pub id: c_uint,
}

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

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlGraphModelIter {
    pub data: [gpointer; 8],
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlGraphRendererInterface {
    pub parent: gobject::GTypeInterface,
    pub render: Option<
        unsafe extern "C" fn(
            *mut DzlGraphRenderer,
            *mut DzlGraphModel,
            i64,
            i64,
            c_double,
            c_double,
            *mut cairo::cairo_t,
            *const cairo::cairo_rectangle_int_t,
        ),
    >,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlGraphViewClass {
    pub parent_class: gtk::GtkDrawingAreaClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlGraphViewClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlGraphViewClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlHeap {
    pub data: *mut c_char,
    pub len: size_t,
}

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlListBoxClass {
    pub parent_class: gtk::GtkListBoxClass,
    pub _reserved: [gpointer; 4],
}

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

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlMenuButtonClass {
    pub parent_class: gtk::GtkMenuButtonClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
}

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlMultiPanedClass {
    pub parent: gtk::GtkContainerClass,
    pub resize_drag_begin: Option<unsafe extern "C" fn(*mut DzlMultiPaned, *mut gtk::GtkWidget)>,
    pub resize_drag_end: Option<unsafe extern "C" fn(*mut DzlMultiPaned, *mut gtk::GtkWidget)>,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlMultiPanedClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlMultiPanedClass @ {self:p}"))
            .field("parent", &self.parent)
            .field("resize_drag_begin", &self.resize_drag_begin)
            .field("resize_drag_end", &self.resize_drag_end)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

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

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

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

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

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesBinClass {
    pub parent_class: gtk::GtkBinClass,
    pub connect: Option<unsafe extern "C" fn(*mut DzlPreferencesBin, *mut gio::GSettings)>,
    pub disconnect: Option<unsafe extern "C" fn(*mut DzlPreferencesBin, *mut gio::GSettings)>,
    pub matches:
        Option<unsafe extern "C" fn(*mut DzlPreferencesBin, *mut DzlPatternSpec) -> gboolean>,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlPreferencesBinClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlPreferencesBinClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("connect", &self.connect)
            .field("disconnect", &self.disconnect)
            .field("matches", &self.matches)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

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

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

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

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

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

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

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

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

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

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

#[repr(C)]
pub struct DzlPreferencesInterface {
    pub parent_interface: gobject::GTypeInterface,
    pub set_page:
        Option<unsafe extern "C" fn(*mut DzlPreferences, *const c_char, *mut glib::GHashTable)>,
    pub add_page:
        Option<unsafe extern "C" fn(*mut DzlPreferences, *const c_char, *const c_char, c_int)>,
    pub add_group: Option<
        unsafe extern "C" fn(
            *mut DzlPreferences,
            *const c_char,
            *const c_char,
            *const c_char,
            c_int,
        ),
    >,
    pub add_list_group: Option<
        unsafe extern "C" fn(
            *mut DzlPreferences,
            *const c_char,
            *const c_char,
            *const c_char,
            gtk::GtkSelectionMode,
            c_int,
        ),
    >,
    pub add_radio: Option<
        unsafe extern "C" fn(
            *mut DzlPreferences,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            c_int,
        ) -> c_uint,
    >,
    pub add_font_button: Option<
        unsafe extern "C" fn(
            *mut DzlPreferences,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            c_int,
        ) -> c_uint,
    >,
    pub add_switch: Option<
        unsafe extern "C" fn(
            *mut DzlPreferences,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            c_int,
        ) -> c_uint,
    >,
    pub add_spin_button: Option<
        unsafe extern "C" fn(
            *mut DzlPreferences,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            c_int,
        ) -> c_uint,
    >,
    pub add_file_chooser: Option<
        unsafe extern "C" fn(
            *mut DzlPreferences,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            *const c_char,
            gtk::GtkFileChooserAction,
            *const c_char,
            c_int,
        ) -> c_uint,
    >,
    pub add_custom: Option<
        unsafe extern "C" fn(
            *mut DzlPreferences,
            *const c_char,
            *const c_char,
            *mut gtk::GtkWidget,
            *const c_char,
            c_int,
        ) -> c_uint,
    >,
    pub remove_id: Option<unsafe extern "C" fn(*mut DzlPreferences, c_uint) -> gboolean>,
    pub get_widget:
        Option<unsafe extern "C" fn(*mut DzlPreferences, c_uint) -> *mut gtk::GtkWidget>,
    _truncated_record_marker: c_void,
    // /*Ignored*/field add_table_row_va has incomplete type
}

impl ::std::fmt::Debug for DzlPreferencesInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlPreferencesInterface @ {self:p}"))
            .field("parent_interface", &self.parent_interface)
            .field("set_page", &self.set_page)
            .field("add_page", &self.add_page)
            .field("add_group", &self.add_group)
            .field("add_list_group", &self.add_list_group)
            .field("add_radio", &self.add_radio)
            .field("add_font_button", &self.add_font_button)
            .field("add_switch", &self.add_switch)
            .field("add_spin_button", &self.add_spin_button)
            .field("add_file_chooser", &self.add_file_chooser)
            .field("add_custom", &self.add_custom)
            .field("remove_id", &self.remove_id)
            .field("get_widget", &self.get_widget)
            .finish()
    }
}

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesViewClass {
    pub parent_class: gtk::GtkBinClass,
    pub _reserved: [gpointer; 8],
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPriorityBoxClass {
    pub parent_class: gtk::GtkBoxClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlProgressButtonClass {
    pub parent_class: gtk::GtkButtonClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
}

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlProgressMenuButtonClass {
    pub parent_class: gtk::GtkMenuButtonClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
}

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlRadioBoxClass {
    pub parent_class: gtk::GtkBinClass,
    pub _padding1: gpointer,
    pub _padding2: gpointer,
    pub _padding3: gpointer,
    pub _padding4: gpointer,
}

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlRing {
    pub data: *mut u8,
    pub len: c_uint,
    pub pos: c_uint,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub type DzlShortcutChordTable = *mut _DzlShortcutChordTable;

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutEntry {
    pub command: *const c_char,
    pub phase: DzlShortcutPhase,
    pub default_accel: *const c_char,
    pub section: *const c_char,
    pub group: *const c_char,
    pub title: *const c_char,
    pub subtitle: *const c_char,
}

impl ::std::fmt::Debug for DzlShortcutEntry {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlShortcutEntry @ {self:p}"))
            .field("command", &self.command)
            .field("phase", &self.phase)
            .field("default_accel", &self.default_accel)
            .field("section", &self.section)
            .field("group", &self.group)
            .field("title", &self.title)
            .field("subtitle", &self.subtitle)
            .finish()
    }
}

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutManagerClass {
    pub parent_instance: gobject::GObjectClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlShortcutManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlShortcutManagerClass @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutThemeClass {
    pub parent_class: gobject::GObjectClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlShortcutThemeClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlShortcutThemeClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutThemeEditorClass {
    pub parent_class: gtk::GtkBinClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlShortcutThemeEditorClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlShortcutThemeEditorClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

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

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

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

pub type DzlShortcutsGroupClass = *mut _DzlShortcutsGroupClass;

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

pub type DzlShortcutsSectionClass = *mut _DzlShortcutsSectionClass;

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

pub type DzlShortcutsShortcutClass = *mut _DzlShortcutsShortcutClass;

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSimplePopoverClass {
    pub parent: gtk::GtkPopoverClass,
    pub activate: Option<unsafe extern "C" fn(*mut DzlSimplePopover, *const c_char)>,
    pub insert_text: Option<
        unsafe extern "C" fn(*mut DzlSimplePopover, c_uint, *const c_char, c_uint) -> gboolean,
    >,
    pub changed: Option<unsafe extern "C" fn(*mut DzlSimplePopover)>,
}

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlStackListClass {
    pub parent_instance: gtk::GtkBinClass,
    pub row_activated: Option<unsafe extern "C" fn(*mut DzlStackList, *mut gtk::GtkListBoxRow)>,
    pub header_activated: Option<unsafe extern "C" fn(*mut DzlStackList, *mut gtk::GtkListBoxRow)>,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlStackListClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlStackListClass @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .field("row_activated", &self.row_activated)
            .field("header_activated", &self.header_activated)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionButtonClass {
    pub parent_class: gtk::GtkStackClass,
    pub _reserved: [gpointer; 8],
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionClass {
    pub parent_class: gobject::GObjectClass,
    pub suggest_suffix:
        Option<unsafe extern "C" fn(*mut DzlSuggestion, *const c_char) -> *mut c_char>,
    pub replace_typed_text:
        Option<unsafe extern "C" fn(*mut DzlSuggestion, *const c_char) -> *mut c_char>,
    pub get_icon: Option<unsafe extern "C" fn(*mut DzlSuggestion) -> *mut gio::GIcon>,
    pub get_icon_surface: Option<
        unsafe extern "C" fn(
            *mut DzlSuggestion,
            *mut gtk::GtkWidget,
        ) -> *mut cairo::cairo_surface_t,
    >,
    pub get_secondary_icon: Option<unsafe extern "C" fn(*mut DzlSuggestion) -> *mut gio::GIcon>,
    pub get_secondary_icon_surface: Option<
        unsafe extern "C" fn(
            *mut DzlSuggestion,
            *mut gtk::GtkWidget,
        ) -> *mut cairo::cairo_surface_t,
    >,
}

impl ::std::fmt::Debug for DzlSuggestionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlSuggestionClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("suggest_suffix", &self.suggest_suffix)
            .field("replace_typed_text", &self.replace_typed_text)
            .field("get_icon", &self.get_icon)
            .field("get_icon_surface", &self.get_icon_surface)
            .field("get_secondary_icon", &self.get_secondary_icon)
            .field(
                "get_secondary_icon_surface",
                &self.get_secondary_icon_surface,
            )
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionEntryBufferClass {
    pub parent_class: gtk::GtkEntryBufferClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionEntryClass {
    pub parent_class: gtk::GtkEntryClass,
    pub hide_suggestions: Option<unsafe extern "C" fn(*mut DzlSuggestionEntry)>,
    pub show_suggestions: Option<unsafe extern "C" fn(*mut DzlSuggestionEntry)>,
    pub move_suggestion: Option<unsafe extern "C" fn(*mut DzlSuggestionEntry, c_int)>,
    pub suggestion_activated:
        Option<unsafe extern "C" fn(*mut DzlSuggestionEntry, *mut DzlSuggestion)>,
    pub suggestion_selected:
        Option<unsafe extern "C" fn(*mut DzlSuggestionEntry, *mut DzlSuggestion)>,
    pub _reserved: [gpointer; 7],
}

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionRowClass {
    pub parent_class: DzlListBoxRowClass,
    pub _reserved: [gpointer; 4],
}

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlTabStripClass {
    pub parent: gtk::GtkBoxClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlTabStripClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlTabStripClass @ {self:p}"))
            .field("parent", &self.parent)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlThreeGridClass {
    pub parent_class: gtk::GtkContainerClass,
    pub _reserved1: gpointer,
    pub _reserved2: gpointer,
    pub _reserved3: gpointer,
    pub _reserved4: gpointer,
    pub _reserved5: gpointer,
    pub _reserved6: gpointer,
    pub _reserved7: gpointer,
    pub _reserved8: gpointer,
}

impl ::std::fmt::Debug for DzlThreeGridClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlThreeGridClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_reserved1", &self._reserved1)
            .field("_reserved2", &self._reserved2)
            .field("_reserved3", &self._reserved3)
            .field("_reserved4", &self._reserved4)
            .field("_reserved5", &self._reserved5)
            .field("_reserved6", &self._reserved6)
            .field("_reserved7", &self._reserved7)
            .field("_reserved8", &self._reserved8)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlTreeBuilderClass {
    pub parent_class: gobject::GInitiallyUnownedClass,
    pub added: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut gtk::GtkWidget)>,
    pub removed: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut gtk::GtkWidget)>,
    pub build_node: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode)>,
    pub build_children: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode)>,
    pub node_activated:
        Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode) -> gboolean>,
    pub node_selected: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode)>,
    pub node_unselected: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode)>,
    pub node_popup:
        Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode, *mut gio::GMenu)>,
    pub node_expanded: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode)>,
    pub node_collapsed: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode)>,
    pub node_draggable:
        Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode) -> gboolean>,
    pub node_droppable: Option<
        unsafe extern "C" fn(
            *mut DzlTreeBuilder,
            *mut DzlTreeNode,
            *mut gtk::GtkSelectionData,
        ) -> gboolean,
    >,
    pub drag_data_get: Option<
        unsafe extern "C" fn(
            *mut DzlTreeBuilder,
            *mut DzlTreeNode,
            *mut gtk::GtkSelectionData,
        ) -> gboolean,
    >,
    pub drag_node_received: Option<
        unsafe extern "C" fn(
            *mut DzlTreeBuilder,
            *mut DzlTreeNode,
            *mut DzlTreeNode,
            DzlTreeDropPosition,
            gdk::GdkDragAction,
            *mut gtk::GtkSelectionData,
        ) -> gboolean,
    >,
    pub drag_data_received: Option<
        unsafe extern "C" fn(
            *mut DzlTreeBuilder,
            *mut DzlTreeNode,
            DzlTreeDropPosition,
            gdk::GdkDragAction,
            *mut gtk::GtkSelectionData,
        ) -> gboolean,
    >,
    pub drag_node_delete:
        Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode) -> gboolean>,
    pub cell_data_func: Option<
        unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode, *mut gtk::GtkCellRenderer),
    >,
    pub _padding: [gpointer; 11],
}

impl ::std::fmt::Debug for DzlTreeBuilderClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("DzlTreeBuilderClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("added", &self.added)
            .field("removed", &self.removed)
            .field("build_node", &self.build_node)
            .field("build_children", &self.build_children)
            .field("node_activated", &self.node_activated)
            .field("node_selected", &self.node_selected)
            .field("node_unselected", &self.node_unselected)
            .field("node_popup", &self.node_popup)
            .field("node_expanded", &self.node_expanded)
            .field("node_collapsed", &self.node_collapsed)
            .field("node_draggable", &self.node_draggable)
            .field("node_droppable", &self.node_droppable)
            .field("drag_data_get", &self.drag_data_get)
            .field("drag_node_received", &self.drag_node_received)
            .field("drag_data_received", &self.drag_data_received)
            .field("drag_node_delete", &self.drag_node_delete)
            .field("cell_data_func", &self.cell_data_func)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlTreeClass {
    pub parent_class: gtk::GtkTreeViewClass,
    pub action:
        Option<unsafe extern "C" fn(*mut DzlTree, *const c_char, *const c_char, *const c_char)>,
    pub populate_popup: Option<unsafe extern "C" fn(*mut DzlTree, *mut gtk::GtkWidget)>,
    pub _padding: [gpointer; 12],
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[link(name = "dazzle-1.0")]
extern "C" {

    //=========================================================================
    // DzlAnimationMode
    //=========================================================================
    pub fn dzl_animation_mode_get_type() -> GType;

    //=========================================================================
    // DzlDockRevealerTransitionType
    //=========================================================================
    pub fn dzl_dock_revealer_transition_type_get_type() -> GType;

    //=========================================================================
    // DzlShortcutMatch
    //=========================================================================
    pub fn dzl_shortcut_match_get_type() -> GType;

    //=========================================================================
    // DzlSliderPosition
    //=========================================================================
    pub fn dzl_slider_position_get_type() -> GType;

    //=========================================================================
    // DzlThreeGridColumn
    //=========================================================================
    pub fn dzl_three_grid_column_get_type() -> GType;

    //=========================================================================
    // DzlTitlebarAnimation
    //=========================================================================
    pub fn dzl_titlebar_animation_get_type() -> GType;

    //=========================================================================
    // DzlTreeDropPosition
    //=========================================================================
    pub fn dzl_tree_drop_position_get_type() -> GType;

    //=========================================================================
    // DzlFileTransferFlags
    //=========================================================================
    pub fn dzl_file_transfer_flags_get_type() -> GType;

    //=========================================================================
    // DzlShortcutPhase
    //=========================================================================
    pub fn dzl_shortcut_phase_get_type() -> GType;

    //=========================================================================
    // DzlTabStyle
    //=========================================================================
    pub fn dzl_tab_style_get_type() -> GType;

    //=========================================================================
    // DzlCounter
    //=========================================================================
    pub fn dzl_counter_get(counter: *mut DzlCounter) -> i64;
    pub fn dzl_counter_reset(counter: *mut DzlCounter);

    //=========================================================================
    // DzlCounterArena
    //=========================================================================
    pub fn dzl_counter_arena_get_type() -> GType;
    pub fn dzl_counter_arena_new_for_pid(pid: glib::GPid) -> *mut DzlCounterArena;
    pub fn dzl_counter_arena_foreach(
        arena: *mut DzlCounterArena,
        func: DzlCounterForeachFunc,
        user_data: gpointer,
    );
    pub fn dzl_counter_arena_ref(arena: *mut DzlCounterArena) -> *mut DzlCounterArena;
    pub fn dzl_counter_arena_register(arena: *mut DzlCounterArena, counter: *mut DzlCounter);
    pub fn dzl_counter_arena_unref(arena: *mut DzlCounterArena);
    pub fn dzl_counter_arena_get_default() -> *mut DzlCounterArena;

    //=========================================================================
    // DzlFuzzyMutableIndex
    //=========================================================================
    pub fn dzl_fuzzy_mutable_index_get_type() -> GType;
    pub fn dzl_fuzzy_mutable_index_new(case_sensitive: gboolean) -> *mut DzlFuzzyMutableIndex;
    pub fn dzl_fuzzy_mutable_index_new_with_free_func(
        case_sensitive: gboolean,
        free_func: glib::GDestroyNotify,
    ) -> *mut DzlFuzzyMutableIndex;
    pub fn dzl_fuzzy_mutable_index_begin_bulk_insert(fuzzy: *mut DzlFuzzyMutableIndex);
    pub fn dzl_fuzzy_mutable_index_contains(
        fuzzy: *mut DzlFuzzyMutableIndex,
        key: *const c_char,
    ) -> gboolean;
    pub fn dzl_fuzzy_mutable_index_end_bulk_insert(fuzzy: *mut DzlFuzzyMutableIndex);
    pub fn dzl_fuzzy_mutable_index_insert(
        fuzzy: *mut DzlFuzzyMutableIndex,
        key: *const c_char,
        value: gpointer,
    );
    pub fn dzl_fuzzy_mutable_index_match(
        fuzzy: *mut DzlFuzzyMutableIndex,
        needle: *const c_char,
        max_matches: size_t,
    ) -> *mut glib::GArray;
    pub fn dzl_fuzzy_mutable_index_ref(
        fuzzy: *mut DzlFuzzyMutableIndex,
    ) -> *mut DzlFuzzyMutableIndex;
    pub fn dzl_fuzzy_mutable_index_remove(fuzzy: *mut DzlFuzzyMutableIndex, key: *const c_char);
    pub fn dzl_fuzzy_mutable_index_set_free_func(
        fuzzy: *mut DzlFuzzyMutableIndex,
        free_func: glib::GDestroyNotify,
    );
    pub fn dzl_fuzzy_mutable_index_unref(fuzzy: *mut DzlFuzzyMutableIndex);

    //=========================================================================
    // DzlHeap
    //=========================================================================
    pub fn dzl_heap_get_type() -> GType;
    pub fn dzl_heap_new(element_size: c_uint, compare_func: glib::GCompareFunc) -> *mut DzlHeap;
    pub fn dzl_heap_extract(heap: *mut DzlHeap, result: gpointer) -> gboolean;
    pub fn dzl_heap_extract_index(heap: *mut DzlHeap, index_: size_t, result: gpointer)
        -> gboolean;
    pub fn dzl_heap_insert_vals(heap: *mut DzlHeap, data: gconstpointer, len: c_uint);
    pub fn dzl_heap_ref(heap: *mut DzlHeap) -> *mut DzlHeap;
    pub fn dzl_heap_unref(heap: *mut DzlHeap);

    //=========================================================================
    // DzlPatternSpec
    //=========================================================================
    pub fn dzl_pattern_spec_get_type() -> GType;
    pub fn dzl_pattern_spec_new(keywords: *const c_char) -> *mut DzlPatternSpec;
    pub fn dzl_pattern_spec_get_text(self_: *mut DzlPatternSpec) -> *const c_char;
    pub fn dzl_pattern_spec_match(self_: *mut DzlPatternSpec, haystack: *const c_char) -> gboolean;
    pub fn dzl_pattern_spec_ref(self_: *mut DzlPatternSpec) -> *mut DzlPatternSpec;
    pub fn dzl_pattern_spec_unref(self_: *mut DzlPatternSpec);

    //=========================================================================
    // DzlRing
    //=========================================================================
    pub fn dzl_ring_get_type() -> GType;
    pub fn dzl_ring_sized_new(
        element_size: c_uint,
        reserved_size: c_uint,
        element_destroy: glib::GDestroyNotify,
    ) -> *mut DzlRing;
    pub fn dzl_ring_append_vals(ring: *mut DzlRing, data: gconstpointer, len: c_uint) -> c_uint;
    pub fn dzl_ring_foreach(ring: *mut DzlRing, func: glib::GFunc, user_data: gpointer);
    pub fn dzl_ring_ref(ring: *mut DzlRing) -> *mut DzlRing;
    pub fn dzl_ring_unref(ring: *mut DzlRing);

    //=========================================================================
    // DzlShortcutChord
    //=========================================================================
    pub fn dzl_shortcut_chord_get_type() -> GType;
    pub fn dzl_shortcut_chord_new_from_event(
        event: *const gdk::GdkEventKey,
    ) -> *mut DzlShortcutChord;
    pub fn dzl_shortcut_chord_new_from_string(accelerator: *const c_char) -> *mut DzlShortcutChord;
    pub fn dzl_shortcut_chord_append_event(
        self_: *mut DzlShortcutChord,
        event: *const gdk::GdkEventKey,
    ) -> gboolean;
    pub fn dzl_shortcut_chord_copy(self_: *const DzlShortcutChord) -> *mut DzlShortcutChord;
    pub fn dzl_shortcut_chord_free(self_: *mut DzlShortcutChord);
    pub fn dzl_shortcut_chord_get_label(self_: *const DzlShortcutChord) -> *mut c_char;
    pub fn dzl_shortcut_chord_get_length(self_: *const DzlShortcutChord) -> c_uint;
    pub fn dzl_shortcut_chord_get_nth_key(
        self_: *const DzlShortcutChord,
        nth: c_uint,
        keyval: *mut c_uint,
        modifier: *mut gdk::GdkModifierType,
    );
    pub fn dzl_shortcut_chord_has_modifier(self_: *const DzlShortcutChord) -> gboolean;
    pub fn dzl_shortcut_chord_match(
        self_: *const DzlShortcutChord,
        other: *const DzlShortcutChord,
    ) -> DzlShortcutMatch;
    pub fn dzl_shortcut_chord_to_string(self_: *const DzlShortcutChord) -> *mut c_char;
    pub fn dzl_shortcut_chord_equal(data1: gconstpointer, data2: gconstpointer) -> gboolean;
    pub fn dzl_shortcut_chord_hash(data: gconstpointer) -> c_uint;

    //=========================================================================
    // DzlShortcutChordTable
    //=========================================================================
    pub fn dzl_shortcut_chord_table_add(
        self_: *mut DzlShortcutChordTable,
        chord: *const DzlShortcutChord,
        data: gpointer,
    );
    pub fn dzl_shortcut_chord_table_foreach(
        self_: *const DzlShortcutChordTable,
        foreach_func: DzlShortcutChordTableForeach,
        foreach_data: gpointer,
    );
    pub fn dzl_shortcut_chord_table_free(self_: *mut DzlShortcutChordTable);
    pub fn dzl_shortcut_chord_table_lookup(
        self_: *mut DzlShortcutChordTable,
        chord: *const DzlShortcutChord,
        data: *mut gpointer,
    ) -> DzlShortcutMatch;
    pub fn dzl_shortcut_chord_table_lookup_data(
        self_: *mut DzlShortcutChordTable,
        data: gpointer,
    ) -> *const DzlShortcutChord;
    pub fn dzl_shortcut_chord_table_printf(self_: *const DzlShortcutChordTable);
    pub fn dzl_shortcut_chord_table_remove(
        self_: *mut DzlShortcutChordTable,
        chord: *const DzlShortcutChord,
    ) -> gboolean;
    pub fn dzl_shortcut_chord_table_remove_data(
        self_: *mut DzlShortcutChordTable,
        data: gpointer,
    ) -> gboolean;
    pub fn dzl_shortcut_chord_table_set_free_func(
        self_: *mut DzlShortcutChordTable,
        notify: glib::GDestroyNotify,
    );
    pub fn dzl_shortcut_chord_table_size(self_: *const DzlShortcutChordTable) -> c_uint;
    pub fn dzl_shortcut_chord_table_new() -> *mut DzlShortcutChordTable;

    //=========================================================================
    // DzlTrie
    //=========================================================================
    pub fn dzl_trie_get_type() -> GType;
    pub fn dzl_trie_new(value_destroy: glib::GDestroyNotify) -> *mut DzlTrie;
    pub fn dzl_trie_destroy(trie: *mut DzlTrie);
    pub fn dzl_trie_insert(trie: *mut DzlTrie, key: *const c_char, value: gpointer);
    pub fn dzl_trie_lookup(trie: *mut DzlTrie, key: *const c_char) -> gpointer;
    pub fn dzl_trie_ref(trie: *mut DzlTrie) -> *mut DzlTrie;
    pub fn dzl_trie_remove(trie: *mut DzlTrie, key: *const c_char) -> gboolean;
    pub fn dzl_trie_traverse(
        trie: *mut DzlTrie,
        key: *const c_char,
        order: glib::GTraverseType,
        flags: glib::GTraverseFlags,
        max_depth: c_int,
        func: DzlTrieTraverseFunc,
        user_data: gpointer,
    );
    pub fn dzl_trie_unref(trie: *mut DzlTrie);

    //=========================================================================
    // DzlAnimation
    //=========================================================================
    pub fn dzl_animation_get_type() -> GType;
    pub fn dzl_animation_calculate_duration(
        monitor: *mut gdk::GdkMonitor,
        from_value: c_double,
        to_value: c_double,
    ) -> c_uint;
    pub fn dzl_animation_add_property(
        animation: *mut DzlAnimation,
        pspec: *mut gobject::GParamSpec,
        value: *const gobject::GValue,
    );
    pub fn dzl_animation_start(animation: *mut DzlAnimation);
    pub fn dzl_animation_stop(animation: *mut DzlAnimation);

    //=========================================================================
    // DzlApplication
    //=========================================================================
    pub fn dzl_application_get_type() -> GType;
    pub fn dzl_application_new(
        application_id: *const c_char,
        flags: gio::GApplicationFlags,
    ) -> *mut DzlApplication;
    pub fn dzl_application_add_resources(self_: *mut DzlApplication, resource_path: *const c_char);
    pub fn dzl_application_get_menu_by_id(
        self_: *mut DzlApplication,
        menu_id: *const c_char,
    ) -> *mut gio::GMenu;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_application_get_menu_manager(self_: *mut DzlApplication) -> *mut DzlMenuManager;
    pub fn dzl_application_get_shortcut_manager(
        self_: *mut DzlApplication,
    ) -> *mut DzlShortcutManager;
    pub fn dzl_application_get_theme_manager(self_: *mut DzlApplication) -> *mut DzlThemeManager;
    pub fn dzl_application_remove_resources(
        self_: *mut DzlApplication,
        resource_path: *const c_char,
    );

    //=========================================================================
    // DzlApplicationWindow
    //=========================================================================
    pub fn dzl_application_window_get_type() -> GType;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_application_window_get_fullscreen(self_: *mut DzlApplicationWindow) -> gboolean;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_application_window_get_titlebar(
        self_: *mut DzlApplicationWindow,
    ) -> *mut gtk::GtkWidget;
    pub fn dzl_application_window_get_titlebar_animation(
        self_: *mut DzlApplicationWindow,
    ) -> DzlTitlebarAnimation;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_application_window_set_fullscreen(
        self_: *mut DzlApplicationWindow,
        fullscreen: gboolean,
    );
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_application_window_set_titlebar(
        self_: *mut DzlApplicationWindow,
        titlebar: *mut gtk::GtkWidget,
    );

    //=========================================================================
    // DzlBin
    //=========================================================================
    pub fn dzl_bin_get_type() -> GType;
    pub fn dzl_bin_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlBindingGroup
    //=========================================================================
    pub fn dzl_binding_group_get_type() -> GType;
    pub fn dzl_binding_group_new() -> *mut DzlBindingGroup;
    pub fn dzl_binding_group_bind(
        self_: *mut DzlBindingGroup,
        source_property: *const c_char,
        target: *mut gobject::GObject,
        target_property: *const c_char,
        flags: gobject::GBindingFlags,
    );
    pub fn dzl_binding_group_bind_full(
        self_: *mut DzlBindingGroup,
        source_property: *const c_char,
        target: *mut gobject::GObject,
        target_property: *const c_char,
        flags: gobject::GBindingFlags,
        transform_to: gobject::GBindingTransformFunc,
        transform_from: gobject::GBindingTransformFunc,
        user_data: gpointer,
        user_data_destroy: glib::GDestroyNotify,
    );
    pub fn dzl_binding_group_bind_with_closures(
        self_: *mut DzlBindingGroup,
        source_property: *const c_char,
        target: *mut gobject::GObject,
        target_property: *const c_char,
        flags: gobject::GBindingFlags,
        transform_to: *mut gobject::GClosure,
        transform_from: *mut gobject::GClosure,
    );
    pub fn dzl_binding_group_get_source(self_: *mut DzlBindingGroup) -> *mut gobject::GObject;
    pub fn dzl_binding_group_set_source(self_: *mut DzlBindingGroup, source: *mut gobject::GObject);

    //=========================================================================
    // DzlBoldingLabel
    //=========================================================================
    pub fn dzl_bolding_label_get_type() -> GType;
    pub fn dzl_bolding_label_new(str: *const c_char, bold: gboolean) -> *mut DzlBoldingLabel;
    pub fn dzl_bolding_label_new_with_mnemonic(
        str: *const c_char,
        bold: gboolean,
    ) -> *mut DzlBoldingLabel;
    pub fn dzl_bolding_label_set_bold(self_: *mut DzlBoldingLabel, bold: gboolean);
    pub fn dzl_bolding_label_set_weight(self_: *mut DzlBoldingLabel, weight: pango::PangoWeight);

    //=========================================================================
    // DzlBox
    //=========================================================================
    pub fn dzl_box_get_type() -> GType;
    pub fn dzl_box_new() -> *mut gtk::GtkWidget;
    pub fn dzl_box_get_max_width_request(self_: *mut DzlBox) -> c_int;
    pub fn dzl_box_get_nth_child(self_: *mut DzlBox, nth: c_uint) -> *mut gtk::GtkWidget;
    pub fn dzl_box_set_max_width_request(self_: *mut DzlBox, max_width_request: c_int);

    //=========================================================================
    // DzlBoxTheatric
    //=========================================================================
    pub fn dzl_box_theatric_get_type() -> GType;

    //=========================================================================
    // DzlCenteringBin
    //=========================================================================
    pub fn dzl_centering_bin_get_type() -> GType;
    pub fn dzl_centering_bin_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlChildPropertyAction
    //=========================================================================
    pub fn dzl_child_property_action_get_type() -> GType;
    pub fn dzl_child_property_action_new(
        name: *const c_char,
        container: *mut gtk::GtkContainer,
        child: *mut gtk::GtkWidget,
        child_property_name: *const c_char,
    ) -> *mut gio::GAction;

    //=========================================================================
    // DzlColumnLayout
    //=========================================================================
    pub fn dzl_column_layout_get_type() -> GType;
    pub fn dzl_column_layout_new() -> *mut gtk::GtkWidget;
    pub fn dzl_column_layout_get_column_spacing(self_: *mut DzlColumnLayout) -> c_int;
    pub fn dzl_column_layout_get_column_width(self_: *mut DzlColumnLayout) -> c_int;
    pub fn dzl_column_layout_get_max_columns(self_: *mut DzlColumnLayout) -> c_uint;
    pub fn dzl_column_layout_get_row_spacing(self_: *mut DzlColumnLayout) -> c_int;
    pub fn dzl_column_layout_set_column_spacing(self_: *mut DzlColumnLayout, column_spacing: c_int);
    pub fn dzl_column_layout_set_column_width(self_: *mut DzlColumnLayout, column_width: c_int);
    pub fn dzl_column_layout_set_max_columns(self_: *mut DzlColumnLayout, max_columns: c_uint);
    pub fn dzl_column_layout_set_row_spacing(self_: *mut DzlColumnLayout, row_spacing: c_int);

    //=========================================================================
    // DzlCountersWindow
    //=========================================================================
    pub fn dzl_counters_window_get_type() -> GType;
    pub fn dzl_counters_window_new() -> *mut gtk::GtkWidget;
    pub fn dzl_counters_window_get_arena(self_: *mut DzlCountersWindow) -> *mut DzlCounterArena;
    pub fn dzl_counters_window_set_arena(
        self_: *mut DzlCountersWindow,
        arena: *mut DzlCounterArena,
    );

    //=========================================================================
    // DzlCpuGraph
    //=========================================================================
    pub fn dzl_cpu_graph_get_type() -> GType;
    pub fn dzl_cpu_graph_new_full(timespan: i64, max_samples: c_uint) -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlCpuModel
    //=========================================================================
    pub fn dzl_cpu_model_get_type() -> GType;
    pub fn dzl_cpu_model_new() -> *mut DzlGraphModel;

    //=========================================================================
    // DzlCssProvider
    //=========================================================================
    pub fn dzl_css_provider_get_type() -> GType;
    pub fn dzl_css_provider_new(base_path: *const c_char) -> *mut gtk::GtkCssProvider;

    //=========================================================================
    // DzlDirectoryModel
    //=========================================================================
    pub fn dzl_directory_model_get_type() -> GType;
    pub fn dzl_directory_model_new(directory: *mut gio::GFile) -> *mut gio::GListModel;
    pub fn dzl_directory_model_get_directory(self_: *mut DzlDirectoryModel) -> *mut gio::GFile;
    pub fn dzl_directory_model_set_directory(
        self_: *mut DzlDirectoryModel,
        directory: *mut gio::GFile,
    );
    pub fn dzl_directory_model_set_visible_func(
        self_: *mut DzlDirectoryModel,
        visible_func: DzlDirectoryModelVisibleFunc,
        user_data: gpointer,
        user_data_free_func: glib::GDestroyNotify,
    );

    //=========================================================================
    // DzlDirectoryReaper
    //=========================================================================
    pub fn dzl_directory_reaper_get_type() -> GType;
    pub fn dzl_directory_reaper_new() -> *mut DzlDirectoryReaper;
    pub fn dzl_directory_reaper_add_directory(
        self_: *mut DzlDirectoryReaper,
        directory: *mut gio::GFile,
        min_age: glib::GTimeSpan,
    );
    pub fn dzl_directory_reaper_add_file(
        self_: *mut DzlDirectoryReaper,
        file: *mut gio::GFile,
        min_age: glib::GTimeSpan,
    );
    pub fn dzl_directory_reaper_add_glob(
        self_: *mut DzlDirectoryReaper,
        directory: *mut gio::GFile,
        glob: *const c_char,
        min_age: glib::GTimeSpan,
    );
    pub fn dzl_directory_reaper_execute(
        self_: *mut DzlDirectoryReaper,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_directory_reaper_execute_async(
        self_: *mut DzlDirectoryReaper,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn dzl_directory_reaper_execute_finish(
        self_: *mut DzlDirectoryReaper,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // DzlDockBin
    //=========================================================================
    pub fn dzl_dock_bin_get_type() -> GType;
    pub fn dzl_dock_bin_new() -> *mut gtk::GtkWidget;
    pub fn dzl_dock_bin_get_bottom_edge(self_: *mut DzlDockBin) -> *mut gtk::GtkWidget;
    pub fn dzl_dock_bin_get_center_widget(self_: *mut DzlDockBin) -> *mut gtk::GtkWidget;
    pub fn dzl_dock_bin_get_left_edge(self_: *mut DzlDockBin) -> *mut gtk::GtkWidget;
    pub fn dzl_dock_bin_get_right_edge(self_: *mut DzlDockBin) -> *mut gtk::GtkWidget;
    pub fn dzl_dock_bin_get_top_edge(self_: *mut DzlDockBin) -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlDockBinEdge
    //=========================================================================
    pub fn dzl_dock_bin_edge_get_type() -> GType;
    pub fn dzl_dock_bin_edge_get_edge(self_: *mut DzlDockBinEdge) -> gtk::GtkPositionType;

    //=========================================================================
    // DzlDockManager
    //=========================================================================
    pub fn dzl_dock_manager_get_type() -> GType;
    pub fn dzl_dock_manager_new() -> *mut DzlDockManager;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_dock_manager_pause_grabs(self_: *mut DzlDockManager);
    pub fn dzl_dock_manager_register_dock(self_: *mut DzlDockManager, dock: *mut DzlDock);
    pub fn dzl_dock_manager_release_transient_grab(self_: *mut DzlDockManager);
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_dock_manager_unpause_grabs(self_: *mut DzlDockManager);
    pub fn dzl_dock_manager_unregister_dock(self_: *mut DzlDockManager, dock: *mut DzlDock);

    //=========================================================================
    // DzlDockOverlay
    //=========================================================================
    pub fn dzl_dock_overlay_get_type() -> GType;
    pub fn dzl_dock_overlay_new() -> *mut gtk::GtkWidget;
    pub fn dzl_dock_overlay_get_edge(
        self_: *mut DzlDockOverlay,
        position: gtk::GtkPositionType,
    ) -> *mut DzlDockOverlayEdge;
    pub fn dzl_dock_overlay_get_edge_adjustment(
        self_: *mut DzlDockOverlay,
        position: gtk::GtkPositionType,
    ) -> *mut gtk::GtkAdjustment;

    //=========================================================================
    // DzlDockOverlayEdge
    //=========================================================================
    pub fn dzl_dock_overlay_edge_get_type() -> GType;
    pub fn dzl_dock_overlay_edge_get_edge(self_: *mut DzlDockOverlayEdge) -> gtk::GtkPositionType;
    pub fn dzl_dock_overlay_edge_get_position(self_: *mut DzlDockOverlayEdge) -> c_int;
    pub fn dzl_dock_overlay_edge_set_edge(
        self_: *mut DzlDockOverlayEdge,
        edge: gtk::GtkPositionType,
    );
    pub fn dzl_dock_overlay_edge_set_position(self_: *mut DzlDockOverlayEdge, position: c_int);

    //=========================================================================
    // DzlDockPaned
    //=========================================================================
    pub fn dzl_dock_paned_get_type() -> GType;
    pub fn dzl_dock_paned_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlDockRevealer
    //=========================================================================
    pub fn dzl_dock_revealer_get_type() -> GType;
    pub fn dzl_dock_revealer_new() -> *mut gtk::GtkWidget;
    pub fn dzl_dock_revealer_animate_to_position(
        self_: *mut DzlDockRevealer,
        position: c_int,
        transition_duration: c_uint,
    );
    pub fn dzl_dock_revealer_get_child_revealed(self_: *mut DzlDockRevealer) -> gboolean;
    pub fn dzl_dock_revealer_get_position(self_: *mut DzlDockRevealer) -> c_int;
    pub fn dzl_dock_revealer_get_position_set(self_: *mut DzlDockRevealer) -> gboolean;
    pub fn dzl_dock_revealer_get_reveal_child(self_: *mut DzlDockRevealer) -> gboolean;
    pub fn dzl_dock_revealer_get_transition_duration(self_: *mut DzlDockRevealer) -> c_uint;
    pub fn dzl_dock_revealer_get_transition_type(
        self_: *mut DzlDockRevealer,
    ) -> DzlDockRevealerTransitionType;
    pub fn dzl_dock_revealer_is_animating(self_: *mut DzlDockRevealer) -> gboolean;
    pub fn dzl_dock_revealer_set_position(self_: *mut DzlDockRevealer, position: c_int);
    pub fn dzl_dock_revealer_set_position_set(self_: *mut DzlDockRevealer, position_set: gboolean);
    pub fn dzl_dock_revealer_set_reveal_child(self_: *mut DzlDockRevealer, reveal_child: gboolean);
    pub fn dzl_dock_revealer_set_transition_duration(
        self_: *mut DzlDockRevealer,
        transition_duration: c_uint,
    );
    pub fn dzl_dock_revealer_set_transition_type(
        self_: *mut DzlDockRevealer,
        transition_type: DzlDockRevealerTransitionType,
    );

    //=========================================================================
    // DzlDockStack
    //=========================================================================
    pub fn dzl_dock_stack_get_type() -> GType;
    pub fn dzl_dock_stack_new() -> *mut gtk::GtkWidget;
    pub fn dzl_dock_stack_get_edge(self_: *mut DzlDockStack) -> gtk::GtkPositionType;
    pub fn dzl_dock_stack_get_show_pinned_button(self_: *mut DzlDockStack) -> gboolean;
    pub fn dzl_dock_stack_get_style(self_: *mut DzlDockStack) -> DzlTabStyle;
    pub fn dzl_dock_stack_set_edge(self_: *mut DzlDockStack, edge: gtk::GtkPositionType);
    pub fn dzl_dock_stack_set_show_pinned_button(
        self_: *mut DzlDockStack,
        show_pinned_button: gboolean,
    );
    pub fn dzl_dock_stack_set_style(self_: *mut DzlDockStack, style: DzlTabStyle);

    //=========================================================================
    // DzlDockTransientGrab
    //=========================================================================
    pub fn dzl_dock_transient_grab_get_type() -> GType;
    pub fn dzl_dock_transient_grab_new() -> *mut DzlDockTransientGrab;
    pub fn dzl_dock_transient_grab_acquire(self_: *mut DzlDockTransientGrab);
    pub fn dzl_dock_transient_grab_add_item(
        self_: *mut DzlDockTransientGrab,
        item: *mut DzlDockItem,
    );
    pub fn dzl_dock_transient_grab_cancel(self_: *mut DzlDockTransientGrab);
    pub fn dzl_dock_transient_grab_contains(
        self_: *mut DzlDockTransientGrab,
        item: *mut DzlDockItem,
    ) -> gboolean;
    pub fn dzl_dock_transient_grab_get_timeout(self_: *mut DzlDockTransientGrab) -> c_uint;
    pub fn dzl_dock_transient_grab_is_descendant(
        self_: *mut DzlDockTransientGrab,
        widget: *mut gtk::GtkWidget,
    ) -> gboolean;
    pub fn dzl_dock_transient_grab_release(self_: *mut DzlDockTransientGrab);
    pub fn dzl_dock_transient_grab_remove_item(
        self_: *mut DzlDockTransientGrab,
        item: *mut DzlDockItem,
    );
    pub fn dzl_dock_transient_grab_set_timeout(self_: *mut DzlDockTransientGrab, timeout: c_uint);
    pub fn dzl_dock_transient_grab_steal_common_ancestors(
        self_: *mut DzlDockTransientGrab,
        other: *mut DzlDockTransientGrab,
    );

    //=========================================================================
    // DzlDockWidget
    //=========================================================================
    pub fn dzl_dock_widget_get_type() -> GType;
    pub fn dzl_dock_widget_new() -> *mut gtk::GtkWidget;
    pub fn dzl_dock_widget_set_gicon(self_: *mut DzlDockWidget, gicon: *mut gio::GIcon);
    pub fn dzl_dock_widget_set_icon_name(self_: *mut DzlDockWidget, icon_name: *const c_char);
    pub fn dzl_dock_widget_set_title(self_: *mut DzlDockWidget, title: *const c_char);

    //=========================================================================
    // DzlDockWindow
    //=========================================================================
    pub fn dzl_dock_window_get_type() -> GType;
    pub fn dzl_dock_window_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlElasticBin
    //=========================================================================
    pub fn dzl_elastic_bin_get_type() -> GType;
    pub fn dzl_elastic_bin_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlEmptyState
    //=========================================================================
    pub fn dzl_empty_state_get_type() -> GType;
    pub fn dzl_empty_state_new() -> *mut gtk::GtkWidget;
    pub fn dzl_empty_state_get_icon_name(self_: *mut DzlEmptyState) -> *const c_char;
    pub fn dzl_empty_state_get_subtitle(self_: *mut DzlEmptyState) -> *const c_char;
    pub fn dzl_empty_state_get_title(self_: *mut DzlEmptyState) -> *const c_char;
    pub fn dzl_empty_state_set_icon_name(self_: *mut DzlEmptyState, icon_name: *const c_char);
    pub fn dzl_empty_state_set_resource(self_: *mut DzlEmptyState, resource: *const c_char);
    pub fn dzl_empty_state_set_subtitle(self_: *mut DzlEmptyState, title: *const c_char);
    pub fn dzl_empty_state_set_title(self_: *mut DzlEmptyState, title: *const c_char);

    //=========================================================================
    // DzlEntryBox
    //=========================================================================
    pub fn dzl_entry_box_get_type() -> GType;
    pub fn dzl_entry_box_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlFileChooserEntry
    //=========================================================================
    pub fn dzl_file_chooser_entry_get_type() -> GType;
    pub fn dzl_file_chooser_entry_new(
        title: *const c_char,
        action: gtk::GtkFileChooserAction,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v3_32")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_32")))]
    pub fn dzl_file_chooser_entry_get_entry(self_: *mut DzlFileChooserEntry) -> *mut gtk::GtkEntry;
    pub fn dzl_file_chooser_entry_get_file(self_: *mut DzlFileChooserEntry) -> *mut gio::GFile;
    pub fn dzl_file_chooser_entry_set_file(self_: *mut DzlFileChooserEntry, file: *mut gio::GFile);

    //=========================================================================
    // DzlFileTransfer
    //=========================================================================
    pub fn dzl_file_transfer_get_type() -> GType;
    pub fn dzl_file_transfer_new() -> *mut DzlFileTransfer;
    pub fn dzl_file_transfer_add(
        self_: *mut DzlFileTransfer,
        src: *mut gio::GFile,
        dest: *mut gio::GFile,
    );
    pub fn dzl_file_transfer_execute(
        self_: *mut DzlFileTransfer,
        io_priority: c_int,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_file_transfer_execute_async(
        self_: *mut DzlFileTransfer,
        io_priority: c_int,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn dzl_file_transfer_execute_finish(
        self_: *mut DzlFileTransfer,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_file_transfer_get_flags(self_: *mut DzlFileTransfer) -> DzlFileTransferFlags;
    pub fn dzl_file_transfer_get_progress(self_: *mut DzlFileTransfer) -> c_double;
    pub fn dzl_file_transfer_set_flags(self_: *mut DzlFileTransfer, flags: DzlFileTransferFlags);
    #[cfg(feature = "v3_28")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_28")))]
    pub fn dzl_file_transfer_stat(self_: *mut DzlFileTransfer, stat_buf: *mut DzlFileTransferStat);

    //=========================================================================
    // DzlFuzzyIndex
    //=========================================================================
    pub fn dzl_fuzzy_index_get_type() -> GType;
    pub fn dzl_fuzzy_index_new() -> *mut DzlFuzzyIndex;
    pub fn dzl_fuzzy_index_get_metadata(
        self_: *mut DzlFuzzyIndex,
        key: *const c_char,
    ) -> *mut glib::GVariant;
    pub fn dzl_fuzzy_index_get_metadata_string(
        self_: *mut DzlFuzzyIndex,
        key: *const c_char,
    ) -> *const c_char;
    pub fn dzl_fuzzy_index_get_metadata_uint32(
        self_: *mut DzlFuzzyIndex,
        key: *const c_char,
    ) -> u32;
    pub fn dzl_fuzzy_index_get_metadata_uint64(
        self_: *mut DzlFuzzyIndex,
        key: *const c_char,
    ) -> u64;
    pub fn dzl_fuzzy_index_load_file(
        self_: *mut DzlFuzzyIndex,
        file: *mut gio::GFile,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_fuzzy_index_load_file_async(
        self_: *mut DzlFuzzyIndex,
        file: *mut gio::GFile,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn dzl_fuzzy_index_load_file_finish(
        self_: *mut DzlFuzzyIndex,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_fuzzy_index_query_async(
        self_: *mut DzlFuzzyIndex,
        query: *const c_char,
        max_matches: c_uint,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn dzl_fuzzy_index_query_finish(
        self_: *mut DzlFuzzyIndex,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> *mut gio::GListModel;

    //=========================================================================
    // DzlFuzzyIndexBuilder
    //=========================================================================
    pub fn dzl_fuzzy_index_builder_get_type() -> GType;
    pub fn dzl_fuzzy_index_builder_new() -> *mut DzlFuzzyIndexBuilder;
    pub fn dzl_fuzzy_index_builder_get_case_sensitive(self_: *mut DzlFuzzyIndexBuilder)
        -> gboolean;
    pub fn dzl_fuzzy_index_builder_get_document(
        self_: *mut DzlFuzzyIndexBuilder,
        document_id: u64,
    ) -> *const glib::GVariant;
    pub fn dzl_fuzzy_index_builder_insert(
        self_: *mut DzlFuzzyIndexBuilder,
        key: *const c_char,
        document: *mut glib::GVariant,
        priority: c_uint,
    ) -> u64;
    pub fn dzl_fuzzy_index_builder_set_case_sensitive(
        self_: *mut DzlFuzzyIndexBuilder,
        case_sensitive: gboolean,
    );
    pub fn dzl_fuzzy_index_builder_set_metadata(
        self_: *mut DzlFuzzyIndexBuilder,
        key: *const c_char,
        value: *mut glib::GVariant,
    );
    pub fn dzl_fuzzy_index_builder_set_metadata_string(
        self_: *mut DzlFuzzyIndexBuilder,
        key: *const c_char,
        value: *const c_char,
    );
    pub fn dzl_fuzzy_index_builder_set_metadata_uint32(
        self_: *mut DzlFuzzyIndexBuilder,
        key: *const c_char,
        value: u32,
    );
    pub fn dzl_fuzzy_index_builder_set_metadata_uint64(
        self_: *mut DzlFuzzyIndexBuilder,
        key: *const c_char,
        value: u64,
    );
    pub fn dzl_fuzzy_index_builder_write(
        self_: *mut DzlFuzzyIndexBuilder,
        file: *mut gio::GFile,
        io_priority: c_int,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_fuzzy_index_builder_write_async(
        self_: *mut DzlFuzzyIndexBuilder,
        file: *mut gio::GFile,
        io_priority: c_int,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn dzl_fuzzy_index_builder_write_finish(
        self_: *mut DzlFuzzyIndexBuilder,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // DzlFuzzyIndexCursor
    //=========================================================================
    pub fn dzl_fuzzy_index_cursor_get_type() -> GType;
    pub fn dzl_fuzzy_index_cursor_get_index(self_: *mut DzlFuzzyIndexCursor) -> *mut DzlFuzzyIndex;

    //=========================================================================
    // DzlFuzzyIndexMatch
    //=========================================================================
    pub fn dzl_fuzzy_index_match_get_type() -> GType;
    pub fn dzl_fuzzy_index_match_get_document(
        self_: *mut DzlFuzzyIndexMatch,
    ) -> *mut glib::GVariant;
    pub fn dzl_fuzzy_index_match_get_key(self_: *mut DzlFuzzyIndexMatch) -> *const c_char;
    pub fn dzl_fuzzy_index_match_get_priority(self_: *mut DzlFuzzyIndexMatch) -> c_uint;
    pub fn dzl_fuzzy_index_match_get_score(self_: *mut DzlFuzzyIndexMatch) -> c_float;

    //=========================================================================
    // DzlGraphColumn
    //=========================================================================
    pub fn dzl_graph_view_column_get_type() -> GType;
    pub fn dzl_graph_view_column_new(name: *const c_char, value_type: GType)
        -> *mut DzlGraphColumn;
    pub fn dzl_graph_view_column_get_name(self_: *mut DzlGraphColumn) -> *const c_char;
    pub fn dzl_graph_view_column_set_name(self_: *mut DzlGraphColumn, name: *const c_char);

    //=========================================================================
    // DzlGraphLineRenderer
    //=========================================================================
    pub fn dzl_graph_view_line_renderer_get_type() -> GType;
    pub fn dzl_graph_view_line_renderer_new() -> *mut DzlGraphLineRenderer;
    pub fn dzl_graph_view_line_renderer_get_stroke_color_rgba(
        self_: *mut DzlGraphLineRenderer,
    ) -> *const gdk::GdkRGBA;
    pub fn dzl_graph_view_line_renderer_set_stroke_color(
        self_: *mut DzlGraphLineRenderer,
        stroke_color: *const c_char,
    );
    pub fn dzl_graph_view_line_renderer_set_stroke_color_rgba(
        self_: *mut DzlGraphLineRenderer,
        stroke_color_rgba: *const gdk::GdkRGBA,
    );

    //=========================================================================
    // DzlGraphModel
    //=========================================================================
    pub fn dzl_graph_view_model_get_type() -> GType;
    pub fn dzl_graph_view_model_new() -> *mut DzlGraphModel;
    pub fn dzl_graph_view_model_iter_get(iter: *mut DzlGraphModelIter, first_column: c_int, ...);
    pub fn dzl_graph_view_model_iter_get_timestamp(iter: *mut DzlGraphModelIter) -> i64;
    pub fn dzl_graph_view_model_iter_get_value(
        iter: *mut DzlGraphModelIter,
        column: c_uint,
        value: *mut gobject::GValue,
    );
    pub fn dzl_graph_view_model_iter_next(iter: *mut DzlGraphModelIter) -> gboolean;
    pub fn dzl_graph_view_model_iter_set(iter: *mut DzlGraphModelIter, first_column: c_int, ...);
    #[cfg(feature = "v3_30")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_30")))]
    pub fn dzl_graph_view_model_iter_set_value(
        iter: *mut DzlGraphModelIter,
        column: c_uint,
        value: *const gobject::GValue,
    );
    pub fn dzl_graph_view_model_add_column(
        self_: *mut DzlGraphModel,
        column: *mut DzlGraphColumn,
    ) -> c_uint;
    pub fn dzl_graph_view_model_get_end_time(self_: *mut DzlGraphModel) -> i64;
    pub fn dzl_graph_view_model_get_iter_first(
        self_: *mut DzlGraphModel,
        iter: *mut DzlGraphModelIter,
    ) -> gboolean;
    pub fn dzl_graph_view_model_get_iter_last(
        self_: *mut DzlGraphModel,
        iter: *mut DzlGraphModelIter,
    ) -> gboolean;
    pub fn dzl_graph_view_model_get_max_samples(self_: *mut DzlGraphModel) -> c_uint;
    pub fn dzl_graph_view_model_get_n_columns(self_: *mut DzlGraphModel) -> c_uint;
    pub fn dzl_graph_view_model_get_timespan(self_: *mut DzlGraphModel) -> glib::GTimeSpan;
    pub fn dzl_graph_view_model_push(
        self_: *mut DzlGraphModel,
        iter: *mut DzlGraphModelIter,
        timestamp: i64,
    );
    pub fn dzl_graph_view_model_set_max_samples(self_: *mut DzlGraphModel, n_rows: c_uint);
    pub fn dzl_graph_view_model_set_timespan(self_: *mut DzlGraphModel, timespan: glib::GTimeSpan);

    //=========================================================================
    // DzlGraphView
    //=========================================================================
    pub fn dzl_graph_view_get_type() -> GType;
    pub fn dzl_graph_view_new() -> *mut gtk::GtkWidget;
    pub fn dzl_graph_view_add_renderer(self_: *mut DzlGraphView, renderer: *mut DzlGraphRenderer);
    pub fn dzl_graph_view_get_model(self_: *mut DzlGraphView) -> *mut DzlGraphModel;
    pub fn dzl_graph_view_set_model(self_: *mut DzlGraphView, model: *mut DzlGraphModel);

    //=========================================================================
    // DzlJoinedMenu
    //=========================================================================
    pub fn dzl_joined_menu_get_type() -> GType;
    pub fn dzl_joined_menu_new() -> *mut DzlJoinedMenu;
    pub fn dzl_joined_menu_append_menu(self_: *mut DzlJoinedMenu, model: *mut gio::GMenuModel);
    pub fn dzl_joined_menu_get_n_joined(self_: *mut DzlJoinedMenu) -> c_uint;
    pub fn dzl_joined_menu_prepend_menu(self_: *mut DzlJoinedMenu, model: *mut gio::GMenuModel);
    pub fn dzl_joined_menu_remove_index(self_: *mut DzlJoinedMenu, index: c_uint);
    pub fn dzl_joined_menu_remove_menu(self_: *mut DzlJoinedMenu, model: *mut gio::GMenuModel);

    //=========================================================================
    // DzlListBox
    //=========================================================================
    pub fn dzl_list_box_get_type() -> GType;
    pub fn dzl_list_box_new(row_type: GType, property_name: *const c_char) -> *mut gtk::GtkWidget;
    pub fn dzl_list_box_get_model(self_: *mut DzlListBox) -> *mut gio::GListModel;
    pub fn dzl_list_box_get_property_name(self_: *mut DzlListBox) -> *const c_char;
    pub fn dzl_list_box_get_row_type(self_: *mut DzlListBox) -> GType;
    pub fn dzl_list_box_set_model(self_: *mut DzlListBox, model: *mut gio::GListModel);
    #[cfg(feature = "v3_28")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_28")))]
    pub fn dzl_list_box_set_recycle_max(self_: *mut DzlListBox, recycle_max: c_uint);

    //=========================================================================
    // DzlListBoxRow
    //=========================================================================
    pub fn dzl_list_box_row_get_type() -> GType;

    //=========================================================================
    // DzlListModelFilter
    //=========================================================================
    pub fn dzl_list_model_filter_get_type() -> GType;
    pub fn dzl_list_model_filter_new(child_model: *mut gio::GListModel) -> *mut DzlListModelFilter;
    pub fn dzl_list_model_filter_get_child_model(
        self_: *mut DzlListModelFilter,
    ) -> *mut gio::GListModel;
    pub fn dzl_list_model_filter_invalidate(self_: *mut DzlListModelFilter);
    pub fn dzl_list_model_filter_set_filter_func(
        self_: *mut DzlListModelFilter,
        filter_func: DzlListModelFilterFunc,
        filter_func_data: gpointer,
        filter_func_data_destroy: glib::GDestroyNotify,
    );

    //=========================================================================
    // DzlListStoreAdapter
    //=========================================================================
    pub fn dzl_list_store_adapter_get_type() -> GType;
    pub fn dzl_list_store_adapter_new(model: *mut gio::GListModel) -> *mut DzlListStoreAdapter;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_list_store_adapter_get_model(
        self_: *mut DzlListStoreAdapter,
    ) -> *mut gio::GListModel;
    pub fn dzl_list_store_adapter_set_model(
        self_: *mut DzlListStoreAdapter,
        model: *mut gio::GListModel,
    );

    //=========================================================================
    // DzlMenuButton
    //=========================================================================
    pub fn dzl_menu_button_get_type() -> GType;
    pub fn dzl_menu_button_new_with_model(
        icon_name: *const c_char,
        model: *mut gio::GMenuModel,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_menu_button_get_model(self_: *mut DzlMenuButton) -> *mut gio::GMenuModel;
    pub fn dzl_menu_button_get_show_accels(self_: *mut DzlMenuButton) -> gboolean;
    pub fn dzl_menu_button_get_show_arrow(self_: *mut DzlMenuButton) -> gboolean;
    pub fn dzl_menu_button_get_show_icons(self_: *mut DzlMenuButton) -> gboolean;
    pub fn dzl_menu_button_set_model(self_: *mut DzlMenuButton, model: *mut gio::GMenuModel);
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_menu_button_set_show_accels(self_: *mut DzlMenuButton, show_accels: gboolean);
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_menu_button_set_show_arrow(self_: *mut DzlMenuButton, show_arrow: gboolean);
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_menu_button_set_show_icons(self_: *mut DzlMenuButton, show_icons: gboolean);

    //=========================================================================
    // DzlMenuManager
    //=========================================================================
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_menu_manager_get_type() -> GType;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_menu_manager_new() -> *mut DzlMenuManager;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_menu_manager_add_filename(
        self_: *mut DzlMenuManager,
        filename: *const c_char,
        error: *mut *mut glib::GError,
    ) -> c_uint;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_menu_manager_add_resource(
        self_: *mut DzlMenuManager,
        resource: *const c_char,
        error: *mut *mut glib::GError,
    ) -> c_uint;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_menu_manager_get_menu_by_id(
        self_: *mut DzlMenuManager,
        menu_id: *const c_char,
    ) -> *mut gio::GMenu;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_menu_manager_merge(
        self_: *mut DzlMenuManager,
        menu_id: *const c_char,
        model: *mut gio::GMenuModel,
    ) -> c_uint;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_menu_manager_remove(self_: *mut DzlMenuManager, merge_id: c_uint);

    //=========================================================================
    // DzlMultiPaned
    //=========================================================================
    pub fn dzl_multi_paned_get_type() -> GType;
    pub fn dzl_multi_paned_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v3_28")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_28")))]
    pub fn dzl_multi_paned_get_at_point(
        self_: *mut DzlMultiPaned,
        x: c_int,
        y: c_int,
    ) -> *mut gtk::GtkWidget;
    pub fn dzl_multi_paned_get_n_children(self_: *mut DzlMultiPaned) -> c_uint;
    pub fn dzl_multi_paned_get_nth_child(
        self_: *mut DzlMultiPaned,
        nth: c_uint,
    ) -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlPath
    //=========================================================================
    pub fn dzl_path_get_type() -> GType;
    pub fn dzl_path_new() -> *mut DzlPath;
    pub fn dzl_path_append(self_: *mut DzlPath, element: *mut DzlPathElement);
    pub fn dzl_path_get_element(self_: *mut DzlPath, index: c_uint) -> *mut DzlPathElement;
    pub fn dzl_path_get_elements(self_: *mut DzlPath) -> *mut glib::GList;
    pub fn dzl_path_get_length(self_: *mut DzlPath) -> c_uint;
    pub fn dzl_path_has_prefix(self_: *mut DzlPath, prefix: *mut DzlPath) -> gboolean;
    pub fn dzl_path_is_empty(self_: *mut DzlPath) -> gboolean;
    pub fn dzl_path_prepend(self_: *mut DzlPath, element: *mut DzlPathElement);
    pub fn dzl_path_printf(self_: *mut DzlPath) -> *mut c_char;

    //=========================================================================
    // DzlPathBar
    //=========================================================================
    pub fn dzl_path_bar_get_type() -> GType;
    pub fn dzl_path_bar_new() -> *mut gtk::GtkWidget;
    pub fn dzl_path_bar_get_path(self_: *mut DzlPathBar) -> *mut DzlPath;
    pub fn dzl_path_bar_set_path(self_: *mut DzlPathBar, path: *mut DzlPath);
    pub fn dzl_path_bar_set_selected_index(self_: *mut DzlPathBar, index: c_uint);

    //=========================================================================
    // DzlPathElement
    //=========================================================================
    pub fn dzl_path_element_get_type() -> GType;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_path_element_new(
        id: *const c_char,
        icon_name: *const c_char,
        title: *const c_char,
    ) -> *mut DzlPathElement;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_path_element_get_icon_name(self_: *mut DzlPathElement) -> *const c_char;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_path_element_get_id(self_: *mut DzlPathElement) -> *const c_char;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_path_element_get_title(self_: *mut DzlPathElement) -> *const c_char;

    //=========================================================================
    // DzlPillBox
    //=========================================================================
    pub fn dzl_pill_box_get_type() -> GType;
    pub fn dzl_pill_box_new(label: *const c_char) -> *mut gtk::GtkWidget;
    pub fn dzl_pill_box_get_label(self_: *mut DzlPillBox) -> *const c_char;
    pub fn dzl_pill_box_set_label(self_: *mut DzlPillBox, label: *const c_char);

    //=========================================================================
    // DzlPreferencesBin
    //=========================================================================
    pub fn dzl_preferences_bin_get_type() -> GType;

    //=========================================================================
    // DzlPreferencesEntry
    //=========================================================================
    pub fn dzl_preferences_entry_get_type() -> GType;
    pub fn dzl_preferences_entry_get_entry_widget(
        self_: *mut DzlPreferencesEntry,
    ) -> *mut gtk::GtkWidget;
    pub fn dzl_preferences_entry_get_title_widget(
        self_: *mut DzlPreferencesEntry,
    ) -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlPreferencesFileChooserButton
    //=========================================================================
    pub fn dzl_preferences_file_chooser_button_get_type() -> GType;

    //=========================================================================
    // DzlPreferencesFlowBox
    //=========================================================================
    pub fn dzl_preferences_flow_box_get_type() -> GType;
    pub fn dzl_preferences_flow_box_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlPreferencesFontButton
    //=========================================================================
    pub fn dzl_preferences_font_button_get_type() -> GType;

    //=========================================================================
    // DzlPreferencesGroup
    //=========================================================================
    pub fn dzl_preferences_group_get_type() -> GType;
    pub fn dzl_preferences_group_add(self_: *mut DzlPreferencesGroup, widget: *mut gtk::GtkWidget);
    pub fn dzl_preferences_group_get_priority(self_: *mut DzlPreferencesGroup) -> c_int;
    pub fn dzl_preferences_group_get_size_group(
        self_: *mut DzlPreferencesGroup,
        column: c_uint,
    ) -> *mut gtk::GtkSizeGroup;
    pub fn dzl_preferences_group_get_title(self_: *mut DzlPreferencesGroup) -> *const c_char;
    pub fn dzl_preferences_group_refilter(
        self_: *mut DzlPreferencesGroup,
        spec: *mut DzlPatternSpec,
    ) -> c_uint;
    pub fn dzl_preferences_group_set_map(
        self_: *mut DzlPreferencesGroup,
        map: *mut glib::GHashTable,
    );

    //=========================================================================
    // DzlPreferencesPage
    //=========================================================================
    pub fn dzl_preferences_page_get_type() -> GType;
    pub fn dzl_preferences_page_add_group(
        self_: *mut DzlPreferencesPage,
        group: *mut DzlPreferencesGroup,
    );
    pub fn dzl_preferences_page_get_group(
        self_: *mut DzlPreferencesPage,
        group_name: *const c_char,
    ) -> *mut DzlPreferencesGroup;
    pub fn dzl_preferences_page_refilter(self_: *mut DzlPreferencesPage, spec: *mut DzlPatternSpec);
    pub fn dzl_preferences_page_set_map(self_: *mut DzlPreferencesPage, map: *mut glib::GHashTable);

    //=========================================================================
    // DzlPreferencesSpinButton
    //=========================================================================
    pub fn dzl_preferences_spin_button_get_type() -> GType;
    pub fn dzl_preferences_spin_button_get_spin_button(
        self_: *mut DzlPreferencesSpinButton,
    ) -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlPreferencesSwitch
    //=========================================================================
    pub fn dzl_preferences_switch_get_type() -> GType;

    //=========================================================================
    // DzlPreferencesView
    //=========================================================================
    pub fn dzl_preferences_view_get_type() -> GType;
    pub fn dzl_preferences_view_new() -> *mut gtk::GtkWidget;
    pub fn dzl_preferences_view_get_show_search_entry(self_: *mut DzlPreferencesView) -> gboolean;
    pub fn dzl_preferences_view_get_use_sidebar(self_: *mut DzlPreferencesView) -> gboolean;
    pub fn dzl_preferences_view_reapply_filter(self_: *mut DzlPreferencesView);
    pub fn dzl_preferences_view_set_show_search_entry(
        self_: *mut DzlPreferencesView,
        show_search_entry: gboolean,
    );
    pub fn dzl_preferences_view_set_use_sidebar(
        self_: *mut DzlPreferencesView,
        use_sidebar: gboolean,
    );

    //=========================================================================
    // DzlPriorityBox
    //=========================================================================
    pub fn dzl_priority_box_get_type() -> GType;
    pub fn dzl_priority_box_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlProgressButton
    //=========================================================================
    pub fn dzl_progress_button_get_type() -> GType;
    pub fn dzl_progress_button_new() -> *mut gtk::GtkWidget;
    pub fn dzl_progress_button_get_progress(self_: *mut DzlProgressButton) -> c_uint;
    pub fn dzl_progress_button_get_show_progress(self_: *mut DzlProgressButton) -> gboolean;
    pub fn dzl_progress_button_set_progress(button: *mut DzlProgressButton, percentage: c_uint);
    pub fn dzl_progress_button_set_show_progress(
        button: *mut DzlProgressButton,
        show_progress: gboolean,
    );

    //=========================================================================
    // DzlProgressIcon
    //=========================================================================
    pub fn dzl_progress_icon_get_type() -> GType;
    pub fn dzl_progress_icon_new() -> *mut gtk::GtkWidget;
    pub fn dzl_progress_icon_get_progress(self_: *mut DzlProgressIcon) -> c_double;
    pub fn dzl_progress_icon_set_progress(self_: *mut DzlProgressIcon, progress: c_double);

    //=========================================================================
    // DzlProgressMenuButton
    //=========================================================================
    pub fn dzl_progress_menu_button_get_type() -> GType;
    pub fn dzl_progress_menu_button_new() -> *mut gtk::GtkWidget;
    pub fn dzl_progress_menu_button_get_progress(button: *mut DzlProgressMenuButton) -> c_double;
    pub fn dzl_progress_menu_button_get_show_progress(
        self_: *mut DzlProgressMenuButton,
    ) -> gboolean;
    pub fn dzl_progress_menu_button_get_show_theatric(
        self_: *mut DzlProgressMenuButton,
    ) -> gboolean;
    pub fn dzl_progress_menu_button_reset_theatrics(self_: *mut DzlProgressMenuButton);
    pub fn dzl_progress_menu_button_set_progress(
        button: *mut DzlProgressMenuButton,
        progress: c_double,
    );
    pub fn dzl_progress_menu_button_set_show_progress(
        self_: *mut DzlProgressMenuButton,
        show_progress: gboolean,
    );
    pub fn dzl_progress_menu_button_set_show_theatric(
        self_: *mut DzlProgressMenuButton,
        show_theatic: gboolean,
    );

    //=========================================================================
    // DzlPropertiesGroup
    //=========================================================================
    pub fn dzl_properties_group_get_type() -> GType;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_properties_group_new(object: *mut gobject::GObject) -> *mut DzlPropertiesGroup;
    pub fn dzl_properties_group_new_for_type(object_type: GType) -> *mut DzlPropertiesGroup;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_properties_group_add_all_properties(self_: *mut DzlPropertiesGroup);
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_properties_group_add_property(
        self_: *mut DzlPropertiesGroup,
        name: *const c_char,
        property_name: *const c_char,
    );
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_properties_group_add_property_full(
        self_: *mut DzlPropertiesGroup,
        name: *const c_char,
        property_name: *const c_char,
        flags: DzlPropertiesFlags,
    );
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_properties_group_remove(self_: *mut DzlPropertiesGroup, name: *const c_char);

    //=========================================================================
    // DzlRadioBox
    //=========================================================================
    pub fn dzl_radio_box_get_type() -> GType;
    pub fn dzl_radio_box_new() -> *mut gtk::GtkWidget;
    pub fn dzl_radio_box_add_item(self_: *mut DzlRadioBox, id: *const c_char, text: *const c_char);
    pub fn dzl_radio_box_get_active_id(self_: *mut DzlRadioBox) -> *const c_char;
    pub fn dzl_radio_box_remove_item(self_: *mut DzlRadioBox, id: *const c_char);
    pub fn dzl_radio_box_set_active_id(self_: *mut DzlRadioBox, id: *const c_char);

    //=========================================================================
    // DzlReadOnlyListModel
    //=========================================================================
    pub fn dzl_read_only_list_model_get_type() -> GType;
    #[cfg(feature = "v3_30")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_30")))]
    pub fn dzl_read_only_list_model_new(base_model: *mut gio::GListModel) -> *mut gio::GListModel;

    //=========================================================================
    // DzlRecursiveFileMonitor
    //=========================================================================
    pub fn dzl_recursive_file_monitor_get_type() -> GType;
    pub fn dzl_recursive_file_monitor_new(root: *mut gio::GFile) -> *mut DzlRecursiveFileMonitor;
    #[cfg(feature = "v3_28")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_28")))]
    pub fn dzl_recursive_file_monitor_cancel(self_: *mut DzlRecursiveFileMonitor);
    #[cfg(feature = "v3_28")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_28")))]
    pub fn dzl_recursive_file_monitor_get_root(
        self_: *mut DzlRecursiveFileMonitor,
    ) -> *mut gio::GFile;
    #[cfg(feature = "v3_28")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_28")))]
    pub fn dzl_recursive_file_monitor_set_ignore_func(
        self_: *mut DzlRecursiveFileMonitor,
        ignore_func: DzlRecursiveIgnoreFunc,
        ignore_func_data: gpointer,
        ignore_func_data_destroy: glib::GDestroyNotify,
    );
    pub fn dzl_recursive_file_monitor_start_async(
        self_: *mut DzlRecursiveFileMonitor,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn dzl_recursive_file_monitor_start_finish(
        self_: *mut DzlRecursiveFileMonitor,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // DzlScrolledWindow
    //=========================================================================
    pub fn dzl_scrolled_window_get_type() -> GType;

    //=========================================================================
    // DzlSearchBar
    //=========================================================================
    pub fn dzl_search_bar_get_type() -> GType;
    pub fn dzl_search_bar_new() -> *mut gtk::GtkWidget;
    pub fn dzl_search_bar_get_entry(self_: *mut DzlSearchBar) -> *mut gtk::GtkSearchEntry;
    pub fn dzl_search_bar_get_search_mode_enabled(self_: *mut DzlSearchBar) -> gboolean;
    pub fn dzl_search_bar_get_show_close_button(self_: *mut DzlSearchBar) -> gboolean;
    pub fn dzl_search_bar_set_search_mode_enabled(
        self_: *mut DzlSearchBar,
        search_mode_enabled: gboolean,
    );
    pub fn dzl_search_bar_set_show_close_button(
        self_: *mut DzlSearchBar,
        show_close_button: gboolean,
    );

    //=========================================================================
    // DzlSettingsFlagAction
    //=========================================================================
    pub fn dzl_settings_flag_action_get_type() -> GType;
    pub fn dzl_settings_flag_action_new(
        schema_id: *const c_char,
        schema_key: *const c_char,
        flag_nick: *const c_char,
    ) -> *mut gio::GAction;

    //=========================================================================
    // DzlSettingsSandwich
    //=========================================================================
    pub fn dzl_settings_sandwich_get_type() -> GType;
    pub fn dzl_settings_sandwich_new(
        schema_id: *const c_char,
        path: *const c_char,
    ) -> *mut DzlSettingsSandwich;
    pub fn dzl_settings_sandwich_append(
        self_: *mut DzlSettingsSandwich,
        settings: *mut gio::GSettings,
    );
    pub fn dzl_settings_sandwich_bind(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
        object: gpointer,
        property: *const c_char,
        flags: gio::GSettingsBindFlags,
    );
    pub fn dzl_settings_sandwich_bind_with_mapping(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
        object: gpointer,
        property: *const c_char,
        flags: gio::GSettingsBindFlags,
        get_mapping: gio::GSettingsBindGetMapping,
        set_mapping: gio::GSettingsBindSetMapping,
        user_data: gpointer,
        destroy: glib::GDestroyNotify,
    );
    pub fn dzl_settings_sandwich_get_boolean(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
    ) -> gboolean;
    pub fn dzl_settings_sandwich_get_default_value(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
    ) -> *mut glib::GVariant;
    pub fn dzl_settings_sandwich_get_double(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
    ) -> c_double;
    pub fn dzl_settings_sandwich_get_int(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
    ) -> c_int;
    pub fn dzl_settings_sandwich_get_string(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
    ) -> *mut c_char;
    pub fn dzl_settings_sandwich_get_uint(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
    ) -> c_uint;
    pub fn dzl_settings_sandwich_get_user_value(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
    ) -> *mut glib::GVariant;
    pub fn dzl_settings_sandwich_get_value(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
    ) -> *mut glib::GVariant;
    pub fn dzl_settings_sandwich_set_boolean(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
        val: gboolean,
    );
    pub fn dzl_settings_sandwich_set_double(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
        val: c_double,
    );
    pub fn dzl_settings_sandwich_set_int(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
        val: c_int,
    );
    pub fn dzl_settings_sandwich_set_string(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
        val: *const c_char,
    );
    pub fn dzl_settings_sandwich_set_uint(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
        val: c_uint,
    );
    pub fn dzl_settings_sandwich_set_value(
        self_: *mut DzlSettingsSandwich,
        key: *const c_char,
        value: *mut glib::GVariant,
    );
    pub fn dzl_settings_sandwich_unbind(self_: *mut DzlSettingsSandwich, property: *const c_char);

    //=========================================================================
    // DzlShortcutAccelDialog
    //=========================================================================
    pub fn dzl_shortcut_accel_dialog_get_type() -> GType;
    pub fn dzl_shortcut_accel_dialog_new() -> *mut gtk::GtkWidget;
    pub fn dzl_shortcut_accel_dialog_get_accelerator(
        self_: *mut DzlShortcutAccelDialog,
    ) -> *mut c_char;
    pub fn dzl_shortcut_accel_dialog_get_chord(
        self_: *mut DzlShortcutAccelDialog,
    ) -> *const DzlShortcutChord;
    pub fn dzl_shortcut_accel_dialog_get_shortcut_title(
        self_: *mut DzlShortcutAccelDialog,
    ) -> *const c_char;
    pub fn dzl_shortcut_accel_dialog_set_accelerator(
        self_: *mut DzlShortcutAccelDialog,
        accelerator: *const c_char,
    );
    pub fn dzl_shortcut_accel_dialog_set_shortcut_title(
        self_: *mut DzlShortcutAccelDialog,
        title: *const c_char,
    );

    //=========================================================================
    // DzlShortcutContext
    //=========================================================================
    pub fn dzl_shortcut_context_get_type() -> GType;
    pub fn dzl_shortcut_context_new(name: *const c_char) -> *mut DzlShortcutContext;
    pub fn dzl_shortcut_context_activate(
        self_: *mut DzlShortcutContext,
        widget: *mut gtk::GtkWidget,
        chord: *const DzlShortcutChord,
    ) -> DzlShortcutMatch;
    pub fn dzl_shortcut_context_add_action(
        self_: *mut DzlShortcutContext,
        accel: *const c_char,
        detailed_action_name: *const c_char,
    );
    pub fn dzl_shortcut_context_add_command(
        self_: *mut DzlShortcutContext,
        accel: *const c_char,
        command: *const c_char,
    );
    pub fn dzl_shortcut_context_add_signal(
        self_: *mut DzlShortcutContext,
        accel: *const c_char,
        signal_name: *const c_char,
        n_args: c_uint,
        ...
    );
    //pub fn dzl_shortcut_context_add_signal_va_list(self_: *mut DzlShortcutContext, accel: *const c_char, signal_name: *const c_char, n_args: c_uint, args: /*Unimplemented*/va_list);
    pub fn dzl_shortcut_context_add_signalv(
        self_: *mut DzlShortcutContext,
        accel: *const c_char,
        signal_name: *const c_char,
        values: *mut glib::GArray,
    );
    pub fn dzl_shortcut_context_get_name(self_: *mut DzlShortcutContext) -> *const c_char;
    pub fn dzl_shortcut_context_load_from_data(
        self_: *mut DzlShortcutContext,
        data: *const c_char,
        len: ssize_t,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_shortcut_context_load_from_resource(
        self_: *mut DzlShortcutContext,
        resource_path: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_shortcut_context_remove(
        self_: *mut DzlShortcutContext,
        accel: *const c_char,
    ) -> gboolean;

    //=========================================================================
    // DzlShortcutController
    //=========================================================================
    pub fn dzl_shortcut_controller_get_type() -> GType;
    pub fn dzl_shortcut_controller_new(widget: *mut gtk::GtkWidget) -> *mut DzlShortcutController;
    pub fn dzl_shortcut_controller_find(widget: *mut gtk::GtkWidget) -> *mut DzlShortcutController;
    pub fn dzl_shortcut_controller_try_find(
        widget: *mut gtk::GtkWidget,
    ) -> *mut DzlShortcutController;
    pub fn dzl_shortcut_controller_add_command_action(
        self_: *mut DzlShortcutController,
        command_id: *const c_char,
        default_accel: *const c_char,
        phase: DzlShortcutPhase,
        action: *const c_char,
    );
    pub fn dzl_shortcut_controller_add_command_callback(
        self_: *mut DzlShortcutController,
        command_id: *const c_char,
        default_accel: *const c_char,
        phase: DzlShortcutPhase,
        callback: gtk::GtkCallback,
        callback_data: gpointer,
        callback_data_destroy: glib::GDestroyNotify,
    );
    pub fn dzl_shortcut_controller_add_command_signal(
        self_: *mut DzlShortcutController,
        command_id: *const c_char,
        default_accel: *const c_char,
        phase: DzlShortcutPhase,
        signal_name: *const c_char,
        n_args: c_uint,
        ...
    );
    pub fn dzl_shortcut_controller_execute_command(
        self_: *mut DzlShortcutController,
        command: *const c_char,
    ) -> gboolean;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_shortcut_controller_get_context(
        self_: *mut DzlShortcutController,
    ) -> *mut DzlShortcutContext;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_shortcut_controller_get_context_for_phase(
        self_: *mut DzlShortcutController,
        phase: DzlShortcutPhase,
    ) -> *mut DzlShortcutContext;
    pub fn dzl_shortcut_controller_get_current_chord(
        self_: *mut DzlShortcutController,
    ) -> *const DzlShortcutChord;
    pub fn dzl_shortcut_controller_get_manager(
        self_: *mut DzlShortcutController,
    ) -> *mut DzlShortcutManager;
    #[cfg(feature = "v3_34")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_34")))]
    pub fn dzl_shortcut_controller_get_widget(
        self_: *mut DzlShortcutController,
    ) -> *mut gtk::GtkWidget;
    pub fn dzl_shortcut_controller_remove_accel(
        self_: *mut DzlShortcutController,
        accel: *const c_char,
        phase: DzlShortcutPhase,
    );
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_shortcut_controller_set_context_by_name(
        self_: *mut DzlShortcutController,
        name: *const c_char,
    );
    pub fn dzl_shortcut_controller_set_manager(
        self_: *mut DzlShortcutController,
        manager: *mut DzlShortcutManager,
    );

    //=========================================================================
    // DzlShortcutLabel
    //=========================================================================
    pub fn dzl_shortcut_label_get_type() -> GType;
    pub fn dzl_shortcut_label_new() -> *mut gtk::GtkWidget;
    pub fn dzl_shortcut_label_get_accelerator(self_: *mut DzlShortcutLabel) -> *mut c_char;
    pub fn dzl_shortcut_label_get_chord(self_: *mut DzlShortcutLabel) -> *const DzlShortcutChord;
    pub fn dzl_shortcut_label_set_accelerator(
        self_: *mut DzlShortcutLabel,
        accelerator: *const c_char,
    );
    pub fn dzl_shortcut_label_set_chord(
        self_: *mut DzlShortcutLabel,
        chord: *const DzlShortcutChord,
    );

    //=========================================================================
    // DzlShortcutManager
    //=========================================================================
    pub fn dzl_shortcut_manager_get_type() -> GType;
    pub fn dzl_shortcut_manager_get_default() -> *mut DzlShortcutManager;
    pub fn dzl_shortcut_manager_add_action(
        self_: *mut DzlShortcutManager,
        detailed_action_name: *const c_char,
        section: *const c_char,
        group: *const c_char,
        title: *const c_char,
        subtitle: *const c_char,
    );
    pub fn dzl_shortcut_manager_add_command(
        self_: *mut DzlShortcutManager,
        command: *const c_char,
        section: *const c_char,
        group: *const c_char,
        title: *const c_char,
        subtitle: *const c_char,
    );
    pub fn dzl_shortcut_manager_add_shortcut_entries(
        self_: *mut DzlShortcutManager,
        shortcuts: *const DzlShortcutEntry,
        n_shortcuts: c_uint,
        translation_domain: *const c_char,
    );
    pub fn dzl_shortcut_manager_add_shortcuts_to_window(
        self_: *mut DzlShortcutManager,
        window: *mut DzlShortcutsWindow,
    );
    pub fn dzl_shortcut_manager_append_search_path(
        self_: *mut DzlShortcutManager,
        directory: *const c_char,
    );
    pub fn dzl_shortcut_manager_get_theme(self_: *mut DzlShortcutManager) -> *mut DzlShortcutTheme;
    pub fn dzl_shortcut_manager_get_theme_by_name(
        self_: *mut DzlShortcutManager,
        theme_name: *const c_char,
    ) -> *mut DzlShortcutTheme;
    pub fn dzl_shortcut_manager_get_theme_name(self_: *mut DzlShortcutManager) -> *const c_char;
    pub fn dzl_shortcut_manager_get_user_dir(self_: *mut DzlShortcutManager) -> *const c_char;
    pub fn dzl_shortcut_manager_handle_event(
        self_: *mut DzlShortcutManager,
        event: *const gdk::GdkEventKey,
        toplevel: *mut gtk::GtkWidget,
    ) -> gboolean;
    pub fn dzl_shortcut_manager_prepend_search_path(
        self_: *mut DzlShortcutManager,
        directory: *const c_char,
    );
    pub fn dzl_shortcut_manager_queue_reload(self_: *mut DzlShortcutManager);
    pub fn dzl_shortcut_manager_reload(
        self_: *mut DzlShortcutManager,
        cancellable: *mut gio::GCancellable,
    );
    pub fn dzl_shortcut_manager_remove_search_path(
        self_: *mut DzlShortcutManager,
        directory: *const c_char,
    );
    pub fn dzl_shortcut_manager_set_theme(
        self_: *mut DzlShortcutManager,
        theme: *mut DzlShortcutTheme,
    );
    pub fn dzl_shortcut_manager_set_theme_name(
        self_: *mut DzlShortcutManager,
        theme_name: *const c_char,
    );
    pub fn dzl_shortcut_manager_set_user_dir(
        self_: *mut DzlShortcutManager,
        user_dir: *const c_char,
    );

    //=========================================================================
    // DzlShortcutModel
    //=========================================================================
    pub fn dzl_shortcut_model_get_type() -> GType;
    pub fn dzl_shortcut_model_new() -> *mut gtk::GtkTreeModel;
    pub fn dzl_shortcut_model_get_manager(self_: *mut DzlShortcutModel) -> *mut DzlShortcutManager;
    pub fn dzl_shortcut_model_get_theme(self_: *mut DzlShortcutModel) -> *mut DzlShortcutTheme;
    pub fn dzl_shortcut_model_rebuild(self_: *mut DzlShortcutModel);
    pub fn dzl_shortcut_model_set_chord(
        self_: *mut DzlShortcutModel,
        iter: *mut gtk::GtkTreeIter,
        chord: *const DzlShortcutChord,
    );
    pub fn dzl_shortcut_model_set_manager(
        self_: *mut DzlShortcutModel,
        manager: *mut DzlShortcutManager,
    );
    pub fn dzl_shortcut_model_set_theme(self_: *mut DzlShortcutModel, theme: *mut DzlShortcutTheme);

    //=========================================================================
    // DzlShortcutSimpleLabel
    //=========================================================================
    pub fn dzl_shortcut_simple_label_get_type() -> GType;
    pub fn dzl_shortcut_simple_label_new() -> *mut gtk::GtkWidget;
    pub fn dzl_shortcut_simple_label_get_accel(self_: *mut DzlShortcutSimpleLabel)
        -> *const c_char;
    pub fn dzl_shortcut_simple_label_get_action(
        self_: *mut DzlShortcutSimpleLabel,
    ) -> *const c_char;
    pub fn dzl_shortcut_simple_label_get_command(
        self_: *mut DzlShortcutSimpleLabel,
    ) -> *const c_char;
    pub fn dzl_shortcut_simple_label_get_title(self_: *mut DzlShortcutSimpleLabel)
        -> *const c_char;
    pub fn dzl_shortcut_simple_label_set_accel(
        self_: *mut DzlShortcutSimpleLabel,
        accel: *const c_char,
    );
    pub fn dzl_shortcut_simple_label_set_action(
        self_: *mut DzlShortcutSimpleLabel,
        action: *const c_char,
    );
    pub fn dzl_shortcut_simple_label_set_command(
        self_: *mut DzlShortcutSimpleLabel,
        command: *const c_char,
    );
    pub fn dzl_shortcut_simple_label_set_title(
        self_: *mut DzlShortcutSimpleLabel,
        title: *const c_char,
    );

    //=========================================================================
    // DzlShortcutTheme
    //=========================================================================
    pub fn dzl_shortcut_theme_get_type() -> GType;
    pub fn dzl_shortcut_theme_new(name: *const c_char) -> *mut DzlShortcutTheme;
    pub fn dzl_shortcut_theme_add_command(
        self_: *mut DzlShortcutTheme,
        accelerator: *const c_char,
        command: *const c_char,
    );
    pub fn dzl_shortcut_theme_add_context(
        self_: *mut DzlShortcutTheme,
        context: *mut DzlShortcutContext,
    );
    pub fn dzl_shortcut_theme_add_css_resource(self_: *mut DzlShortcutTheme, path: *const c_char);
    pub fn dzl_shortcut_theme_find_context_by_name(
        self_: *mut DzlShortcutTheme,
        name: *const c_char,
    ) -> *mut DzlShortcutContext;
    pub fn dzl_shortcut_theme_find_default_context(
        self_: *mut DzlShortcutTheme,
        widget: *mut gtk::GtkWidget,
    ) -> *mut DzlShortcutContext;
    pub fn dzl_shortcut_theme_get_chord_for_action(
        self_: *mut DzlShortcutTheme,
        detailed_action_name: *const c_char,
    ) -> *const DzlShortcutChord;
    pub fn dzl_shortcut_theme_get_chord_for_command(
        self_: *mut DzlShortcutTheme,
        command: *const c_char,
    ) -> *const DzlShortcutChord;
    pub fn dzl_shortcut_theme_get_name(self_: *mut DzlShortcutTheme) -> *const c_char;
    pub fn dzl_shortcut_theme_get_parent(self_: *mut DzlShortcutTheme) -> *mut DzlShortcutTheme;
    pub fn dzl_shortcut_theme_get_parent_name(self_: *mut DzlShortcutTheme) -> *const c_char;
    pub fn dzl_shortcut_theme_get_subtitle(self_: *mut DzlShortcutTheme) -> *const c_char;
    pub fn dzl_shortcut_theme_get_title(self_: *mut DzlShortcutTheme) -> *const c_char;
    pub fn dzl_shortcut_theme_load_from_data(
        self_: *mut DzlShortcutTheme,
        data: *const c_char,
        len: ssize_t,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_shortcut_theme_load_from_file(
        self_: *mut DzlShortcutTheme,
        file: *mut gio::GFile,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_shortcut_theme_load_from_path(
        self_: *mut DzlShortcutTheme,
        path: *const c_char,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_shortcut_theme_remove_css_resource(
        self_: *mut DzlShortcutTheme,
        path: *const c_char,
    );
    pub fn dzl_shortcut_theme_save_to_file(
        self_: *mut DzlShortcutTheme,
        file: *mut gio::GFile,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_shortcut_theme_save_to_path(
        self_: *mut DzlShortcutTheme,
        path: *const c_char,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_shortcut_theme_save_to_stream(
        self_: *mut DzlShortcutTheme,
        stream: *mut gio::GOutputStream,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn dzl_shortcut_theme_set_accel_for_action(
        self_: *mut DzlShortcutTheme,
        detailed_action_name: *const c_char,
        accel: *const c_char,
        phase: DzlShortcutPhase,
    );
    pub fn dzl_shortcut_theme_set_accel_for_command(
        self_: *mut DzlShortcutTheme,
        command: *const c_char,
        accel: *const c_char,
        phase: DzlShortcutPhase,
    );
    pub fn dzl_shortcut_theme_set_chord_for_action(
        self_: *mut DzlShortcutTheme,
        detailed_action_name: *const c_char,
        chord: *const DzlShortcutChord,
        phase: DzlShortcutPhase,
    );
    pub fn dzl_shortcut_theme_set_chord_for_command(
        self_: *mut DzlShortcutTheme,
        command: *const c_char,
        chord: *const DzlShortcutChord,
        phase: DzlShortcutPhase,
    );
    pub fn dzl_shortcut_theme_set_parent_name(
        self_: *mut DzlShortcutTheme,
        parent_name: *const c_char,
    );

    //=========================================================================
    // DzlShortcutThemeEditor
    //=========================================================================
    pub fn dzl_shortcut_theme_editor_get_type() -> GType;
    pub fn dzl_shortcut_theme_editor_new() -> *mut gtk::GtkWidget;
    pub fn dzl_shortcut_theme_editor_get_theme(
        self_: *mut DzlShortcutThemeEditor,
    ) -> *mut DzlShortcutTheme;
    pub fn dzl_shortcut_theme_editor_set_theme(
        self_: *mut DzlShortcutThemeEditor,
        theme: *mut DzlShortcutTheme,
    );

    //=========================================================================
    // DzlShortcutTooltip
    //=========================================================================
    pub fn dzl_shortcut_tooltip_get_type() -> GType;
    #[cfg(feature = "v3_32")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_32")))]
    pub fn dzl_shortcut_tooltip_new() -> *mut DzlShortcutTooltip;
    #[cfg(feature = "v3_32")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_32")))]
    pub fn dzl_shortcut_tooltip_get_accel(self_: *mut DzlShortcutTooltip) -> *const c_char;
    #[cfg(feature = "v3_32")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_32")))]
    pub fn dzl_shortcut_tooltip_get_command_id(self_: *mut DzlShortcutTooltip) -> *const c_char;
    #[cfg(feature = "v3_32")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_32")))]
    pub fn dzl_shortcut_tooltip_get_title(self_: *mut DzlShortcutTooltip) -> *const c_char;
    #[cfg(feature = "v3_32")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_32")))]
    pub fn dzl_shortcut_tooltip_get_widget(self_: *mut DzlShortcutTooltip) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v3_32")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_32")))]
    pub fn dzl_shortcut_tooltip_set_accel(self_: *mut DzlShortcutTooltip, accel: *const c_char);
    #[cfg(feature = "v3_32")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_32")))]
    pub fn dzl_shortcut_tooltip_set_command_id(
        self_: *mut DzlShortcutTooltip,
        command_id: *const c_char,
    );
    #[cfg(feature = "v3_32")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_32")))]
    pub fn dzl_shortcut_tooltip_set_title(self_: *mut DzlShortcutTooltip, title: *const c_char);
    #[cfg(feature = "v3_32")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_32")))]
    pub fn dzl_shortcut_tooltip_set_widget(
        self_: *mut DzlShortcutTooltip,
        widget: *mut gtk::GtkWidget,
    );

    //=========================================================================
    // DzlShortcutsGroup
    //=========================================================================
    pub fn dzl_shortcuts_group_get_type() -> GType;

    //=========================================================================
    // DzlShortcutsSection
    //=========================================================================
    pub fn dzl_shortcuts_section_get_type() -> GType;

    //=========================================================================
    // DzlShortcutsShortcut
    //=========================================================================
    pub fn dzl_shortcuts_shortcut_get_type() -> GType;

    //=========================================================================
    // DzlShortcutsWindow
    //=========================================================================
    pub fn dzl_shortcuts_window_get_type() -> GType;

    //=========================================================================
    // DzlSignalGroup
    //=========================================================================
    pub fn dzl_signal_group_get_type() -> GType;
    pub fn dzl_signal_group_new(target_type: GType) -> *mut DzlSignalGroup;
    pub fn dzl_signal_group_block(self_: *mut DzlSignalGroup);
    pub fn dzl_signal_group_connect(
        self_: *mut DzlSignalGroup,
        detailed_signal: *const c_char,
        c_handler: gobject::GCallback,
        data: gpointer,
    );
    pub fn dzl_signal_group_connect_after(
        self_: *mut DzlSignalGroup,
        detailed_signal: *const c_char,
        c_handler: gobject::GCallback,
        data: gpointer,
    );
    pub fn dzl_signal_group_connect_data(
        self_: *mut DzlSignalGroup,
        detailed_signal: *const c_char,
        c_handler: gobject::GCallback,
        data: gpointer,
        notify: gobject::GClosureNotify,
        flags: gobject::GConnectFlags,
    );
    pub fn dzl_signal_group_connect_object(
        self_: *mut DzlSignalGroup,
        detailed_signal: *const c_char,
        c_handler: gobject::GCallback,
        object: gpointer,
        flags: gobject::GConnectFlags,
    );
    pub fn dzl_signal_group_connect_swapped(
        self_: *mut DzlSignalGroup,
        detailed_signal: *const c_char,
        c_handler: gobject::GCallback,
        data: gpointer,
    );
    pub fn dzl_signal_group_get_target(self_: *mut DzlSignalGroup) -> *mut gobject::GObject;
    pub fn dzl_signal_group_set_target(self_: *mut DzlSignalGroup, target: *mut gobject::GObject);
    pub fn dzl_signal_group_unblock(self_: *mut DzlSignalGroup);

    //=========================================================================
    // DzlSimpleLabel
    //=========================================================================
    pub fn dzl_simple_label_get_type() -> GType;
    pub fn dzl_simple_label_new(label: *const c_char) -> *mut gtk::GtkWidget;
    pub fn dzl_simple_label_get_label(self_: *mut DzlSimpleLabel) -> *const c_char;
    pub fn dzl_simple_label_get_width_chars(self_: *mut DzlSimpleLabel) -> c_int;
    pub fn dzl_simple_label_get_xalign(self_: *mut DzlSimpleLabel) -> c_float;
    pub fn dzl_simple_label_set_label(self_: *mut DzlSimpleLabel, label: *const c_char);
    pub fn dzl_simple_label_set_width_chars(self_: *mut DzlSimpleLabel, width_chars: c_int);
    pub fn dzl_simple_label_set_xalign(self_: *mut DzlSimpleLabel, xalign: c_float);

    //=========================================================================
    // DzlSimplePopover
    //=========================================================================
    pub fn dzl_simple_popover_get_type() -> GType;
    pub fn dzl_simple_popover_new() -> *mut gtk::GtkWidget;
    pub fn dzl_simple_popover_get_button_text(self_: *mut DzlSimplePopover) -> *const c_char;
    pub fn dzl_simple_popover_get_message(self_: *mut DzlSimplePopover) -> *const c_char;
    pub fn dzl_simple_popover_get_ready(self_: *mut DzlSimplePopover) -> gboolean;
    pub fn dzl_simple_popover_get_text(self_: *mut DzlSimplePopover) -> *const c_char;
    pub fn dzl_simple_popover_get_title(self_: *mut DzlSimplePopover) -> *const c_char;
    pub fn dzl_simple_popover_set_button_text(
        self_: *mut DzlSimplePopover,
        button_text: *const c_char,
    );
    pub fn dzl_simple_popover_set_message(self_: *mut DzlSimplePopover, message: *const c_char);
    pub fn dzl_simple_popover_set_ready(self_: *mut DzlSimplePopover, ready: gboolean);
    pub fn dzl_simple_popover_set_text(self_: *mut DzlSimplePopover, text: *const c_char);
    pub fn dzl_simple_popover_set_title(self_: *mut DzlSimplePopover, title: *const c_char);

    //=========================================================================
    // DzlSlider
    //=========================================================================
    pub fn dzl_slider_get_type() -> GType;
    pub fn dzl_slider_new() -> *mut gtk::GtkWidget;
    pub fn dzl_slider_add_slider(
        self_: *mut DzlSlider,
        widget: *mut gtk::GtkWidget,
        position: DzlSliderPosition,
    );
    pub fn dzl_slider_get_position(self_: *mut DzlSlider) -> DzlSliderPosition;
    pub fn dzl_slider_set_position(self_: *mut DzlSlider, position: DzlSliderPosition);

    //=========================================================================
    // DzlStackList
    //=========================================================================
    pub fn dzl_stack_list_get_type() -> GType;
    pub fn dzl_stack_list_new() -> *mut gtk::GtkWidget;
    pub fn dzl_stack_list_clear(self_: *mut DzlStackList);
    pub fn dzl_stack_list_get_depth(self_: *mut DzlStackList) -> c_uint;
    pub fn dzl_stack_list_get_model(self_: *mut DzlStackList) -> *mut gio::GListModel;
    pub fn dzl_stack_list_pop(self_: *mut DzlStackList);
    pub fn dzl_stack_list_push(
        self_: *mut DzlStackList,
        header: *mut gtk::GtkWidget,
        model: *mut gio::GListModel,
        create_widget_func: DzlStackListCreateWidgetFunc,
        user_data: gpointer,
        user_data_free_func: glib::GDestroyNotify,
    );

    //=========================================================================
    // DzlStateMachine
    //=========================================================================
    pub fn dzl_state_machine_get_type() -> GType;
    pub fn dzl_state_machine_new() -> *mut DzlStateMachine;
    pub fn dzl_state_machine_buildable_iface_init(iface: *mut gtk::GtkBuildableIface);
    pub fn dzl_state_machine_add_binding(
        self_: *mut DzlStateMachine,
        state: *const c_char,
        source_object: gpointer,
        source_property: *const c_char,
        target_object: gpointer,
        target_property: *const c_char,
        flags: gobject::GBindingFlags,
    );
    pub fn dzl_state_machine_add_property(
        self_: *mut DzlStateMachine,
        state: *const c_char,
        object: gpointer,
        property: *const c_char,
        ...
    );
    //pub fn dzl_state_machine_add_property_valist(self_: *mut DzlStateMachine, state: *const c_char, object: gpointer, property: *const c_char, var_args: /*Unimplemented*/va_list);
    pub fn dzl_state_machine_add_propertyv(
        self_: *mut DzlStateMachine,
        state: *const c_char,
        object: gpointer,
        property: *const c_char,
        value: *const gobject::GValue,
    );
    pub fn dzl_state_machine_add_style(
        self_: *mut DzlStateMachine,
        state: *const c_char,
        widget: *mut gtk::GtkWidget,
        style: *const c_char,
    );
    pub fn dzl_state_machine_connect_object(
        self_: *mut DzlStateMachine,
        state: *const c_char,
        source: gpointer,
        detailed_signal: *const c_char,
        callback: gobject::GCallback,
        user_data: gpointer,
        flags: gobject::GConnectFlags,
    );
    pub fn dzl_state_machine_create_action(
        self_: *mut DzlStateMachine,
        name: *const c_char,
    ) -> *mut gio::GAction;
    pub fn dzl_state_machine_get_state(self_: *mut DzlStateMachine) -> *const c_char;
    #[cfg(feature = "v3_28")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_28")))]
    pub fn dzl_state_machine_is_state(
        self_: *mut DzlStateMachine,
        state: *const c_char,
    ) -> gboolean;
    pub fn dzl_state_machine_set_state(self_: *mut DzlStateMachine, state: *const c_char);

    //=========================================================================
    // DzlSuggestion
    //=========================================================================
    pub fn dzl_suggestion_get_type() -> GType;
    pub fn dzl_suggestion_new() -> *mut DzlSuggestion;
    #[cfg(feature = "v3_30")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_30")))]
    pub fn dzl_suggestion_get_icon(self_: *mut DzlSuggestion) -> *mut gio::GIcon;
    pub fn dzl_suggestion_get_icon_name(self_: *mut DzlSuggestion) -> *const c_char;
    #[cfg(feature = "v3_30")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_30")))]
    pub fn dzl_suggestion_get_icon_surface(
        self_: *mut DzlSuggestion,
        widget: *mut gtk::GtkWidget,
    ) -> *mut cairo::cairo_surface_t;
    pub fn dzl_suggestion_get_id(self_: *mut DzlSuggestion) -> *const c_char;
    #[cfg(feature = "v3_36")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_36")))]
    pub fn dzl_suggestion_get_secondary_icon(self_: *mut DzlSuggestion) -> *mut gio::GIcon;
    pub fn dzl_suggestion_get_secondary_icon_name(self_: *mut DzlSuggestion) -> *const c_char;
    #[cfg(feature = "v3_36")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_36")))]
    pub fn dzl_suggestion_get_secondary_icon_surface(
        self_: *mut DzlSuggestion,
        widget: *mut gtk::GtkWidget,
    ) -> *mut cairo::cairo_surface_t;
    pub fn dzl_suggestion_get_subtitle(self_: *mut DzlSuggestion) -> *const c_char;
    pub fn dzl_suggestion_get_title(self_: *mut DzlSuggestion) -> *const c_char;
    pub fn dzl_suggestion_replace_typed_text(
        self_: *mut DzlSuggestion,
        typed_text: *const c_char,
    ) -> *mut c_char;
    pub fn dzl_suggestion_set_icon_name(self_: *mut DzlSuggestion, icon_name: *const c_char);
    pub fn dzl_suggestion_set_id(self_: *mut DzlSuggestion, id: *const c_char);
    pub fn dzl_suggestion_set_secondary_icon_name(
        self_: *mut DzlSuggestion,
        icon_name: *const c_char,
    );
    pub fn dzl_suggestion_set_subtitle(self_: *mut DzlSuggestion, subtitle: *const c_char);
    pub fn dzl_suggestion_set_title(self_: *mut DzlSuggestion, title: *const c_char);
    pub fn dzl_suggestion_suggest_suffix(
        self_: *mut DzlSuggestion,
        typed_text: *const c_char,
    ) -> *mut c_char;

    //=========================================================================
    // DzlSuggestionButton
    //=========================================================================
    pub fn dzl_suggestion_button_get_type() -> GType;
    pub fn dzl_suggestion_button_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v3_34")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_34")))]
    pub fn dzl_suggestion_button_get_button(self_: *mut DzlSuggestionButton)
        -> *mut gtk::GtkButton;
    #[cfg(feature = "v3_34")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_34")))]
    pub fn dzl_suggestion_button_get_entry(
        self_: *mut DzlSuggestionButton,
    ) -> *mut DzlSuggestionEntry;

    //=========================================================================
    // DzlSuggestionEntry
    //=========================================================================
    pub fn dzl_suggestion_entry_get_type() -> GType;
    pub fn dzl_suggestion_entry_new() -> *mut gtk::GtkWidget;
    pub fn dzl_suggestion_entry_default_position_func(
        self_: *mut DzlSuggestionEntry,
        area: *mut gdk::GdkRectangle,
        is_absolute: *mut gboolean,
        user_data: gpointer,
    );
    pub fn dzl_suggestion_entry_get_activate_on_single_click(
        self_: *mut DzlSuggestionEntry,
    ) -> gboolean;
    #[cfg(feature = "v3_34")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_34")))]
    pub fn dzl_suggestion_entry_get_compact(self_: *mut DzlSuggestionEntry) -> gboolean;
    pub fn dzl_suggestion_entry_get_model(self_: *mut DzlSuggestionEntry) -> *mut gio::GListModel;
    #[cfg(feature = "v3_32")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_32")))]
    pub fn dzl_suggestion_entry_get_popover(self_: *mut DzlSuggestionEntry) -> *mut gtk::GtkWidget;
    pub fn dzl_suggestion_entry_get_suggestion(
        self_: *mut DzlSuggestionEntry,
    ) -> *mut DzlSuggestion;
    pub fn dzl_suggestion_entry_get_typed_text(self_: *mut DzlSuggestionEntry) -> *const c_char;
    pub fn dzl_suggestion_entry_hide_suggestions(self_: *mut DzlSuggestionEntry);
    pub fn dzl_suggestion_entry_set_activate_on_single_click(
        self_: *mut DzlSuggestionEntry,
        activate_on_single_click: gboolean,
    );
    #[cfg(feature = "v3_34")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_34")))]
    pub fn dzl_suggestion_entry_set_compact(self_: *mut DzlSuggestionEntry, compact: gboolean);
    pub fn dzl_suggestion_entry_set_model(
        self_: *mut DzlSuggestionEntry,
        model: *mut gio::GListModel,
    );
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_suggestion_entry_set_position_func(
        self_: *mut DzlSuggestionEntry,
        func: DzlSuggestionPositionFunc,
        func_data: gpointer,
        func_data_destroy: glib::GDestroyNotify,
    );
    pub fn dzl_suggestion_entry_set_suggestion(
        self_: *mut DzlSuggestionEntry,
        suggestion: *mut DzlSuggestion,
    );
    pub fn dzl_suggestion_entry_window_position_func(
        self_: *mut DzlSuggestionEntry,
        area: *mut gdk::GdkRectangle,
        is_absolute: *mut gboolean,
        user_data: gpointer,
    );

    //=========================================================================
    // DzlSuggestionEntryBuffer
    //=========================================================================
    pub fn dzl_suggestion_entry_buffer_get_type() -> GType;
    pub fn dzl_suggestion_entry_buffer_new() -> *mut DzlSuggestionEntryBuffer;
    pub fn dzl_suggestion_entry_buffer_clear(self_: *mut DzlSuggestionEntryBuffer);
    pub fn dzl_suggestion_entry_buffer_commit(self_: *mut DzlSuggestionEntryBuffer);
    pub fn dzl_suggestion_entry_buffer_get_suggestion(
        self_: *mut DzlSuggestionEntryBuffer,
    ) -> *mut DzlSuggestion;
    pub fn dzl_suggestion_entry_buffer_get_typed_length(
        self_: *mut DzlSuggestionEntryBuffer,
    ) -> c_uint;
    pub fn dzl_suggestion_entry_buffer_get_typed_text(
        self_: *mut DzlSuggestionEntryBuffer,
    ) -> *const c_char;
    pub fn dzl_suggestion_entry_buffer_set_suggestion(
        self_: *mut DzlSuggestionEntryBuffer,
        suggestion: *mut DzlSuggestion,
    );

    //=========================================================================
    // DzlSuggestionPopover
    //=========================================================================
    pub fn dzl_suggestion_popover_get_type() -> GType;
    pub fn dzl_suggestion_popover_new() -> *mut gtk::GtkWidget;
    pub fn dzl_suggestion_popover_activate_selected(self_: *mut DzlSuggestionPopover);
    pub fn dzl_suggestion_popover_get_model(
        self_: *mut DzlSuggestionPopover,
    ) -> *mut gio::GListModel;
    pub fn dzl_suggestion_popover_get_relative_to(
        self_: *mut DzlSuggestionPopover,
    ) -> *mut gtk::GtkWidget;
    pub fn dzl_suggestion_popover_get_selected(
        self_: *mut DzlSuggestionPopover,
    ) -> *mut DzlSuggestion;
    pub fn dzl_suggestion_popover_move_by(self_: *mut DzlSuggestionPopover, amount: c_int);
    pub fn dzl_suggestion_popover_popdown(self_: *mut DzlSuggestionPopover);
    pub fn dzl_suggestion_popover_popup(self_: *mut DzlSuggestionPopover);
    pub fn dzl_suggestion_popover_set_model(
        self_: *mut DzlSuggestionPopover,
        model: *mut gio::GListModel,
    );
    pub fn dzl_suggestion_popover_set_relative_to(
        self_: *mut DzlSuggestionPopover,
        widget: *mut gtk::GtkWidget,
    );
    pub fn dzl_suggestion_popover_set_selected(
        self_: *mut DzlSuggestionPopover,
        suggestion: *mut DzlSuggestion,
    );

    //=========================================================================
    // DzlSuggestionRow
    //=========================================================================
    pub fn dzl_suggestion_row_get_type() -> GType;
    pub fn dzl_suggestion_row_new() -> *mut gtk::GtkWidget;
    pub fn dzl_suggestion_row_get_suggestion(self_: *mut DzlSuggestionRow) -> *mut DzlSuggestion;
    pub fn dzl_suggestion_row_set_suggestion(
        self_: *mut DzlSuggestionRow,
        suggestion: *mut DzlSuggestion,
    );

    //=========================================================================
    // DzlTab
    //=========================================================================
    pub fn dzl_tab_get_type() -> GType;
    pub fn dzl_tab_get_active(self_: *mut DzlTab) -> gboolean;
    pub fn dzl_tab_get_can_close(self_: *mut DzlTab) -> gboolean;
    pub fn dzl_tab_get_edge(self_: *mut DzlTab) -> gtk::GtkPositionType;
    pub fn dzl_tab_get_icon_name(self_: *mut DzlTab) -> *const c_char;
    pub fn dzl_tab_get_style(self_: *mut DzlTab) -> DzlTabStyle;
    pub fn dzl_tab_get_title(self_: *mut DzlTab) -> *const c_char;
    pub fn dzl_tab_get_widget(self_: *mut DzlTab) -> *mut gtk::GtkWidget;
    pub fn dzl_tab_set_active(self_: *mut DzlTab, active: gboolean);
    pub fn dzl_tab_set_can_close(self_: *mut DzlTab, can_close: gboolean);
    pub fn dzl_tab_set_edge(self_: *mut DzlTab, edge: gtk::GtkPositionType);
    pub fn dzl_tab_set_gicon(self_: *mut DzlTab, gicon: *mut gio::GIcon);
    pub fn dzl_tab_set_icon_name(self_: *mut DzlTab, icon_name: *const c_char);
    pub fn dzl_tab_set_style(self_: *mut DzlTab, style: DzlTabStyle);
    pub fn dzl_tab_set_title(self_: *mut DzlTab, title: *const c_char);
    pub fn dzl_tab_set_widget(self_: *mut DzlTab, widget: *mut gtk::GtkWidget);

    //=========================================================================
    // DzlTabStrip
    //=========================================================================
    pub fn dzl_tab_strip_get_type() -> GType;
    pub fn dzl_tab_strip_new() -> *mut gtk::GtkWidget;
    pub fn dzl_tab_strip_add_control(self_: *mut DzlTabStrip, widget: *mut gtk::GtkWidget);
    pub fn dzl_tab_strip_get_edge(self_: *mut DzlTabStrip) -> gtk::GtkPositionType;
    pub fn dzl_tab_strip_get_stack(self_: *mut DzlTabStrip) -> *mut gtk::GtkStack;
    pub fn dzl_tab_strip_get_style(self_: *mut DzlTabStrip) -> DzlTabStyle;
    pub fn dzl_tab_strip_set_edge(self_: *mut DzlTabStrip, edge: gtk::GtkPositionType);
    pub fn dzl_tab_strip_set_stack(self_: *mut DzlTabStrip, stack: *mut gtk::GtkStack);
    pub fn dzl_tab_strip_set_style(self_: *mut DzlTabStrip, style: DzlTabStyle);

    //=========================================================================
    // DzlTaskCache
    //=========================================================================
    pub fn dzl_task_cache_get_type() -> GType;
    pub fn dzl_task_cache_new(
        key_hash_func: glib::GHashFunc,
        key_equal_func: glib::GEqualFunc,
        key_copy_func: gobject::GBoxedCopyFunc,
        key_destroy_func: gobject::GBoxedFreeFunc,
        value_copy_func: gobject::GBoxedCopyFunc,
        value_free_func: gobject::GBoxedFreeFunc,
        time_to_live_msec: i64,
        populate_callback: DzlTaskCacheCallback,
        populate_callback_data: gpointer,
        populate_callback_data_destroy: glib::GDestroyNotify,
    ) -> *mut DzlTaskCache;
    pub fn dzl_task_cache_evict(self_: *mut DzlTaskCache, key: gconstpointer) -> gboolean;
    pub fn dzl_task_cache_evict_all(self_: *mut DzlTaskCache);
    pub fn dzl_task_cache_get_async(
        self_: *mut DzlTaskCache,
        key: gconstpointer,
        force_update: gboolean,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn dzl_task_cache_get_finish(
        self_: *mut DzlTaskCache,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gpointer;
    pub fn dzl_task_cache_get_values(self_: *mut DzlTaskCache) -> *mut glib::GPtrArray;
    pub fn dzl_task_cache_peek(
        self_: *mut DzlTaskCache,
        key: gconstpointer,
    ) -> *mut gobject::GObject;
    pub fn dzl_task_cache_set_name(self_: *mut DzlTaskCache, name: *const c_char);

    //=========================================================================
    // DzlThemeManager
    //=========================================================================
    pub fn dzl_theme_manager_get_type() -> GType;
    pub fn dzl_theme_manager_new() -> *mut DzlThemeManager;
    pub fn dzl_theme_manager_add_resources(
        self_: *mut DzlThemeManager,
        resource_path: *const c_char,
    );
    pub fn dzl_theme_manager_remove_resources(
        self_: *mut DzlThemeManager,
        resource_path: *const c_char,
    );

    //=========================================================================
    // DzlThreeGrid
    //=========================================================================
    pub fn dzl_three_grid_get_type() -> GType;
    pub fn dzl_three_grid_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // DzlTree
    //=========================================================================
    pub fn dzl_tree_get_type() -> GType;
    pub fn dzl_tree_add_builder(self_: *mut DzlTree, builder: *mut DzlTreeBuilder);
    pub fn dzl_tree_expand_to_node(self_: *mut DzlTree, node: *mut DzlTreeNode);
    pub fn dzl_tree_find_child_node(
        self_: *mut DzlTree,
        node: *mut DzlTreeNode,
        find_func: DzlTreeFindFunc,
        user_data: gpointer,
    ) -> *mut DzlTreeNode;
    pub fn dzl_tree_find_custom(
        self_: *mut DzlTree,
        equal_func: glib::GEqualFunc,
        key: gpointer,
    ) -> *mut DzlTreeNode;
    pub fn dzl_tree_find_item(self_: *mut DzlTree, item: *mut gobject::GObject)
        -> *mut DzlTreeNode;
    pub fn dzl_tree_get_context_menu(self_: *mut DzlTree) -> *mut gio::GMenuModel;
    pub fn dzl_tree_get_root(self_: *mut DzlTree) -> *mut DzlTreeNode;
    pub fn dzl_tree_get_selected(self_: *mut DzlTree) -> *mut DzlTreeNode;
    pub fn dzl_tree_get_show_icons(self_: *mut DzlTree) -> gboolean;
    pub fn dzl_tree_rebuild(self_: *mut DzlTree);
    pub fn dzl_tree_remove_builder(self_: *mut DzlTree, builder: *mut DzlTreeBuilder);
    pub fn dzl_tree_scroll_to_node(self_: *mut DzlTree, node: *mut DzlTreeNode);
    pub fn dzl_tree_set_context_menu(self_: *mut DzlTree, context_menu: *mut gio::GMenuModel);
    pub fn dzl_tree_set_filter(
        self_: *mut DzlTree,
        filter_func: DzlTreeFilterFunc,
        filter_data: gpointer,
        filter_data_destroy: glib::GDestroyNotify,
    );
    pub fn dzl_tree_set_root(self_: *mut DzlTree, node: *mut DzlTreeNode);
    pub fn dzl_tree_set_show_icons(self_: *mut DzlTree, show_icons: gboolean);
    pub fn dzl_tree_unselect_all(self_: *mut DzlTree);

    //=========================================================================
    // DzlTreeBuilder
    //=========================================================================
    pub fn dzl_tree_builder_get_type() -> GType;
    pub fn dzl_tree_builder_new() -> *mut DzlTreeBuilder;
    pub fn dzl_tree_builder_get_tree(builder: *mut DzlTreeBuilder) -> *mut DzlTree;

    //=========================================================================
    // DzlTreeNode
    //=========================================================================
    pub fn dzl_tree_node_get_type() -> GType;
    pub fn dzl_tree_node_new() -> *mut DzlTreeNode;
    pub fn dzl_tree_node_add_emblem(self_: *mut DzlTreeNode, emblem_name: *const c_char);
    pub fn dzl_tree_node_append(node: *mut DzlTreeNode, child: *mut DzlTreeNode);
    pub fn dzl_tree_node_clear_emblems(self_: *mut DzlTreeNode);
    pub fn dzl_tree_node_collapse(node: *mut DzlTreeNode);
    pub fn dzl_tree_node_expand(node: *mut DzlTreeNode, expand_ancestors: gboolean) -> gboolean;
    pub fn dzl_tree_node_get_area(node: *mut DzlTreeNode, area: *mut gdk::GdkRectangle);
    pub fn dzl_tree_node_get_children_possible(self_: *mut DzlTreeNode) -> gboolean;
    pub fn dzl_tree_node_get_expanded(node: *mut DzlTreeNode) -> gboolean;
    #[cfg(feature = "v3_28")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_28")))]
    pub fn dzl_tree_node_get_foreground_rgba(self_: *mut DzlTreeNode) -> *const gdk::GdkRGBA;
    pub fn dzl_tree_node_get_gicon(self_: *mut DzlTreeNode) -> *mut gio::GIcon;
    pub fn dzl_tree_node_get_icon_name(node: *mut DzlTreeNode) -> *const c_char;
    pub fn dzl_tree_node_get_item(node: *mut DzlTreeNode) -> *mut gobject::GObject;
    pub fn dzl_tree_node_get_iter(node: *mut DzlTreeNode, iter: *mut gtk::GtkTreeIter) -> gboolean;
    pub fn dzl_tree_node_get_parent(node: *mut DzlTreeNode) -> *mut DzlTreeNode;
    pub fn dzl_tree_node_get_path(node: *mut DzlTreeNode) -> *mut gtk::GtkTreePath;
    pub fn dzl_tree_node_get_reset_on_collapse(self_: *mut DzlTreeNode) -> gboolean;
    pub fn dzl_tree_node_get_text(node: *mut DzlTreeNode) -> *const c_char;
    pub fn dzl_tree_node_get_tree(node: *mut DzlTreeNode) -> *mut DzlTree;
    pub fn dzl_tree_node_get_use_dim_label(self_: *mut DzlTreeNode) -> gboolean;
    pub fn dzl_tree_node_get_use_markup(self_: *mut DzlTreeNode) -> gboolean;
    pub fn dzl_tree_node_has_emblem(
        self_: *mut DzlTreeNode,
        emblem_name: *const c_char,
    ) -> gboolean;
    #[cfg(feature = "v3_28")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_28")))]
    pub fn dzl_tree_node_insert(self_: *mut DzlTreeNode, child: *mut DzlTreeNode, position: c_uint);
    pub fn dzl_tree_node_insert_sorted(
        node: *mut DzlTreeNode,
        child: *mut DzlTreeNode,
        compare_func: DzlTreeNodeCompareFunc,
        user_data: gpointer,
    );
    pub fn dzl_tree_node_invalidate(node: *mut DzlTreeNode);
    pub fn dzl_tree_node_is_root(node: *mut DzlTreeNode) -> gboolean;
    pub fn dzl_tree_node_n_children(self_: *mut DzlTreeNode) -> c_uint;
    pub fn dzl_tree_node_nth_child(self_: *mut DzlTreeNode, nth: c_uint) -> *mut DzlTreeNode;
    pub fn dzl_tree_node_prepend(node: *mut DzlTreeNode, child: *mut DzlTreeNode);
    #[cfg(feature = "v3_28")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_28")))]
    pub fn dzl_tree_node_rebuild(self_: *mut DzlTreeNode);
    pub fn dzl_tree_node_remove(node: *mut DzlTreeNode, child: *mut DzlTreeNode);
    pub fn dzl_tree_node_remove_emblem(self_: *mut DzlTreeNode, emblem_name: *const c_char);
    pub fn dzl_tree_node_select(node: *mut DzlTreeNode);
    pub fn dzl_tree_node_set_children_possible(
        self_: *mut DzlTreeNode,
        children_possible: gboolean,
    );
    pub fn dzl_tree_node_set_emblems(self_: *mut DzlTreeNode, emblems: *const *const c_char);
    #[cfg(feature = "v3_28")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_28")))]
    pub fn dzl_tree_node_set_foreground_rgba(
        self_: *mut DzlTreeNode,
        foreground_rgba: *const gdk::GdkRGBA,
    );
    pub fn dzl_tree_node_set_gicon(self_: *mut DzlTreeNode, icon: *mut gio::GIcon);
    pub fn dzl_tree_node_set_icon_name(node: *mut DzlTreeNode, icon_name: *const c_char);
    pub fn dzl_tree_node_set_item(node: *mut DzlTreeNode, item: *mut gobject::GObject);
    pub fn dzl_tree_node_set_reset_on_collapse(
        self_: *mut DzlTreeNode,
        reset_on_collapse: gboolean,
    );
    pub fn dzl_tree_node_set_text(node: *mut DzlTreeNode, text: *const c_char);
    pub fn dzl_tree_node_set_use_dim_label(self_: *mut DzlTreeNode, use_dim_label: gboolean);
    pub fn dzl_tree_node_set_use_markup(self_: *mut DzlTreeNode, use_markup: gboolean);
    pub fn dzl_tree_node_show_popover(node: *mut DzlTreeNode, popover: *mut gtk::GtkPopover);

    //=========================================================================
    // DzlWidgetActionGroup
    //=========================================================================
    pub fn dzl_widget_action_group_get_type() -> GType;
    pub fn dzl_widget_action_group_attach(widget: *mut gtk::GtkWidget, group_name: *const c_char);
    pub fn dzl_widget_action_group_new(widget: *mut gtk::GtkWidget) -> *mut gio::GActionGroup;
    pub fn dzl_widget_action_group_set_action_enabled(
        self_: *mut DzlWidgetActionGroup,
        action_name: *const c_char,
        enabled: gboolean,
    );

    //=========================================================================
    // DzlDock
    //=========================================================================
    pub fn dzl_dock_get_type() -> GType;

    //=========================================================================
    // DzlDockItem
    //=========================================================================
    pub fn dzl_dock_item_get_type() -> GType;
    pub fn dzl_dock_item_adopt(self_: *mut DzlDockItem, child: *mut DzlDockItem) -> gboolean;
    pub fn dzl_dock_item_close(self_: *mut DzlDockItem) -> gboolean;
    #[cfg(feature = "v3_30")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_30")))]
    pub fn dzl_dock_item_emit_presented(self_: *mut DzlDockItem);
    pub fn dzl_dock_item_get_can_close(self_: *mut DzlDockItem) -> gboolean;
    pub fn dzl_dock_item_get_can_minimize(self_: *mut DzlDockItem) -> gboolean;
    pub fn dzl_dock_item_get_child_visible(
        self_: *mut DzlDockItem,
        child: *mut DzlDockItem,
    ) -> gboolean;
    pub fn dzl_dock_item_get_icon_name(self_: *mut DzlDockItem) -> *mut c_char;
    pub fn dzl_dock_item_get_manager(self_: *mut DzlDockItem) -> *mut DzlDockManager;
    pub fn dzl_dock_item_get_parent(self_: *mut DzlDockItem) -> *mut DzlDockItem;
    pub fn dzl_dock_item_get_title(self_: *mut DzlDockItem) -> *mut c_char;
    pub fn dzl_dock_item_has_widgets(self_: *mut DzlDockItem) -> gboolean;
    pub fn dzl_dock_item_minimize(
        self_: *mut DzlDockItem,
        child: *mut DzlDockItem,
        position: *mut gtk::GtkPositionType,
    ) -> gboolean;
    #[cfg(feature = "v3_34")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_34")))]
    pub fn dzl_dock_item_needs_attention(self_: *mut DzlDockItem);
    pub fn dzl_dock_item_present(self_: *mut DzlDockItem);
    pub fn dzl_dock_item_present_child(self_: *mut DzlDockItem, child: *mut DzlDockItem);
    #[cfg(feature = "v3_34")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_34")))]
    pub fn dzl_dock_item_ref_gicon(self_: *mut DzlDockItem) -> *mut gio::GIcon;
    pub fn dzl_dock_item_release(self_: *mut DzlDockItem, child: *mut DzlDockItem);
    pub fn dzl_dock_item_set_child_visible(
        self_: *mut DzlDockItem,
        child: *mut DzlDockItem,
        child_visible: gboolean,
    );
    pub fn dzl_dock_item_set_manager(self_: *mut DzlDockItem, manager: *mut DzlDockManager);
    pub fn dzl_dock_item_update_visibility(self_: *mut DzlDockItem);

    //=========================================================================
    // DzlGraphRenderer
    //=========================================================================
    pub fn dzl_graph_view_renderer_get_type() -> GType;
    pub fn dzl_graph_view_renderer_render(
        self_: *mut DzlGraphRenderer,
        table: *mut DzlGraphModel,
        x_begin: i64,
        x_end: i64,
        y_begin: c_double,
        y_end: c_double,
        cr: *mut cairo::cairo_t,
        area: *const cairo::cairo_rectangle_int_t,
    );

    //=========================================================================
    // DzlPreferences
    //=========================================================================
    pub fn dzl_preferences_get_type() -> GType;
    pub fn dzl_preferences_add_custom(
        self_: *mut DzlPreferences,
        page_name: *const c_char,
        group_name: *const c_char,
        widget: *mut gtk::GtkWidget,
        keywords: *const c_char,
        priority: c_int,
    ) -> c_uint;
    pub fn dzl_preferences_add_file_chooser(
        self_: *mut DzlPreferences,
        page_name: *const c_char,
        group_name: *const c_char,
        schema_id: *const c_char,
        key: *const c_char,
        path: *const c_char,
        title: *const c_char,
        subtitle: *const c_char,
        action: gtk::GtkFileChooserAction,
        keywords: *const c_char,
        priority: c_int,
    ) -> c_uint;
    pub fn dzl_preferences_add_font_button(
        self_: *mut DzlPreferences,
        page_name: *const c_char,
        group_name: *const c_char,
        schema_id: *const c_char,
        key: *const c_char,
        title: *const c_char,
        keywords: *const c_char,
        priority: c_int,
    ) -> c_uint;
    pub fn dzl_preferences_add_group(
        self_: *mut DzlPreferences,
        page_name: *const c_char,
        group_name: *const c_char,
        title: *const c_char,
        priority: c_int,
    );
    pub fn dzl_preferences_add_list_group(
        self_: *mut DzlPreferences,
        page_name: *const c_char,
        group_name: *const c_char,
        title: *const c_char,
        mode: gtk::GtkSelectionMode,
        priority: c_int,
    );
    pub fn dzl_preferences_add_page(
        self_: *mut DzlPreferences,
        page_name: *const c_char,
        title: *const c_char,
        priority: c_int,
    );
    pub fn dzl_preferences_add_radio(
        self_: *mut DzlPreferences,
        page_name: *const c_char,
        group_name: *const c_char,
        schema_id: *const c_char,
        key: *const c_char,
        path: *const c_char,
        variant_string: *const c_char,
        title: *const c_char,
        subtitle: *const c_char,
        keywords: *const c_char,
        priority: c_int,
    ) -> c_uint;
    pub fn dzl_preferences_add_spin_button(
        self_: *mut DzlPreferences,
        page_name: *const c_char,
        group_name: *const c_char,
        schema_id: *const c_char,
        key: *const c_char,
        path: *const c_char,
        title: *const c_char,
        subtitle: *const c_char,
        keywords: *const c_char,
        priority: c_int,
    ) -> c_uint;
    pub fn dzl_preferences_add_switch(
        self_: *mut DzlPreferences,
        page_name: *const c_char,
        group_name: *const c_char,
        schema_id: *const c_char,
        key: *const c_char,
        path: *const c_char,
        variant_string: *const c_char,
        title: *const c_char,
        subtitle: *const c_char,
        keywords: *const c_char,
        priority: c_int,
    ) -> c_uint;
    pub fn dzl_preferences_add_table_row(
        self_: *mut DzlPreferences,
        page_name: *const c_char,
        group_name: *const c_char,
        first_widget: *mut gtk::GtkWidget,
        ...
    ) -> c_uint;
    pub fn dzl_preferences_get_widget(
        self_: *mut DzlPreferences,
        widget_id: c_uint,
    ) -> *mut gtk::GtkWidget;
    pub fn dzl_preferences_remove_id(self_: *mut DzlPreferences, widget_id: c_uint) -> gboolean;
    pub fn dzl_preferences_set_page(
        self_: *mut DzlPreferences,
        page_name: *const c_char,
        map: *mut glib::GHashTable,
    );

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn dzl_cairo_region_create_from_clip_extents(
        cr: *mut cairo::cairo_t,
    ) -> *mut cairo::cairo_region_t;
    pub fn dzl_cairo_rounded_rectangle(
        cr: *mut cairo::cairo_t,
        rect: *const gdk::GdkRectangle,
        x_radius: c_int,
        y_radius: c_int,
    );
    #[cfg(feature = "v3_28")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_28")))]
    pub fn dzl_cancellable_chain(
        self_: *mut gio::GCancellable,
        other: *mut gio::GCancellable,
    ) -> *mut gio::GCancellable;
    pub fn dzl_dnd_get_uri_list(selection_data: *mut gtk::GtkSelectionData) -> *mut *mut c_char;
    pub fn dzl_file_manager_show(file: *mut gio::GFile, error: *mut *mut glib::GError) -> gboolean;
    pub fn dzl_frame_source_add(
        frames_per_sec: c_uint,
        callback: glib::GSourceFunc,
        user_data: gpointer,
    ) -> c_uint;
    pub fn dzl_frame_source_add_full(
        priority: c_int,
        frames_per_sec: c_uint,
        callback: glib::GSourceFunc,
        user_data: gpointer,
        notify: glib::GDestroyNotify,
    ) -> c_uint;
    pub fn dzl_fuzzy_highlight(
        str: *const c_char,
        query: *const c_char,
        case_sensitive: gboolean,
    ) -> *mut c_char;
    pub fn dzl_g_date_time_format_for_display(self_: *mut glib::GDateTime) -> *mut c_char;
    pub fn dzl_g_time_span_to_label(span: glib::GTimeSpan) -> *mut c_char;
    pub fn dzl_g_time_span_to_label_mapping(
        binding: *mut gobject::GBinding,
        from_value: *const gobject::GValue,
        to_value: *mut gobject::GValue,
        user_data: gpointer,
    ) -> gboolean;
    pub fn dzl_g_variant_hash(data: gconstpointer) -> c_uint;
    pub fn dzl_gdk_synthesize_event_key(
        window: *mut gdk::GdkWindow,
        ch: u32,
    ) -> *mut gdk::GdkEventKey;
    pub fn dzl_gdk_synthesize_event_keyval(
        window: *mut gdk::GdkWindow,
        keyval: c_uint,
    ) -> *mut gdk::GdkEventKey;
    pub fn dzl_get_current_cpu_call() -> c_uint;
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_gtk_list_store_insert_sorted(
        store: *mut gtk::GtkListStore,
        iter: *mut gtk::GtkTreeIter,
        key: gconstpointer,
        compare_column: c_uint,
        compare_func: glib::GCompareDataFunc,
        compare_data: gpointer,
    );
    pub fn dzl_gtk_text_buffer_remove_tag(
        buffer: *mut gtk::GtkTextBuffer,
        tag: *mut gtk::GtkTextTag,
        start: *const gtk::GtkTextIter,
        end: *const gtk::GtkTextIter,
        minimal_damage: gboolean,
    );
    pub fn dzl_gtk_widget_action(
        widget: *mut gtk::GtkWidget,
        group: *const c_char,
        name: *const c_char,
        param: *mut glib::GVariant,
    ) -> gboolean;
    pub fn dzl_gtk_widget_action_set(
        widget: *mut gtk::GtkWidget,
        group: *const c_char,
        name: *const c_char,
        first_property: *const c_char,
        ...
    );
    pub fn dzl_gtk_widget_action_with_string(
        widget: *mut gtk::GtkWidget,
        group: *const c_char,
        name: *const c_char,
        param: *const c_char,
    ) -> gboolean;
    pub fn dzl_gtk_widget_add_style_class(widget: *mut gtk::GtkWidget, class_name: *const c_char);
    pub fn dzl_gtk_widget_find_child_typed(
        widget: *mut gtk::GtkWidget,
        type_: GType,
    ) -> *mut gtk::GtkWidget;
    pub fn dzl_gtk_widget_get_relative(
        widget: *mut gtk::GtkWidget,
        relative_type: GType,
    ) -> *mut gtk::GtkWidget;
    pub fn dzl_gtk_widget_hide_with_fade(widget: *mut gtk::GtkWidget);
    #[cfg(feature = "v3_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_26")))]
    pub fn dzl_gtk_widget_is_ancestor_or_relative(
        widget: *mut gtk::GtkWidget,
        ancestor: *mut gtk::GtkWidget,
    ) -> gboolean;
    pub fn dzl_gtk_widget_mux_action_groups(
        widget: *mut gtk::GtkWidget,
        from_widget: *mut gtk::GtkWidget,
        mux_key: *const c_char,
    );
    pub fn dzl_gtk_widget_remove_style_class(
        widget: *mut gtk::GtkWidget,
        class_name: *const c_char,
    );
    pub fn dzl_gtk_widget_show_with_fade(widget: *mut gtk::GtkWidget);
    pub fn dzl_levenshtein(needle: *const c_char, haystack: *const c_char) -> c_int;
    pub fn dzl_object_animate(
        object: gpointer,
        mode: DzlAnimationMode,
        duration_msec: c_uint,
        frame_clock: *mut gdk::GdkFrameClock,
        first_property: *const c_char,
        ...
    ) -> *mut DzlAnimation;
    pub fn dzl_object_animate_full(
        object: gpointer,
        mode: DzlAnimationMode,
        duration_msec: c_uint,
        frame_clock: *mut gdk::GdkFrameClock,
        notify: glib::GDestroyNotify,
        notify_data: gpointer,
        first_property: *const c_char,
        ...
    ) -> *mut DzlAnimation;
    //pub fn dzl_object_animatev(object: gpointer, mode: DzlAnimationMode, duration_msec: c_uint, frame_clock: *mut gdk::GdkFrameClock, first_property: *const c_char, args: /*Unimplemented*/va_list) -> *mut DzlAnimation;
    pub fn dzl_overlay_add_child(
        self_: *mut DzlDockOverlay,
        child: *mut gtk::GtkWidget,
        type_: *const c_char,
    );
    pub fn dzl_pango_font_description_to_css(
        font_desc: *const pango::PangoFontDescription,
    ) -> *mut c_char;
    pub fn dzl_rgba_shade(rgba: *const gdk::GdkRGBA, dst: *mut gdk::GdkRGBA, k: c_double);
    pub fn dzl_shortcut_chord_table_get_type() -> GType;

}