// This file was generated by gir (https://github.com/gtk-rs/gir @ 60cbef0)
// from gir-files (https://github.com/gtk-rs/gir-files @ 617a344)
// 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)]

extern crate libc;
extern crate cairo_sys as cairo;
extern crate pango_sys as pango;
extern crate glib_sys as glib;
extern crate gobject_sys as gobject;
extern crate gio_sys as gio;
extern crate gtk_sys as gtk;
extern crate gdk_sys as gdk;

#[allow(unused_imports)]
use libc::{c_int, c_char, c_uchar, c_float, c_uint, c_double,
    c_short, c_ushort, c_long, c_ulong,
    c_void, size_t, ssize_t, intptr_t, uintptr_t, time_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 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_COUNTER_REQUIRES_ATOMIC: c_int = 1;
pub const DZL_DOCK_BIN_STYLE_CLASS_PINNED: *const c_char = b"pinned\0" as *const u8 as *const c_char;
pub const DZL_ENABLE_TRACE: c_int = 0;
pub const DZL_LOG_LEVEL_TRACE: glib::GLogLevelFlags = 1;
pub const DZL_MAJOR_VERSION: c_int = 3;
pub const DZL_MICRO_VERSION: c_int = 0;
pub const DZL_MINOR_VERSION: c_int = 36;
pub const DZL_VERSION_S: *const c_char = b"3.36.0\0" as *const u8 as *const c_char;

// 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
#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent", &self.parent)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent", &self.parent)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("values", &self.values)
         .field("category", &self.category)
         .field("name", &self.name)
         .field("description", &self.description)
         .finish()
    }
}

#[repr(C)]
pub struct DzlCounterArena(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
pub struct DzlCounterValue {
    pub value: /*volatile*/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 as *const _))
         .field("padding", &self.padding)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .field("_reserved1", &self._reserved1)
         .field("_reserved2", &self._reserved2)
         .field("_reserved3", &self._reserved3)
         .field("_reserved4", &self._reserved4)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent", &self.parent)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent", &self.parent)
         .field("_reserved1", &self._reserved1)
         .field("_reserved2", &self._reserved2)
         .field("_reserved3", &self._reserved3)
         .field("_reserved4", &self._reserved4)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .field("_reserved1", &self._reserved1)
         .field("_reserved2", &self._reserved2)
         .field("_reserved3", &self._reserved3)
         .field("_reserved4", &self._reserved4)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .field("_reserved1", &self._reserved1)
         .field("_reserved2", &self._reserved2)
         .field("_reserved3", &self._reserved3)
         .field("_reserved4", &self._reserved4)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct DzlFuzzyMutableIndex(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("key", &self.key)
         .field("value", &self.value)
         .field("score", &self.score)
         .field("id", &self.id)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent", &self.parent)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("data", &self.data)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent", &self.parent)
         .field("render", &self.render)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("data", &self.data)
         .field("len", &self.len)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .field("_reserved1", &self._reserved1)
         .field("_reserved2", &self._reserved2)
         .field("_reserved3", &self._reserved3)
         .field("_reserved4", &self._reserved4)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct DzlPatternSpec(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .field("_reserved1", &self._reserved1)
         .field("_reserved2", &self._reserved2)
         .field("_reserved3", &self._reserved3)
         .field("_reserved4", &self._reserved4)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .field("_reserved1", &self._reserved1)
         .field("_reserved2", &self._reserved2)
         .field("_reserved3", &self._reserved3)
         .field("_reserved4", &self._reserved4)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .field("_reserved1", &self._reserved1)
         .field("_reserved2", &self._reserved2)
         .field("_reserved3", &self._reserved3)
         .field("_reserved4", &self._reserved4)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .field("_padding1", &self._padding1)
         .field("_padding2", &self._padding2)
         .field("_padding3", &self._padding3)
         .field("_padding4", &self._padding4)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("data", &self.data)
         .field("len", &self.len)
         .field("pos", &self.pos)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct DzlShortcutChord(c_void);

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

#[repr(C)]
pub struct _DzlShortcutChordTable(c_void);

pub type DzlShortcutChordTable = *mut _DzlShortcutChordTable;

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _DzlShortcutsGroupClass(c_void);

pub type DzlShortcutsGroupClass = *mut _DzlShortcutsGroupClass;

#[repr(C)]
pub struct _DzlShortcutsSectionClass(c_void);

pub type DzlShortcutsSectionClass = *mut _DzlShortcutsSectionClass;

#[repr(C)]
pub struct _DzlShortcutsShortcutClass(c_void);

pub type DzlShortcutsShortcutClass = *mut _DzlShortcutsShortcutClass;

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .field("close", &self.close)
         .field("search", &self.search)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent", &self.parent)
         .field("activate", &self.activate)
         .field("insert_text", &self.insert_text)
         .field("changed", &self.changed)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent", &self.parent)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .field("_reserved1", &self._reserved1)
         .field("_reserved2", &self._reserved2)
         .field("_reserved3", &self._reserved3)
         .field("_reserved4", &self._reserved4)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .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()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .field("action", &self.action)
         .field("populate_popup", &self.populate_popup)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct DzlTrie(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct _DzlGraphColumnClass {
    pub parent: 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 as *const _))
         .field("parent", &self.parent)
         .finish()
    }
}

// Classes
#[repr(C)]
pub struct DzlAnimation(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlBindingGroup(c_void);

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

#[repr(C)]
pub struct DzlBoldingLabel(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlBoxTheatric(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlChildPropertyAction(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlCpuGraph(c_void);

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

#[repr(C)]
pub struct DzlCpuModel(c_void);

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

#[repr(C)]
pub struct DzlCssProvider(c_void);

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

#[repr(C)]
pub struct DzlDirectoryModel(c_void);

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

#[repr(C)]
pub struct DzlDirectoryReaper(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlDockOverlayEdge(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlDockTransientGrab(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlEntryBox(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlFuzzyIndex(c_void);

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

#[repr(C)]
pub struct DzlFuzzyIndexBuilder(c_void);

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

#[repr(C)]
pub struct DzlFuzzyIndexCursor(c_void);

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

#[repr(C)]
pub struct DzlFuzzyIndexMatch(c_void);

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

#[repr(C)]
pub struct DzlGraphColumn(c_void);

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

#[repr(C)]
pub struct DzlGraphLineRenderer(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlJoinedMenu(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlListModelFilter(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlMenuManager(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlPath(c_void);

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

#[repr(C)]
pub struct DzlPathBar(c_void);

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

#[repr(C)]
pub struct DzlPathElement(c_void);

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

#[repr(C)]
pub struct DzlPillBox(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlPreferencesFileChooserButton(c_void);

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

#[repr(C)]
pub struct DzlPreferencesFlowBox(c_void);

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

#[repr(C)]
pub struct DzlPreferencesFontButton(c_void);

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

#[repr(C)]
pub struct DzlPreferencesGroup(c_void);

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

#[repr(C)]
pub struct DzlPreferencesPage(c_void);

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

#[repr(C)]
pub struct DzlPreferencesSpinButton(c_void);

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

#[repr(C)]
pub struct DzlPreferencesSwitch(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlProgressIcon(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlPropertiesGroup(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlReadOnlyListModel(c_void);

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

#[repr(C)]
pub struct DzlRecursiveFileMonitor(c_void);

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

#[repr(C)]
pub struct DzlScrolledWindow(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlSettingsFlagAction(c_void);

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

#[repr(C)]
pub struct DzlSettingsSandwich(c_void);

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

#[repr(C)]
pub struct DzlShortcutAccelDialog(c_void);

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

#[repr(C)]
pub struct DzlShortcutContext(c_void);

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

#[repr(C)]
pub struct DzlShortcutController(c_void);

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

#[repr(C)]
pub struct DzlShortcutLabel(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlShortcutModel(c_void);

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

#[repr(C)]
pub struct DzlShortcutSimpleLabel(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlShortcutTooltip(c_void);

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

#[repr(C)]
pub struct DzlShortcutsGroup(c_void);

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

#[repr(C)]
pub struct DzlShortcutsSection(c_void);

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

#[repr(C)]
pub struct DzlShortcutsShortcut(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("window", &self.window)
         .finish()
    }
}

#[repr(C)]
pub struct DzlSignalGroup(c_void);

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

#[repr(C)]
pub struct DzlSimpleLabel(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlSuggestionPopover(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlTab(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlTaskCache(c_void);

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

#[repr(C)]
pub struct DzlThemeManager(c_void);

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

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
         .field("parent_instance", &self.parent_instance)
         .finish()
    }
}

#[repr(C)]
pub struct DzlTreeNode(c_void);

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

#[repr(C)]
pub struct DzlWidgetActionGroup(c_void);

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

// Interfaces
#[repr(C)]
pub struct DzlDock(c_void);

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

#[repr(C)]
pub struct DzlDockItem(c_void);

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

#[repr(C)]
pub struct DzlGraphRenderer(c_void);

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

#[repr(C)]
pub struct DzlPreferences(c_void);

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


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;

    //=========================================================================
    // 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(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_application_window_get_fullscreen(self_: *mut DzlApplicationWindow) -> gboolean;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_application_window_get_titlebar(self_: *mut DzlApplicationWindow) -> *mut gtk::GtkWidget;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_application_window_set_fullscreen(self_: *mut DzlApplicationWindow, fullscreen: gboolean);
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_32", feature = "dox"))]
    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(any(feature = "v3_28", feature = "dox"))]
    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(any(feature = "v3_30", feature = "dox"))]
    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(any(feature = "v3_28", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_menu_button_set_show_accels(self_: *mut DzlMenuButton, show_accels: gboolean);
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_menu_button_set_show_arrow(self_: *mut DzlMenuButton, show_arrow: gboolean);
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_menu_button_set_show_icons(self_: *mut DzlMenuButton, show_icons: gboolean);

    //=========================================================================
    // DzlMenuManager
    //=========================================================================
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_menu_manager_get_type() -> GType;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_menu_manager_new() -> *mut DzlMenuManager;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_menu_manager_add_filename(self_: *mut DzlMenuManager, filename: *const c_char, error: *mut *mut glib::GError) -> c_uint;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_menu_manager_add_resource(self_: *mut DzlMenuManager, resource: *const c_char, error: *mut *mut glib::GError) -> c_uint;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_menu_manager_get_menu_by_id(self_: *mut DzlMenuManager, menu_id: *const c_char) -> *mut gio::GMenu;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_menu_manager_merge(self_: *mut DzlMenuManager, menu_id: *const c_char, model: *mut gio::GMenuModel) -> c_uint;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_28", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_path_element_new(id: *const c_char, icon_name: *const c_char, title: *const c_char) -> *mut DzlPathElement;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_path_element_get_icon_name(self_: *mut DzlPathElement) -> *const c_char;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_path_element_get_id(self_: *mut DzlPathElement) -> *const c_char;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_properties_group_add_all_properties(self_: *mut DzlPropertiesGroup);
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_properties_group_add_property(self_: *mut DzlPropertiesGroup, name: *const c_char, property_name: *const c_char);
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_properties_group_add_property_full(self_: *mut DzlPropertiesGroup, name: *const c_char, property_name: *const c_char, flags: DzlPropertiesFlags);
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_30", feature = "dox"))]
    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(any(feature = "v3_28", feature = "dox"))]
    pub fn dzl_recursive_file_monitor_cancel(self_: *mut DzlRecursiveFileMonitor);
    #[cfg(any(feature = "v3_28", feature = "dox"))]
    pub fn dzl_recursive_file_monitor_get_root(self_: *mut DzlRecursiveFileMonitor) -> *mut gio::GFile;
    #[cfg(any(feature = "v3_28", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    pub fn dzl_shortcut_controller_get_context(self_: *mut DzlShortcutController) -> *mut DzlShortcutContext;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_34", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_32", feature = "dox"))]
    pub fn dzl_shortcut_tooltip_new() -> *mut DzlShortcutTooltip;
    #[cfg(any(feature = "v3_32", feature = "dox"))]
    pub fn dzl_shortcut_tooltip_get_accel(self_: *mut DzlShortcutTooltip) -> *const c_char;
    #[cfg(any(feature = "v3_32", feature = "dox"))]
    pub fn dzl_shortcut_tooltip_get_command_id(self_: *mut DzlShortcutTooltip) -> *const c_char;
    #[cfg(any(feature = "v3_32", feature = "dox"))]
    pub fn dzl_shortcut_tooltip_get_title(self_: *mut DzlShortcutTooltip) -> *const c_char;
    #[cfg(any(feature = "v3_32", feature = "dox"))]
    pub fn dzl_shortcut_tooltip_get_widget(self_: *mut DzlShortcutTooltip) -> *mut gtk::GtkWidget;
    #[cfg(any(feature = "v3_32", feature = "dox"))]
    pub fn dzl_shortcut_tooltip_set_accel(self_: *mut DzlShortcutTooltip, accel: *const c_char);
    #[cfg(any(feature = "v3_32", feature = "dox"))]
    pub fn dzl_shortcut_tooltip_set_command_id(self_: *mut DzlShortcutTooltip, command_id: *const c_char);
    #[cfg(any(feature = "v3_32", feature = "dox"))]
    pub fn dzl_shortcut_tooltip_set_title(self_: *mut DzlShortcutTooltip, title: *const c_char);
    #[cfg(any(feature = "v3_32", feature = "dox"))]
    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(any(feature = "v3_28", feature = "dox"))]
    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(any(feature = "v3_30", feature = "dox"))]
    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(any(feature = "v3_30", feature = "dox"))]
    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(any(feature = "v3_36", feature = "dox"))]
    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(any(feature = "v3_36", feature = "dox"))]
    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(any(feature = "v3_34", feature = "dox"))]
    pub fn dzl_suggestion_button_get_button(self_: *mut DzlSuggestionButton) -> *mut gtk::GtkButton;
    #[cfg(any(feature = "v3_34", feature = "dox"))]
    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(any(feature = "v3_34", feature = "dox"))]
    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(any(feature = "v3_32", feature = "dox"))]
    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(any(feature = "v3_34", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_28", feature = "dox"))]
    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(any(feature = "v3_28", feature = "dox"))]
    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(any(feature = "v3_28", feature = "dox"))]
    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(any(feature = "v3_28", feature = "dox"))]
    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(any(feature = "v3_30", feature = "dox"))]
    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(any(feature = "v3_34", feature = "dox"))]
    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(any(feature = "v3_34", feature = "dox"))]
    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(any(feature = "v3_28", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    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(any(feature = "v3_26", feature = "dox"))]
    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;

}