libhelium_sys/

lib.rs

// Generated by gir (https://github.com/gtk-rs/gir @ 5c4134d75fd1)
// from
// from gir-files (https://github.com/gtk-rs/gir-files.git @ fa73af2178bc)
// DO NOT EDIT

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

use gdk_sys as gdk;
use gio_sys as gio;
use glib_sys as glib;
use gobject_sys as gobject;
use gtk_sys as gtk;
use pango_sys as pango;

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

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

// Enums
pub type HeAboutWindowLicenses = c_int;
pub const HE_ABOUT_WINDOW_LICENSES_GPLV3: HeAboutWindowLicenses = 0;
pub const HE_ABOUT_WINDOW_LICENSES_MIT: HeAboutWindowLicenses = 1;
pub const HE_ABOUT_WINDOW_LICENSES_MPLV2: HeAboutWindowLicenses = 2;
pub const HE_ABOUT_WINDOW_LICENSES_UNLICENSE: HeAboutWindowLicenses = 3;
pub const HE_ABOUT_WINDOW_LICENSES_APACHEV2: HeAboutWindowLicenses = 4;
pub const HE_ABOUT_WINDOW_LICENSES_WTFPL: HeAboutWindowLicenses = 5;
pub const HE_ABOUT_WINDOW_LICENSES_PROPRIETARY: HeAboutWindowLicenses = 6;

pub type HeAnimationState = c_int;
pub const HE_ANIMATION_STATE_IDLE: HeAnimationState = 0;
pub const HE_ANIMATION_STATE_PAUSED: HeAnimationState = 1;
pub const HE_ANIMATION_STATE_PLAYING: HeAnimationState = 2;
pub const HE_ANIMATION_STATE_FINISHED: HeAnimationState = 3;

pub type HeAvatarStatusColor = c_int;
pub const HE_AVATAR_STATUS_COLOR_RED: HeAvatarStatusColor = 0;
pub const HE_AVATAR_STATUS_COLOR_GREEN: HeAvatarStatusColor = 1;
pub const HE_AVATAR_STATUS_COLOR_YELLOW: HeAvatarStatusColor = 2;

pub type HeBannerStyle = c_int;
pub const HE_BANNER_STYLE_INFO: HeBannerStyle = 0;
pub const HE_BANNER_STYLE_WARNING: HeBannerStyle = 1;
pub const HE_BANNER_STYLE_ERROR: HeBannerStyle = 2;

pub type HeBottomBarPosition = c_int;
pub const HE_BOTTOM_BAR_POSITION_LEFT: HeBottomBarPosition = 0;
pub const HE_BOTTOM_BAR_POSITION_RIGHT: HeBottomBarPosition = 1;

pub type HeColors = c_int;
pub const HE_COLORS_NONE: HeColors = 0;
pub const HE_COLORS_RED: HeColors = 1;
pub const HE_COLORS_ORANGE: HeColors = 2;
pub const HE_COLORS_YELLOW: HeColors = 3;
pub const HE_COLORS_GREEN: HeColors = 4;
pub const HE_COLORS_BLUE: HeColors = 5;
pub const HE_COLORS_INDIGO: HeColors = 6;
pub const HE_COLORS_PURPLE: HeColors = 7;
pub const HE_COLORS_PINK: HeColors = 8;
pub const HE_COLORS_MINT: HeColors = 9;
pub const HE_COLORS_BROWN: HeColors = 10;
pub const HE_COLORS_LIGHT: HeColors = 11;
pub const HE_COLORS_DARK: HeColors = 12;

pub type HeContentBlockImageClusterImagePosition = c_int;
pub const HE_CONTENT_BLOCK_IMAGE_CLUSTER_IMAGE_POSITION_TOP_LEFT:
    HeContentBlockImageClusterImagePosition = 0;
pub const HE_CONTENT_BLOCK_IMAGE_CLUSTER_IMAGE_POSITION_BOTTOM_LEFT:
    HeContentBlockImageClusterImagePosition = 1;
pub const HE_CONTENT_BLOCK_IMAGE_CLUSTER_IMAGE_POSITION_TOP_RIGHT:
    HeContentBlockImageClusterImagePosition = 2;
pub const HE_CONTENT_BLOCK_IMAGE_CLUSTER_IMAGE_POSITION_BOTTOM_RIGHT:
    HeContentBlockImageClusterImagePosition = 3;

pub type HeDesktopColorScheme = c_int;
pub const HE_DESKTOP_COLOR_SCHEME_NO_PREFERENCE: HeDesktopColorScheme = 0;
pub const HE_DESKTOP_COLOR_SCHEME_DARK: HeDesktopColorScheme = 1;
pub const HE_DESKTOP_COLOR_SCHEME_LIGHT: HeDesktopColorScheme = 2;

pub type HeDesktopEnsorScheme = c_int;
pub const HE_DESKTOP_ENSOR_SCHEME_DEFAULT: HeDesktopEnsorScheme = 0;
pub const HE_DESKTOP_ENSOR_SCHEME_VIBRANT: HeDesktopEnsorScheme = 1;
pub const HE_DESKTOP_ENSOR_SCHEME_MUTED: HeDesktopEnsorScheme = 2;
pub const HE_DESKTOP_ENSOR_SCHEME_MONOCHROMATIC: HeDesktopEnsorScheme = 3;
pub const HE_DESKTOP_ENSOR_SCHEME_SALAD: HeDesktopEnsorScheme = 4;

pub type HeEasing = c_int;
pub const HE_EASING_LINEAR: HeEasing = 0;
pub const HE_EASING_EASE_OUT_CUBIC: HeEasing = 1;
pub const HE_EASING_EASE_IN_OUT_BOUNCE: HeEasing = 2;

pub type HeModifierBadgeAlignment = c_int;
pub const HE_MODIFIER_BADGE_ALIGNMENT_LEFT: HeModifierBadgeAlignment = 0;
pub const HE_MODIFIER_BADGE_ALIGNMENT_CENTER: HeModifierBadgeAlignment = 1;
pub const HE_MODIFIER_BADGE_ALIGNMENT_RIGHT: HeModifierBadgeAlignment = 2;

pub type HeOverlayButtonAlignment = c_int;
pub const HE_OVERLAY_BUTTON_ALIGNMENT_LEFT: HeOverlayButtonAlignment = 0;
pub const HE_OVERLAY_BUTTON_ALIGNMENT_CENTER: HeOverlayButtonAlignment = 1;
pub const HE_OVERLAY_BUTTON_ALIGNMENT_RIGHT: HeOverlayButtonAlignment = 2;

pub type HeOverlayButtonSize = c_int;
pub const HE_OVERLAY_BUTTON_SIZE_SMALL: HeOverlayButtonSize = 0;
pub const HE_OVERLAY_BUTTON_SIZE_MEDIUM: HeOverlayButtonSize = 1;
pub const HE_OVERLAY_BUTTON_SIZE_LARGE: HeOverlayButtonSize = 2;

pub type HeOverlayButtonTypeButton = c_int;
pub const HE_OVERLAY_BUTTON_TYPE_BUTTON_SURFACE: HeOverlayButtonTypeButton = 0;
pub const HE_OVERLAY_BUTTON_TYPE_BUTTON_PRIMARY: HeOverlayButtonTypeButton = 1;
pub const HE_OVERLAY_BUTTON_TYPE_BUTTON_SECONDARY: HeOverlayButtonTypeButton = 2;
pub const HE_OVERLAY_BUTTON_TYPE_BUTTON_TERTIARY: HeOverlayButtonTypeButton = 3;

pub type HeSchemeVariant = c_int;
pub const HE_SCHEME_VARIANT_DEFAULT: HeSchemeVariant = 0;
pub const HE_SCHEME_VARIANT_VIBRANT: HeSchemeVariant = 1;
pub const HE_SCHEME_VARIANT_MUTED: HeSchemeVariant = 2;
pub const HE_SCHEME_VARIANT_MONOCHROME: HeSchemeVariant = 3;
pub const HE_SCHEME_VARIANT_SALAD: HeSchemeVariant = 4;
pub const HE_SCHEME_VARIANT_CONTENT: HeSchemeVariant = 5;

pub type HeTabSwitcherTabBarBehavior = c_int;
pub const HE_TAB_SWITCHER_TAB_BAR_BEHAVIOR_ALWAYS: HeTabSwitcherTabBarBehavior = 0;
pub const HE_TAB_SWITCHER_TAB_BAR_BEHAVIOR_SINGLE: HeTabSwitcherTabBarBehavior = 1;
pub const HE_TAB_SWITCHER_TAB_BAR_BEHAVIOR_NEVER: HeTabSwitcherTabBarBehavior = 2;

pub type HeTipViewStyle = c_int;
pub const HE_TIP_VIEW_STYLE_NONE: HeTipViewStyle = 0;
pub const HE_TIP_VIEW_STYLE_POPUP: HeTipViewStyle = 1;
pub const HE_TIP_VIEW_STYLE_VIEW: HeTipViewStyle = 2;

pub type HeTonePolarity = c_int;
pub const HE_TONE_POLARITY_DARKER: HeTonePolarity = 0;
pub const HE_TONE_POLARITY_LIGHTER: HeTonePolarity = 1;
pub const HE_TONE_POLARITY_NEARER: HeTonePolarity = 2;
pub const HE_TONE_POLARITY_FARTHER: HeTonePolarity = 3;

// Callbacks
pub type HeAnimationTargetFunc = Option<unsafe extern "C" fn(c_double, *mut c_void)>;
pub type HeBackgroundFunc =
    Option<unsafe extern "C" fn(*mut HeDynamicScheme, *mut c_void) -> *mut HeDynamicColor>;
pub type HePaletteFunc =
    Option<unsafe extern "C" fn(*mut HeDynamicScheme, *mut c_void) -> *mut HeTonalPalette>;
pub type HeToneDeltaPairFunc =
    Option<unsafe extern "C" fn(*mut HeDynamicScheme, *mut c_void) -> *mut HeToneDeltaPair>;
pub type HeToneFunc = Option<unsafe extern "C" fn(*mut HeDynamicScheme, *mut c_void) -> c_double>;

// Records
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAboutWindowClass {
    pub parent_class: HeWindowClass,
}

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

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

pub type HeAboutWindowPrivate = _HeAboutWindowPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAnimationClass {
    pub parent_class: gobject::GObjectClass,
    pub estimate_duration: Option<unsafe extern "C" fn(*mut HeAnimation) -> c_uint>,
    pub calculate_value: Option<unsafe extern "C" fn(*mut HeAnimation, c_uint) -> c_double>,
}

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

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

pub type HeAnimationPrivate = _HeAnimationPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAnimationTargetClass {
    pub parent_class: gobject::GObjectClass,
    pub set_value: Option<unsafe extern "C" fn(*mut HeAnimationTarget, c_double)>,
}

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

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

pub type HeAnimationTargetPrivate = _HeAnimationTargetPrivate;

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

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

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

pub type HeAppBarPrivate = _HeAppBarPrivate;

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

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

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

pub type HeApplicationPrivate = _HeApplicationPrivate;

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

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

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

pub type HeApplicationWindowPrivate = _HeApplicationWindowPrivate;

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

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

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

pub type HeAvatarPrivate = _HeAvatarPrivate;

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

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

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

pub type HeBadgePrivate = _HeBadgePrivate;

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

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

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

pub type HeBannerPrivate = _HeBannerPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBinClass {
    pub parent_class: gtk::GtkWidgetClass,
    pub add_child: Option<
        unsafe extern "C" fn(
            *mut HeBin,
            *mut gtk::GtkBuilder,
            *mut gobject::GObject,
            *const c_char,
        ),
    >,
}

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

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

pub type HeBinPrivate = _HeBinPrivate;

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

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

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

pub type HeBottomBarPrivate = _HeBottomBarPrivate;

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

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

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

pub type HeBottomSheetPrivate = _HeBottomSheetPrivate;

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

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

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

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

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

pub type HeButtonContentPrivate = _HeButtonContentPrivate;

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

pub type HeButtonPrivate = _HeButtonPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeCAM16Color {
    pub j: c_double,
    pub a: c_double,
    pub b: c_double,
    pub c: c_double,
    pub h: c_double,
    pub m: c_double,
    pub s: c_double,
}

impl ::std::fmt::Debug for HeCAM16Color {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HeCAM16Color @ {self:p}"))
            .field("j", &self.j)
            .field("a", &self.a)
            .field("b", &self.b)
            .field("c", &self.c)
            .field("h", &self.h)
            .field("m", &self.m)
            .field("s", &self.s)
            .finish()
    }
}

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

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

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

pub type HeCallbackAnimationTargetPrivate = _HeCallbackAnimationTargetPrivate;

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

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

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

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

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

pub type HeChipGroupPrivate = _HeChipGroupPrivate;

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

pub type HeChipPrivate = _HeChipPrivate;

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

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

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

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

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

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

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

pub type HeContentBlockImageClusterPrivate = _HeContentBlockImageClusterPrivate;

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

pub type HeContentBlockImagePrivate = _HeContentBlockImagePrivate;

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

pub type HeContentBlockPrivate = _HeContentBlockPrivate;

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

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

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

pub type HeContentListPrivate = _HeContentListPrivate;

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

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

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

pub type HeContentSchemePrivate = _HeContentSchemePrivate;

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

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

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

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

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

pub type HeContrastCurvePrivate = _HeContrastCurvePrivate;

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

pub type HeContrastPrivate = _HeContrastPrivate;

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

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

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

pub type HeDatePickerPrivate = _HeDatePickerPrivate;

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

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

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

pub type HeDefaultSchemePrivate = _HeDefaultSchemePrivate;

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

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

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

pub type HeDesktopPrivate = _HeDesktopPrivate;

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

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

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

pub type HeDialogPrivate = _HeDialogPrivate;

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

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

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

pub type HeDividerPrivate = _HeDividerPrivate;

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

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

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

pub type HeDropdownPrivate = _HeDropdownPrivate;

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

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

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

pub type HeDynamicColorPrivate = _HeDynamicColorPrivate;

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

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

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

pub type HeDynamicSchemePrivate = _HeDynamicSchemePrivate;

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

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

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

pub type HeEmptyPagePrivate = _HeEmptyPagePrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeHCTColor {
    pub h: c_double,
    pub c: c_double,
    pub t: c_double,
    pub a: c_int,
}

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

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

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

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

pub type HeKeyColorPrivate = _HeKeyColorPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeLABColor {
    pub l: c_double,
    pub a: c_double,
    pub b: c_double,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeLCHColor {
    pub l: c_double,
    pub c: c_double,
    pub h: c_double,
}

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

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

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

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

pub type HeMiniContentBlockPrivate = _HeMiniContentBlockPrivate;

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

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

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

pub type HeModifierBadgePrivate = _HeModifierBadgePrivate;

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

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

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

pub type HeMonochromaticSchemePrivate = _HeMonochromaticSchemePrivate;

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

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

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

pub type HeMutedSchemePrivate = _HeMutedSchemePrivate;

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

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

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

pub type HeNavigationRailPrivate = _HeNavigationRailPrivate;

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

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

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

pub type HeNavigationSectionPrivate = _HeNavigationSectionPrivate;

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

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

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

pub type HeOverlayButtonPrivate = _HeOverlayButtonPrivate;

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

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

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

pub type HeProgressBarPrivate = _HeProgressBarPrivate;

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

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

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

pub type HePropertyAnimationTargetPrivate = _HePropertyAnimationTargetPrivate;

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

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

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

pub type HeQuantizerCelebiPrivate = _HeQuantizerCelebiPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerClass {
    pub parent_class: gobject::GObjectClass,
    pub quantize: Option<
        unsafe extern "C" fn(*mut HeQuantizer, *mut c_int, c_int, c_int) -> *mut HeQuantizerResult,
    >,
}

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

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

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

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

pub type HeQuantizerMapPrivate = _HeQuantizerMapPrivate;

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

pub type HeQuantizerPrivate = _HeQuantizerPrivate;

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

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

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

pub type HeQuantizerResultPrivate = _HeQuantizerResultPrivate;

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

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

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

pub type HeQuantizerWsmeansPrivate = _HeQuantizerWsmeansPrivate;

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

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

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

pub type HeQuantizerWuPrivate = _HeQuantizerWuPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeRGBColor {
    pub r: c_double,
    pub g: c_double,
    pub b: c_double,
}

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

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

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

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

pub type HeSaladSchemePrivate = _HeSaladSchemePrivate;

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

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

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

pub type HeSchemePrivate = _HeSchemePrivate;

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

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

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

pub type HeScoreAnnotatedColorPrivate = _HeScoreAnnotatedColorPrivate;

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

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

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

pub type HeScorePrivate = _HeScorePrivate;

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

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

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

pub type HeSegmentedButtonPrivate = _HeSegmentedButtonPrivate;

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

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

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

pub type HeSettingsListPrivate = _HeSettingsListPrivate;

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

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

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

pub type HeSettingsPagePrivate = _HeSettingsPagePrivate;

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

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

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

pub type HeSettingsRowPrivate = _HeSettingsRowPrivate;

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

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

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

pub type HeSettingsWindowPrivate = _HeSettingsWindowPrivate;

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

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

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

pub type HeSideBarPrivate = _HeSideBarPrivate;

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

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

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

pub type HeSliderPrivate = _HeSliderPrivate;

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

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

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

pub type HeSpringAnimationPrivate = _HeSpringAnimationPrivate;

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

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

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

pub type HeSpringParamsPrivate = _HeSpringParamsPrivate;

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

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

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

pub type HeStyleManagerPrivate = _HeStyleManagerPrivate;

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

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

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

pub type HeSwitchBarPrivate = _HeSwitchBarPrivate;

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

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

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

pub type HeSwitchPrivate = _HeSwitchPrivate;

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

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

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

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

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

pub type HeTabPagePrivate = _HeTabPagePrivate;

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

pub type HeTabPrivate = _HeTabPrivate;

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

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

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

pub type HeTabSwitcherPrivate = _HeTabSwitcherPrivate;

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

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

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

pub type HeTemperatureCachePrivate = _HeTemperatureCachePrivate;

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

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

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

pub type HeTextFieldPrivate = _HeTextFieldPrivate;

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

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

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

pub type HeTimePickerPrivate = _HeTimePickerPrivate;

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

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

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

pub type HeTimedAnimationPrivate = _HeTimedAnimationPrivate;

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

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

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

pub type HeTipPrivate = _HeTipPrivate;

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

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

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

pub type HeTipViewPrivate = _HeTipViewPrivate;

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

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

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

pub type HeToastPrivate = _HeToastPrivate;

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

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

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

pub type HeTonalPalettePrivate = _HeTonalPalettePrivate;

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

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

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

pub type HeToneDeltaPairPrivate = _HeToneDeltaPairPrivate;

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

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

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

pub type HeVibrantSchemePrivate = _HeVibrantSchemePrivate;

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

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

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

pub type HeViewAuxPrivate = _HeViewAuxPrivate;

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

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

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

pub type HeViewChooserPrivate = _HeViewChooserPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewClass {
    pub parent_class: gtk::GtkWidgetClass,
    pub add_child: Option<
        unsafe extern "C" fn(
            *mut HeView,
            *mut gtk::GtkBuilder,
            *mut gobject::GObject,
            *const c_char,
        ),
    >,
}

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

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

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

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

pub type HeViewDualPrivate = _HeViewDualPrivate;

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

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

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

pub type HeViewMonoPrivate = _HeViewMonoPrivate;

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

pub type HeViewPrivate = _HeViewPrivate;

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

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

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

pub type HeViewSubTitlePrivate = _HeViewSubTitlePrivate;

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

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

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

pub type HeViewSwitcherPrivate = _HeViewSwitcherPrivate;

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

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

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

pub type HeViewTitlePrivate = _HeViewTitlePrivate;

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

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

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

pub type HeViewingConditionsPrivate = _HeViewingConditionsPrivate;

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

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

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

pub type HeWelcomeScreenPrivate = _HeWelcomeScreenPrivate;

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

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

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

pub type HeWindowPrivate = _HeWindowPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeXYZColor {
    pub x: c_double,
    pub y: c_double,
    pub z: c_double,
}

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

// Classes
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAboutWindow {
    pub parent_instance: HeWindow,
    pub priv_: *mut HeAboutWindowPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAnimation {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeAnimationPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAnimationTarget {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeAnimationTargetPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAppBar {
    pub parent_instance: HeBin,
    pub priv_: *mut HeAppBarPrivate,
    pub back_button: *mut HeButton,
    pub btn_box: *mut gtk::GtkBox,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeApplication {
    pub parent_instance: gtk::GtkApplication,
    pub priv_: *mut HeApplicationPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeApplicationWindow {
    pub parent_instance: gtk::GtkApplicationWindow,
    pub priv_: *mut HeApplicationWindowPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAvatar {
    pub parent_instance: gtk::GtkWidget,
    pub priv_: *mut HeAvatarPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBadge {
    pub parent_instance: HeBin,
    pub priv_: *mut HeBadgePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBanner {
    pub parent_instance: HeBin,
    pub priv_: *mut HeBannerPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBin {
    pub parent_instance: gtk::GtkWidget,
    pub priv_: *mut HeBinPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBottomBar {
    pub parent_instance: HeBin,
    pub priv_: *mut HeBottomBarPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBottomSheet {
    pub parent_instance: gtk::GtkWidget,
    pub priv_: *mut HeBottomSheetPrivate,
    pub back_button: *mut HeButton,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeButton {
    pub parent_instance: gtk::GtkButton,
    pub priv_: *mut HeButtonPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeButtonContent {
    pub parent_instance: gtk::GtkWidget,
    pub priv_: *mut HeButtonContentPrivate,
    pub image: *mut gtk::GtkImage,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeCallbackAnimationTarget {
    pub parent_instance: HeAnimationTarget,
    pub priv_: *mut HeCallbackAnimationTargetPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeChip {
    pub parent_instance: gtk::GtkToggleButton,
    pub priv_: *mut HeChipPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeChipGroup {
    pub parent_instance: HeBin,
    pub priv_: *mut HeChipGroupPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentBlock {
    pub parent_instance: HeBin,
    pub priv_: *mut HeContentBlockPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentBlockImage {
    pub parent_instance: HeBin,
    pub priv_: *mut HeContentBlockImagePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentBlockImageCluster {
    pub parent_instance: HeBin,
    pub priv_: *mut HeContentBlockImageClusterPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentList {
    pub parent_instance: HeBin,
    pub priv_: *mut HeContentListPrivate,
    pub children: *mut glib::GList,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentScheme {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeContentSchemePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContrast {
    pub parent_instance: gobject::GTypeInstance,
    pub ref_count: c_int,
    pub priv_: *mut HeContrastPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContrastCurve {
    pub parent_instance: gobject::GTypeInstance,
    pub ref_count: c_int,
    pub priv_: *mut HeContrastCurvePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDatePicker {
    pub parent_instance: gtk::GtkEntry,
    pub priv_: *mut HeDatePickerPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDefaultScheme {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeDefaultSchemePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDesktop {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeDesktopPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDialog {
    pub parent_instance: HeWindow,
    pub priv_: *mut HeDialogPrivate,
    pub cancel_button: *mut HeButton,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDivider {
    pub parent_instance: HeBin,
    pub priv_: *mut HeDividerPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDropdown {
    pub parent_instance: gtk::GtkGrid,
    pub priv_: *mut HeDropdownPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDynamicColor {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeDynamicColorPrivate,
    pub palette: HePaletteFunc,
    pub palette_target: gpointer,
    pub tonev: HeToneFunc,
    pub tonev_target: gpointer,
    pub background: HeBackgroundFunc,
    pub background_target: gpointer,
    pub second_background: HeBackgroundFunc,
    pub second_background_target: gpointer,
    pub tone_delta_pair: HeToneDeltaPairFunc,
    pub tone_delta_pair_target: gpointer,
}

impl ::std::fmt::Debug for HeDynamicColor {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HeDynamicColor @ {self:p}"))
            .field("palette", &self.palette)
            .field("palette_target", &self.palette_target)
            .field("tonev", &self.tonev)
            .field("tonev_target", &self.tonev_target)
            .field("background", &self.background)
            .field("background_target", &self.background_target)
            .field("second_background", &self.second_background)
            .field("second_background_target", &self.second_background_target)
            .field("tone_delta_pair", &self.tone_delta_pair)
            .field("tone_delta_pair_target", &self.tone_delta_pair_target)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDynamicScheme {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeDynamicSchemePrivate,
    pub hct: HeHCTColor,
    pub variant: HeSchemeVariant,
    pub is_dark: gboolean,
    pub contrast_level: c_double,
    pub primary: *mut HeTonalPalette,
    pub secondary: *mut HeTonalPalette,
    pub tertiary: *mut HeTonalPalette,
    pub neutral: *mut HeTonalPalette,
    pub neutral_variant: *mut HeTonalPalette,
    pub error: *mut HeTonalPalette,
}

impl ::std::fmt::Debug for HeDynamicScheme {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HeDynamicScheme @ {self:p}"))
            .field("hct", &self.hct)
            .field("variant", &self.variant)
            .field("is_dark", &self.is_dark)
            .field("contrast_level", &self.contrast_level)
            .field("primary", &self.primary)
            .field("secondary", &self.secondary)
            .field("tertiary", &self.tertiary)
            .field("neutral", &self.neutral)
            .field("neutral_variant", &self.neutral_variant)
            .field("error", &self.error)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeEmptyPage {
    pub parent_instance: HeBin,
    pub priv_: *mut HeEmptyPagePrivate,
    pub action_button: *mut HeButton,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeKeyColor {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeKeyColorPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeMiniContentBlock {
    pub parent_instance: HeBin,
    pub priv_: *mut HeMiniContentBlockPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeModifierBadge {
    pub parent_instance: HeBin,
    pub priv_: *mut HeModifierBadgePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeMonochromaticScheme {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeMonochromaticSchemePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeMutedScheme {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeMutedSchemePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeNavigationRail {
    pub parent_instance: HeBin,
    pub priv_: *mut HeNavigationRailPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeNavigationSection {
    pub parent_instance: HeBin,
    pub priv_: *mut HeNavigationSectionPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeOverlayButton {
    pub parent_instance: HeBin,
    pub priv_: *mut HeOverlayButtonPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeProgressBar {
    pub parent_instance: HeBin,
    pub priv_: *mut HeProgressBarPrivate,
    pub progressbar: *mut gtk::GtkProgressBar,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HePropertyAnimationTarget {
    pub parent_instance: HeAnimationTarget,
    pub priv_: *mut HePropertyAnimationTargetPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizer {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeQuantizerPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerCelebi {
    pub parent_instance: gobject::GTypeInstance,
    pub ref_count: c_int,
    pub priv_: *mut HeQuantizerCelebiPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerMap {
    pub parent_instance: HeQuantizer,
    pub priv_: *mut HeQuantizerMapPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerResult {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeQuantizerResultPrivate,
    pub color_to_count: *mut glib::GHashTable,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerWsmeans {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeQuantizerWsmeansPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerWu {
    pub parent_instance: HeQuantizer,
    pub priv_: *mut HeQuantizerWuPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSaladScheme {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeSaladSchemePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeScheme {
    pub parent_instance: gobject::GTypeInstance,
    pub ref_count: c_int,
    pub priv_: *mut HeSchemePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeScore {
    pub parent_instance: gobject::GTypeInstance,
    pub ref_count: c_int,
    pub priv_: *mut HeScorePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeScoreAnnotatedColor {
    pub parent_instance: gobject::GTypeInstance,
    pub ref_count: c_int,
    pub priv_: *mut HeScoreAnnotatedColorPrivate,
    pub argb: c_int,
    pub cam_hue: c_double,
    pub cam_chroma: c_double,
    pub excited_proportion: c_double,
    pub score: c_double,
    pub he_score_annotated_color_cmp: glib::GCompareFunc,
}

impl ::std::fmt::Debug for HeScoreAnnotatedColor {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HeScoreAnnotatedColor @ {self:p}"))
            .field("argb", &self.argb)
            .field("cam_hue", &self.cam_hue)
            .field("cam_chroma", &self.cam_chroma)
            .field("excited_proportion", &self.excited_proportion)
            .field("score", &self.score)
            .field(
                "he_score_annotated_color_cmp",
                &self.he_score_annotated_color_cmp,
            )
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSegmentedButton {
    pub parent_instance: gtk::GtkBox,
    pub priv_: *mut HeSegmentedButtonPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSettingsList {
    pub parent_instance: HeBin,
    pub priv_: *mut HeSettingsListPrivate,
    pub children: *mut glib::GList,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSettingsPage {
    pub parent_instance: HeBin,
    pub priv_: *mut HeSettingsPagePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSettingsRow {
    pub parent_instance: gtk::GtkListBoxRow,
    pub priv_: *mut HeSettingsRowPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSettingsWindow {
    pub parent_instance: HeWindow,
    pub priv_: *mut HeSettingsWindowPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSideBar {
    pub parent_instance: HeBin,
    pub priv_: *mut HeSideBarPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSlider {
    pub parent_instance: HeBin,
    pub priv_: *mut HeSliderPrivate,
    pub scale: *mut gtk::GtkScale,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSpringAnimation {
    pub parent_instance: HeAnimation,
    pub priv_: *mut HeSpringAnimationPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSpringParams {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeSpringParamsPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeStyleManager {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeStyleManagerPrivate,
    pub accent_color: *mut HeRGBColor,
    pub font_weight: c_double,
    pub roundness: c_double,
    pub is_dark: gboolean,
    pub contrast: c_double,
    pub scheme_variant: *mut HeSchemeVariant,
}

impl ::std::fmt::Debug for HeStyleManager {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HeStyleManager @ {self:p}"))
            .field("accent_color", &self.accent_color)
            .field("font_weight", &self.font_weight)
            .field("roundness", &self.roundness)
            .field("is_dark", &self.is_dark)
            .field("contrast", &self.contrast)
            .field("scheme_variant", &self.scheme_variant)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSwitch {
    pub parent_instance: HeBin,
    pub priv_: *mut HeSwitchPrivate,
    pub iswitch: *mut gtk::GtkSwitch,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSwitchBar {
    pub parent_instance: HeBin,
    pub priv_: *mut HeSwitchBarPrivate,
    pub main_switch: *mut HeSwitch,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTab {
    pub parent_instance: HeBin,
    pub priv_: *mut HeTabPrivate,
    pub page_container: *mut HeTabPage,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTabPage {
    pub parent_instance: HeBin,
    pub priv_: *mut HeTabPagePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTabSwitcher {
    pub parent_instance: HeBin,
    pub priv_: *mut HeTabSwitcherPrivate,
    pub notebook: *mut gtk::GtkNotebook,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTemperatureCache {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeTemperatureCachePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTextField {
    pub parent_instance: gtk::GtkListBoxRow,
    pub priv_: *mut HeTextFieldPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTimePicker {
    pub parent_instance: gtk::GtkEntry,
    pub priv_: *mut HeTimePickerPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTimedAnimation {
    pub parent_instance: HeAnimation,
    pub priv_: *mut HeTimedAnimationPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTip {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeTipPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTipView {
    pub parent_instance: HeBin,
    pub priv_: *mut HeTipViewPrivate,
    pub button: *mut HeButton,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeToast {
    pub parent_instance: HeBin,
    pub priv_: *mut HeToastPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTonalPalette {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeTonalPalettePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeToneDeltaPair {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeToneDeltaPairPrivate,
    pub role_a: *mut HeDynamicColor,
    pub role_b: *mut HeDynamicColor,
    pub delta: c_double,
    pub polarity: HeTonePolarity,
    pub stay_together: gboolean,
}

impl ::std::fmt::Debug for HeToneDeltaPair {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HeToneDeltaPair @ {self:p}"))
            .field("role_a", &self.role_a)
            .field("role_b", &self.role_b)
            .field("delta", &self.delta)
            .field("polarity", &self.polarity)
            .field("stay_together", &self.stay_together)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeVibrantScheme {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeVibrantSchemePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeView {
    pub parent_instance: gtk::GtkWidget,
    pub priv_: *mut HeViewPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewAux {
    pub parent_instance: HeView,
    pub priv_: *mut HeViewAuxPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewChooser {
    pub parent_instance: HeBin,
    pub priv_: *mut HeViewChooserPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewDual {
    pub parent_instance: gtk::GtkWidget,
    pub priv_: *mut HeViewDualPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewMono {
    pub parent_instance: HeBin,
    pub priv_: *mut HeViewMonoPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewSubTitle {
    pub parent_instance: HeBin,
    pub priv_: *mut HeViewSubTitlePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewSwitcher {
    pub parent_instance: HeBin,
    pub priv_: *mut HeViewSwitcherPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewTitle {
    pub parent_instance: HeBin,
    pub priv_: *mut HeViewTitlePrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewingConditions {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut HeViewingConditionsPrivate,
    pub he_viewing_conditions_default_conditions: *mut HeViewingConditions,
    pub rgb_d: *mut c_double,
    pub rgb_d_length1: c_int,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeWelcomeScreen {
    pub parent_instance: HeBin,
    pub priv_: *mut HeWelcomeScreenPrivate,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeWindow {
    pub parent_instance: gtk::GtkWindow,
    pub priv_: *mut HeWindowPrivate,
}

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

#[link(name = "helium-1")]
extern "C" {

    //=========================================================================
    // HeAboutWindowLicenses
    //=========================================================================
    pub fn he_about_window_licenses_get_type() -> GType;

    //=========================================================================
    // HeAnimationState
    //=========================================================================
    pub fn he_animation_state_get_type() -> GType;

    //=========================================================================
    // HeAvatarStatusColor
    //=========================================================================
    pub fn he_avatar_status_color_get_type() -> GType;

    //=========================================================================
    // HeBannerStyle
    //=========================================================================
    pub fn he_banner_style_get_type() -> GType;

    //=========================================================================
    // HeBottomBarPosition
    //=========================================================================
    pub fn he_bottom_bar_position_get_type() -> GType;

    //=========================================================================
    // HeColors
    //=========================================================================
    pub fn he_colors_get_type() -> GType;

    //=========================================================================
    // HeContentBlockImageClusterImagePosition
    //=========================================================================
    pub fn he_content_block_image_cluster_image_position_get_type() -> GType;

    //=========================================================================
    // HeDesktopColorScheme
    //=========================================================================
    pub fn he_desktop_color_scheme_get_type() -> GType;

    //=========================================================================
    // HeDesktopEnsorScheme
    //=========================================================================
    pub fn he_desktop_ensor_scheme_get_type() -> GType;

    //=========================================================================
    // HeEasing
    //=========================================================================
    pub fn he_easing_get_type() -> GType;

    //=========================================================================
    // HeModifierBadgeAlignment
    //=========================================================================
    pub fn he_modifier_badge_alignment_get_type() -> GType;

    //=========================================================================
    // HeOverlayButtonAlignment
    //=========================================================================
    pub fn he_overlay_button_alignment_get_type() -> GType;

    //=========================================================================
    // HeOverlayButtonSize
    //=========================================================================
    pub fn he_overlay_button_size_get_type() -> GType;

    //=========================================================================
    // HeOverlayButtonTypeButton
    //=========================================================================
    pub fn he_overlay_button_type_button_get_type() -> GType;

    //=========================================================================
    // HeSchemeVariant
    //=========================================================================
    pub fn he_scheme_variant_get_type() -> GType;

    //=========================================================================
    // HeTabSwitcherTabBarBehavior
    //=========================================================================
    pub fn he_tab_switcher_tab_bar_behavior_get_type() -> GType;

    //=========================================================================
    // HeTipViewStyle
    //=========================================================================
    pub fn he_tip_view_style_get_type() -> GType;

    //=========================================================================
    // HeTonePolarity
    //=========================================================================
    pub fn he_tone_polarity_get_type() -> GType;

    //=========================================================================
    // HeCAM16Color
    //=========================================================================
    pub fn he_ca_m16_color_get_type() -> GType;

    //=========================================================================
    // HeHCTColor
    //=========================================================================
    pub fn he_hct_color_get_type() -> GType;

    //=========================================================================
    // HeLABColor
    //=========================================================================
    pub fn he_lab_color_get_type() -> GType;
    pub fn he_lab_color_distance(self_: *mut HeLABColor, lab: *mut HeLABColor) -> c_double;

    //=========================================================================
    // HeLCHColor
    //=========================================================================
    pub fn he_lch_color_get_type() -> GType;

    //=========================================================================
    // HeRGBColor
    //=========================================================================
    pub fn he_rgb_color_get_type() -> GType;

    //=========================================================================
    // HeXYZColor
    //=========================================================================
    pub fn he_xyz_color_get_type() -> GType;

    //=========================================================================
    // HeAboutWindow
    //=========================================================================
    pub fn he_about_window_get_type() -> GType;
    pub fn he_about_window_new(
        parent: *mut gtk::GtkWindow,
        app_name: *const c_char,
        app_id: *const c_char,
        version: *const c_char,
        icon: *const c_char,
        translate_url: *const c_char,
        issue_url: *const c_char,
        more_info_url: *const c_char,
        translators: *mut *mut c_char,
        translators_length1: c_int,
        developers: *mut *mut c_char,
        developers_length1: c_int,
        copyright_year: c_int,
        license: HeAboutWindowLicenses,
        color: HeColors,
    ) -> *mut HeAboutWindow;
    pub fn he_about_window_get_color(self_: *mut HeAboutWindow) -> HeColors;
    pub fn he_about_window_set_color(self_: *mut HeAboutWindow, value: HeColors);
    pub fn he_about_window_get_license(self_: *mut HeAboutWindow) -> HeAboutWindowLicenses;
    pub fn he_about_window_set_license(self_: *mut HeAboutWindow, value: HeAboutWindowLicenses);
    pub fn he_about_window_get_version(self_: *mut HeAboutWindow) -> *const c_char;
    pub fn he_about_window_set_version(self_: *mut HeAboutWindow, value: *const c_char);
    pub fn he_about_window_get_app_name(self_: *mut HeAboutWindow) -> *const c_char;
    pub fn he_about_window_set_app_name(self_: *mut HeAboutWindow, value: *const c_char);
    pub fn he_about_window_get_icon(self_: *mut HeAboutWindow) -> *const c_char;
    pub fn he_about_window_set_icon(self_: *mut HeAboutWindow, value: *const c_char);
    pub fn he_about_window_get_translator_names(
        self_: *mut HeAboutWindow,
        result_length1: *mut c_int,
    ) -> *mut *mut c_char;
    pub fn he_about_window_set_translator_names(
        self_: *mut HeAboutWindow,
        value: *mut *mut c_char,
        value_length1: c_int,
    );
    pub fn he_about_window_get_developer_names(
        self_: *mut HeAboutWindow,
        result_length1: *mut c_int,
    ) -> *mut *mut c_char;
    pub fn he_about_window_set_developer_names(
        self_: *mut HeAboutWindow,
        value: *mut *mut c_char,
        value_length1: c_int,
    );
    pub fn he_about_window_get_copyright_year(self_: *mut HeAboutWindow) -> c_int;
    pub fn he_about_window_set_copyright_year(self_: *mut HeAboutWindow, value: c_int);
    pub fn he_about_window_get_app_id(self_: *mut HeAboutWindow) -> *const c_char;
    pub fn he_about_window_set_app_id(self_: *mut HeAboutWindow, value: *const c_char);
    pub fn he_about_window_get_translate_url(self_: *mut HeAboutWindow) -> *const c_char;
    pub fn he_about_window_set_translate_url(self_: *mut HeAboutWindow, value: *const c_char);
    pub fn he_about_window_get_issue_url(self_: *mut HeAboutWindow) -> *const c_char;
    pub fn he_about_window_set_issue_url(self_: *mut HeAboutWindow, value: *const c_char);
    pub fn he_about_window_get_more_info_url(self_: *mut HeAboutWindow) -> *const c_char;
    pub fn he_about_window_set_more_info_url(self_: *mut HeAboutWindow, value: *const c_char);

    //=========================================================================
    // HeAnimation
    //=========================================================================
    pub fn he_animation_get_type() -> GType;
    pub fn he_animation_pause(self_: *mut HeAnimation);
    pub fn he_animation_play(self_: *mut HeAnimation);
    pub fn he_animation_reset(self_: *mut HeAnimation);
    pub fn he_animation_resume(self_: *mut HeAnimation);
    pub fn he_animation_skip(self_: *mut HeAnimation);
    pub fn he_animation_estimate_duration(self_: *mut HeAnimation) -> c_uint;
    pub fn he_animation_calculate_value(self_: *mut HeAnimation, t: c_uint) -> c_double;
    pub fn he_animation_get_state(self_: *mut HeAnimation) -> HeAnimationState;
    pub fn he_animation_set_state(self_: *mut HeAnimation, value: HeAnimationState);
    pub fn he_animation_get_target(self_: *mut HeAnimation) -> *mut HeAnimationTarget;
    pub fn he_animation_set_target(self_: *mut HeAnimation, value: *mut HeAnimationTarget);
    pub fn he_animation_get_widget(self_: *mut HeAnimation) -> *mut gtk::GtkWidget;
    pub fn he_animation_set_widget(self_: *mut HeAnimation, value: *mut gtk::GtkWidget);
    pub fn he_animation_get_avalue(self_: *mut HeAnimation) -> c_double;
    pub fn he_animation_set_avalue(self_: *mut HeAnimation, value: c_double);

    //=========================================================================
    // HeAnimationTarget
    //=========================================================================
    pub fn he_animation_target_get_type() -> GType;
    pub fn he_animation_target_set_value(self_: *mut HeAnimationTarget, value: c_double);

    //=========================================================================
    // HeAppBar
    //=========================================================================
    pub fn he_app_bar_get_type() -> GType;
    pub fn he_app_bar_append(self_: *mut HeAppBar, child: *mut gtk::GtkWidget);
    pub fn he_app_bar_append_toggle(self_: *mut HeAppBar, child: *mut gtk::GtkWidget);
    pub fn he_app_bar_append_menu(self_: *mut HeAppBar, child: *mut gtk::GtkWidget);
    pub fn he_app_bar_remove(self_: *mut HeAppBar, child: *mut gtk::GtkWidget);
    pub fn he_app_bar_new() -> *mut HeAppBar;
    pub fn he_app_bar_get_stack(self_: *mut HeAppBar) -> *mut gtk::GtkStack;
    pub fn he_app_bar_set_stack(self_: *mut HeAppBar, value: *mut gtk::GtkStack);
    pub fn he_app_bar_get_scroller(self_: *mut HeAppBar) -> *mut gtk::GtkScrolledWindow;
    pub fn he_app_bar_set_scroller(self_: *mut HeAppBar, value: *mut gtk::GtkScrolledWindow);
    pub fn he_app_bar_get_is_compact(self_: *mut HeAppBar) -> gboolean;
    pub fn he_app_bar_set_is_compact(self_: *mut HeAppBar, value: gboolean);
    pub fn he_app_bar_get_viewtitle_widget(self_: *mut HeAppBar) -> *mut gtk::GtkWidget;
    pub fn he_app_bar_set_viewtitle_widget(self_: *mut HeAppBar, value: *mut gtk::GtkWidget);
    pub fn he_app_bar_get_viewsubtitle_label(self_: *mut HeAppBar) -> *const c_char;
    pub fn he_app_bar_set_viewsubtitle_label(self_: *mut HeAppBar, value: *const c_char);
    pub fn he_app_bar_get_show_left_title_buttons(self_: *mut HeAppBar) -> gboolean;
    pub fn he_app_bar_set_show_left_title_buttons(self_: *mut HeAppBar, value: gboolean);
    pub fn he_app_bar_get_show_right_title_buttons(self_: *mut HeAppBar) -> gboolean;
    pub fn he_app_bar_set_show_right_title_buttons(self_: *mut HeAppBar, value: gboolean);
    pub fn he_app_bar_get_decoration_layout(self_: *mut HeAppBar) -> *const c_char;
    pub fn he_app_bar_set_decoration_layout(self_: *mut HeAppBar, value: *const c_char);
    pub fn he_app_bar_get_show_back(self_: *mut HeAppBar) -> gboolean;
    pub fn he_app_bar_set_show_back(self_: *mut HeAppBar, value: gboolean);

    //=========================================================================
    // HeApplication
    //=========================================================================
    pub fn he_application_get_type() -> GType;
    pub fn he_application_new(
        application_id: *const c_char,
        flags: gio::GApplicationFlags,
    ) -> *mut HeApplication;
    pub fn he_application_get_default_accent_color(self_: *mut HeApplication) -> *mut HeRGBColor;
    pub fn he_application_set_default_accent_color(
        self_: *mut HeApplication,
        value: *mut HeRGBColor,
    );
    pub fn he_application_get_override_accent_color(self_: *mut HeApplication) -> gboolean;
    pub fn he_application_set_override_accent_color(self_: *mut HeApplication, value: gboolean);
    pub fn he_application_get_override_dark_style(self_: *mut HeApplication) -> gboolean;
    pub fn he_application_set_override_dark_style(self_: *mut HeApplication, value: gboolean);
    pub fn he_application_get_override_contrast(self_: *mut HeApplication) -> gboolean;
    pub fn he_application_set_override_contrast(self_: *mut HeApplication, value: gboolean);
    pub fn he_application_get_default_contrast(self_: *mut HeApplication) -> c_double;
    pub fn he_application_set_default_contrast(self_: *mut HeApplication, value: c_double);
    pub fn he_application_get_is_content(self_: *mut HeApplication) -> gboolean;
    pub fn he_application_set_is_content(self_: *mut HeApplication, value: gboolean);
    pub fn he_application_get_is_mono(self_: *mut HeApplication) -> gboolean;
    pub fn he_application_set_is_mono(self_: *mut HeApplication, value: gboolean);

    //=========================================================================
    // HeApplicationWindow
    //=========================================================================
    pub fn he_application_window_get_type() -> GType;
    pub fn he_application_window_new(app: *mut HeApplication) -> *mut HeApplicationWindow;
    pub fn he_application_window_get_has_title(self_: *mut HeApplicationWindow) -> gboolean;
    pub fn he_application_window_set_has_title(self_: *mut HeApplicationWindow, value: gboolean);
    pub fn he_application_window_get_has_back_button(self_: *mut HeApplicationWindow) -> gboolean;
    pub fn he_application_window_set_has_back_button(
        self_: *mut HeApplicationWindow,
        value: gboolean,
    );

    //=========================================================================
    // HeAvatar
    //=========================================================================
    pub fn he_avatar_get_type() -> GType;
    pub fn he_avatar_new(
        size: c_int,
        image: *const c_char,
        text: *const c_char,
        status: gboolean,
        status_color: *mut HeAvatarStatusColor,
    ) -> *mut HeAvatar;
    pub fn he_avatar_get_size(self_: *mut HeAvatar) -> c_int;
    pub fn he_avatar_set_size(self_: *mut HeAvatar, value: c_int);
    pub fn he_avatar_get_text(self_: *mut HeAvatar) -> *const c_char;
    pub fn he_avatar_set_text(self_: *mut HeAvatar, value: *const c_char);
    pub fn he_avatar_get_status(self_: *mut HeAvatar) -> gboolean;
    pub fn he_avatar_set_status(self_: *mut HeAvatar, value: gboolean);
    pub fn he_avatar_get_status_color(self_: *mut HeAvatar) -> HeAvatarStatusColor;
    pub fn he_avatar_set_status_color(self_: *mut HeAvatar, value: HeAvatarStatusColor);
    pub fn he_avatar_get_image(self_: *mut HeAvatar) -> *const c_char;
    pub fn he_avatar_set_image(self_: *mut HeAvatar, value: *const c_char);

    //=========================================================================
    // HeBadge
    //=========================================================================
    pub fn he_badge_get_type() -> GType;
    pub fn he_badge_new() -> *mut HeBadge;
    pub fn he_badge_get_child(self_: *mut HeBadge) -> *mut gtk::GtkWidget;
    pub fn he_badge_set_child(self_: *mut HeBadge, value: *mut gtk::GtkWidget);
    pub fn he_badge_get_label(self_: *mut HeBadge) -> *const c_char;
    pub fn he_badge_set_label(self_: *mut HeBadge, value: *const c_char);

    //=========================================================================
    // HeBanner
    //=========================================================================
    pub fn he_banner_get_type() -> GType;
    pub fn he_banner_add_action_button(self_: *mut HeBanner, widget: *mut gtk::GtkWidget);
    pub fn he_banner_remove_action(self_: *mut HeBanner, widget: *mut gtk::GtkWidget);
    pub fn he_banner_set_banner_style(self_: *mut HeBanner, style: HeBannerStyle);
    pub fn he_banner_new(title: *const c_char, description: *const c_char) -> *mut HeBanner;
    pub fn he_banner_get_title(self_: *mut HeBanner) -> *const c_char;
    pub fn he_banner_set_title(self_: *mut HeBanner, value: *const c_char);
    pub fn he_banner_get_description(self_: *mut HeBanner) -> *const c_char;
    pub fn he_banner_set_description(self_: *mut HeBanner, value: *const c_char);
    pub fn he_banner_get_style(self_: *mut HeBanner) -> HeBannerStyle;
    pub fn he_banner_set_style(self_: *mut HeBanner, value: HeBannerStyle);

    //=========================================================================
    // HeBin
    //=========================================================================
    pub fn he_bin_get_type() -> GType;
    pub fn he_bin_add_child(
        self_: *mut HeBin,
        builder: *mut gtk::GtkBuilder,
        child: *mut gobject::GObject,
        type_: *const c_char,
    );
    pub fn he_bin_new() -> *mut HeBin;
    pub fn he_bin_get_child(self_: *mut HeBin) -> *mut gtk::GtkWidget;
    pub fn he_bin_set_child(self_: *mut HeBin, value: *mut gtk::GtkWidget);

    //=========================================================================
    // HeBottomBar
    //=========================================================================
    pub fn he_bottom_bar_get_type() -> GType;
    pub fn he_bottom_bar_new_with_details(
        title: *const c_char,
        description: *const c_char,
    ) -> *mut HeBottomBar;
    pub fn he_bottom_bar_new() -> *mut HeBottomBar;
    pub fn he_bottom_bar_append_button(
        self_: *mut HeBottomBar,
        icon: *mut HeButton,
        position: HeBottomBarPosition,
    );
    pub fn he_bottom_bar_prepend_button(
        self_: *mut HeBottomBar,
        icon: *mut HeButton,
        position: HeBottomBarPosition,
    );
    pub fn he_bottom_bar_remove_button(
        self_: *mut HeBottomBar,
        icon: *mut HeButton,
        position: HeBottomBarPosition,
    );
    pub fn he_bottom_bar_insert_button_after(
        self_: *mut HeBottomBar,
        icon: *mut HeButton,
        after: *mut HeButton,
        position: HeBottomBarPosition,
    );
    pub fn he_bottom_bar_reorder_button_after(
        self_: *mut HeBottomBar,
        icon: *mut HeButton,
        sibling: *mut HeButton,
        position: HeBottomBarPosition,
    );
    pub fn he_bottom_bar_get_title(self_: *mut HeBottomBar) -> *const c_char;
    pub fn he_bottom_bar_set_title(self_: *mut HeBottomBar, value: *const c_char);
    pub fn he_bottom_bar_get_description(self_: *mut HeBottomBar) -> *const c_char;
    pub fn he_bottom_bar_set_description(self_: *mut HeBottomBar, value: *const c_char);
    pub fn he_bottom_bar_get_menu_model(self_: *mut HeBottomBar) -> *mut gio::GMenuModel;
    pub fn he_bottom_bar_set_menu_model(self_: *mut HeBottomBar, value: *mut gio::GMenuModel);
    pub fn he_bottom_bar_get_collapse_actions(self_: *mut HeBottomBar) -> gboolean;
    pub fn he_bottom_bar_set_collapse_actions(self_: *mut HeBottomBar, value: gboolean);

    //=========================================================================
    // HeBottomSheet
    //=========================================================================
    pub fn he_bottom_sheet_get_type() -> GType;
    pub fn he_bottom_sheet_new() -> *mut HeBottomSheet;
    pub fn he_bottom_sheet_get_sheet(self_: *mut HeBottomSheet) -> *mut gtk::GtkWidget;
    pub fn he_bottom_sheet_set_sheet(self_: *mut HeBottomSheet, value: *mut gtk::GtkWidget);
    pub fn he_bottom_sheet_get_sheet_stack(self_: *mut HeBottomSheet) -> *mut gtk::GtkStack;
    pub fn he_bottom_sheet_set_sheet_stack(self_: *mut HeBottomSheet, value: *mut gtk::GtkStack);
    pub fn he_bottom_sheet_get_button(self_: *mut HeBottomSheet) -> *mut gtk::GtkWidget;
    pub fn he_bottom_sheet_set_button(self_: *mut HeBottomSheet, value: *mut gtk::GtkWidget);
    pub fn he_bottom_sheet_get_title(self_: *mut HeBottomSheet) -> *const c_char;
    pub fn he_bottom_sheet_set_title(self_: *mut HeBottomSheet, value: *const c_char);
    pub fn he_bottom_sheet_get_show_sheet(self_: *mut HeBottomSheet) -> gboolean;
    pub fn he_bottom_sheet_set_show_sheet(self_: *mut HeBottomSheet, value: gboolean);
    pub fn he_bottom_sheet_get_modal(self_: *mut HeBottomSheet) -> gboolean;
    pub fn he_bottom_sheet_set_modal(self_: *mut HeBottomSheet, value: gboolean);
    pub fn he_bottom_sheet_get_show_handle(self_: *mut HeBottomSheet) -> gboolean;
    pub fn he_bottom_sheet_set_show_handle(self_: *mut HeBottomSheet, value: gboolean);
    pub fn he_bottom_sheet_get_preferred_sheet_height(self_: *mut HeBottomSheet) -> c_int;
    pub fn he_bottom_sheet_set_preferred_sheet_height(self_: *mut HeBottomSheet, value: c_int);

    //=========================================================================
    // HeButton
    //=========================================================================
    pub fn he_button_get_type() -> GType;
    pub fn he_button_new(icon: *const c_char, text: *const c_char) -> *mut HeButton;
    pub fn he_button_get_color(self_: *mut HeButton) -> HeColors;
    pub fn he_button_set_color(self_: *mut HeButton, value: HeColors);
    pub fn he_button_get_is_disclosure(self_: *mut HeButton) -> gboolean;
    pub fn he_button_set_is_disclosure(self_: *mut HeButton, value: gboolean);
    pub fn he_button_get_is_iconic(self_: *mut HeButton) -> gboolean;
    pub fn he_button_set_is_iconic(self_: *mut HeButton, value: gboolean);
    pub fn he_button_get_is_outline(self_: *mut HeButton) -> gboolean;
    pub fn he_button_set_is_outline(self_: *mut HeButton, value: gboolean);
    pub fn he_button_get_is_tint(self_: *mut HeButton) -> gboolean;
    pub fn he_button_set_is_tint(self_: *mut HeButton, value: gboolean);
    pub fn he_button_get_is_fill(self_: *mut HeButton) -> gboolean;
    pub fn he_button_set_is_fill(self_: *mut HeButton, value: gboolean);
    pub fn he_button_get_is_pill(self_: *mut HeButton) -> gboolean;
    pub fn he_button_set_is_pill(self_: *mut HeButton, value: gboolean);
    pub fn he_button_get_is_textual(self_: *mut HeButton) -> gboolean;
    pub fn he_button_set_is_textual(self_: *mut HeButton, value: gboolean);
    pub fn he_button_get_icon(self_: *mut HeButton) -> *const c_char;
    pub fn he_button_set_icon(self_: *mut HeButton, value: *const c_char);
    pub fn he_button_get_text(self_: *mut HeButton) -> *const c_char;
    pub fn he_button_set_text(self_: *mut HeButton, value: *const c_char);

    //=========================================================================
    // HeButtonContent
    //=========================================================================
    pub fn he_button_content_get_type() -> GType;
    pub fn he_button_content_new() -> *mut HeButtonContent;
    pub fn he_button_content_get_icon(self_: *mut HeButtonContent) -> *mut c_char;
    pub fn he_button_content_set_icon(self_: *mut HeButtonContent, value: *const c_char);
    pub fn he_button_content_get_label(self_: *mut HeButtonContent) -> *mut c_char;
    pub fn he_button_content_set_label(self_: *mut HeButtonContent, value: *const c_char);

    //=========================================================================
    // HeCallbackAnimationTarget
    //=========================================================================
    pub fn he_callback_animation_target_get_type() -> GType;
    pub fn he_callback_animation_target_new(
        callback: HeAnimationTargetFunc,
        callback_target: *mut c_void,
        callback_target_destroy_notify: glib::GDestroyNotify,
    ) -> *mut HeCallbackAnimationTarget;

    //=========================================================================
    // HeChip
    //=========================================================================
    pub fn he_chip_get_type() -> GType;
    pub fn he_chip_new(label: *const c_char) -> *mut HeChip;
    pub fn he_chip_get_chip_label(self_: *mut HeChip) -> *const c_char;
    pub fn he_chip_set_chip_label(self_: *mut HeChip, value: *const c_char);

    //=========================================================================
    // HeChipGroup
    //=========================================================================
    pub fn he_chip_group_get_type() -> GType;
    pub fn he_chip_group_new() -> *mut HeChipGroup;
    pub fn he_chip_group_get_selection_model(
        self_: *mut HeChipGroup,
    ) -> *mut gtk::GtkSingleSelection;
    pub fn he_chip_group_set_selection_model(
        self_: *mut HeChipGroup,
        value: *mut gtk::GtkSingleSelection,
    );
    pub fn he_chip_group_get_single_line(self_: *mut HeChipGroup) -> gboolean;
    pub fn he_chip_group_set_single_line(self_: *mut HeChipGroup, value: gboolean);

    //=========================================================================
    // HeContentBlock
    //=========================================================================
    pub fn he_content_block_get_type() -> GType;
    pub fn he_content_block_new(
        title: *const c_char,
        subtitle: *const c_char,
        icon: *const c_char,
        primary_button: *mut HeButton,
        secondary_button: *mut HeButton,
    ) -> *mut HeContentBlock;
    pub fn he_content_block_get_title(self_: *mut HeContentBlock) -> *const c_char;
    pub fn he_content_block_set_title(self_: *mut HeContentBlock, value: *const c_char);
    pub fn he_content_block_get_subtitle(self_: *mut HeContentBlock) -> *const c_char;
    pub fn he_content_block_set_subtitle(self_: *mut HeContentBlock, value: *const c_char);
    pub fn he_content_block_get_icon(self_: *mut HeContentBlock) -> *const c_char;
    pub fn he_content_block_set_icon(self_: *mut HeContentBlock, value: *const c_char);
    pub fn he_content_block_set_gicon(self_: *mut HeContentBlock, value: *mut gio::GIcon);
    pub fn he_content_block_get_secondary_button(self_: *mut HeContentBlock) -> *mut HeButton;
    pub fn he_content_block_set_secondary_button(self_: *mut HeContentBlock, value: *mut HeButton);
    pub fn he_content_block_get_primary_button(self_: *mut HeContentBlock) -> *mut HeButton;
    pub fn he_content_block_set_primary_button(self_: *mut HeContentBlock, value: *mut HeButton);

    //=========================================================================
    // HeContentBlockImage
    //=========================================================================
    pub fn he_content_block_image_get_type() -> GType;
    pub fn he_content_block_image_new(file: *const c_char) -> *mut HeContentBlockImage;
    pub fn he_content_block_image_get_file(self_: *mut HeContentBlockImage) -> *const c_char;
    pub fn he_content_block_image_set_file(self_: *mut HeContentBlockImage, value: *const c_char);
    pub fn he_content_block_image_get_requested_height(self_: *mut HeContentBlockImage) -> c_int;
    pub fn he_content_block_image_set_requested_height(
        self_: *mut HeContentBlockImage,
        value: c_int,
    );
    pub fn he_content_block_image_get_requested_width(self_: *mut HeContentBlockImage) -> c_int;
    pub fn he_content_block_image_set_requested_width(
        self_: *mut HeContentBlockImage,
        value: c_int,
    );

    //=========================================================================
    // HeContentBlockImageCluster
    //=========================================================================
    pub fn he_content_block_image_cluster_get_type() -> GType;
    pub fn he_content_block_image_cluster_set_image(
        self_: *mut HeContentBlockImageCluster,
        image: *mut HeContentBlockImage,
        position: HeContentBlockImageClusterImagePosition,
    );
    pub fn he_content_block_image_cluster_remove_image(
        self_: *mut HeContentBlockImageCluster,
        image: *mut HeContentBlockImage,
    );
    pub fn he_content_block_image_cluster_new(
        title: *const c_char,
        subtitle: *const c_char,
        icon: *const c_char,
    ) -> *mut HeContentBlockImageCluster;
    pub fn he_content_block_image_cluster_get_title(
        self_: *mut HeContentBlockImageCluster,
    ) -> *const c_char;
    pub fn he_content_block_image_cluster_set_title(
        self_: *mut HeContentBlockImageCluster,
        value: *const c_char,
    );
    pub fn he_content_block_image_cluster_get_subtitle(
        self_: *mut HeContentBlockImageCluster,
    ) -> *const c_char;
    pub fn he_content_block_image_cluster_set_subtitle(
        self_: *mut HeContentBlockImageCluster,
        value: *const c_char,
    );
    pub fn he_content_block_image_cluster_get_icon(
        self_: *mut HeContentBlockImageCluster,
    ) -> *const c_char;
    pub fn he_content_block_image_cluster_set_icon(
        self_: *mut HeContentBlockImageCluster,
        value: *const c_char,
    );

    //=========================================================================
    // HeContentList
    //=========================================================================
    pub fn he_content_list_get_type() -> GType;
    pub fn he_content_list_add(self_: *mut HeContentList, child: *mut gtk::GtkWidget);
    pub fn he_content_list_remove(self_: *mut HeContentList, child: *mut gtk::GtkWidget);
    pub fn he_content_list_new() -> *mut HeContentList;
    pub fn he_content_list_get_title(self_: *mut HeContentList) -> *const c_char;
    pub fn he_content_list_set_title(self_: *mut HeContentList, value: *const c_char);
    pub fn he_content_list_get_description(self_: *mut HeContentList) -> *const c_char;
    pub fn he_content_list_set_description(self_: *mut HeContentList, value: *const c_char);

    //=========================================================================
    // HeContentScheme
    //=========================================================================
    pub fn he_content_scheme_get_type() -> GType;
    pub fn he_content_scheme_generate(
        self_: *mut HeContentScheme,
        hct: *mut HeHCTColor,
        is_dark: gboolean,
        contrast: c_double,
    ) -> *mut HeDynamicScheme;
    pub fn he_content_scheme_new() -> *mut HeContentScheme;

    //=========================================================================
    // HeContrast
    //=========================================================================
    pub fn he_contrast_get_type() -> GType;
    pub fn he_contrast_ratio_of_ys(y1: c_double, y2: c_double) -> c_double;
    pub fn he_contrast_ratio_of_tones(t1: c_double, t2: c_double) -> c_double;
    pub fn he_contrast_lighter(tone: c_double, ratio: c_double) -> c_double;
    pub fn he_contrast_lighter_unsafe(tone: c_double, ratio: c_double) -> c_double;
    pub fn he_contrast_darker(tone: c_double, ratio: c_double) -> c_double;
    pub fn he_contrast_darker_unsafe(tone: c_double, ratio: c_double) -> c_double;

    //=========================================================================
    // HeContrastCurve
    //=========================================================================
    pub fn he_contrast_curve_get_type() -> GType;
    pub fn he_contrast_curve_new(
        low: c_double,
        normal: c_double,
        medium: c_double,
        high: c_double,
    ) -> *mut HeContrastCurve;
    pub fn he_contrast_curve_get(self_: *mut HeContrastCurve, contrast: c_double) -> c_double;

    //=========================================================================
    // HeDatePicker
    //=========================================================================
    pub fn he_date_picker_get_type() -> GType;
    pub fn he_date_picker_new_with_format(format: *const c_char) -> *mut HeDatePicker;
    pub fn he_date_picker_new() -> *mut HeDatePicker;
    pub fn he_date_picker_get_format(self_: *mut HeDatePicker) -> *const c_char;
    pub fn he_date_picker_get_date(self_: *mut HeDatePicker) -> *mut glib::GDateTime;
    pub fn he_date_picker_set_date(self_: *mut HeDatePicker, value: *mut glib::GDateTime);

    //=========================================================================
    // HeDefaultScheme
    //=========================================================================
    pub fn he_default_scheme_get_type() -> GType;
    pub fn he_default_scheme_generate(
        self_: *mut HeDefaultScheme,
        hct: *mut HeHCTColor,
        is_dark: gboolean,
        contrast: c_double,
    ) -> *mut HeDynamicScheme;
    pub fn he_default_scheme_new() -> *mut HeDefaultScheme;

    //=========================================================================
    // HeDesktop
    //=========================================================================
    pub fn he_desktop_get_type() -> GType;
    pub fn he_desktop_new() -> *mut HeDesktop;
    pub fn he_desktop_get_prefers_color_scheme(self_: *mut HeDesktop) -> HeDesktopColorScheme;
    pub fn he_desktop_set_prefers_color_scheme(self_: *mut HeDesktop, value: HeDesktopColorScheme);
    pub fn he_desktop_get_ensor_scheme(self_: *mut HeDesktop) -> HeDesktopEnsorScheme;
    pub fn he_desktop_get_accent_color(self_: *mut HeDesktop) -> *mut HeRGBColor;
    pub fn he_desktop_set_accent_color(self_: *mut HeDesktop, value: *mut HeRGBColor);
    pub fn he_desktop_get_font_weight(self_: *mut HeDesktop) -> c_double;
    pub fn he_desktop_set_font_weight(self_: *mut HeDesktop, value: c_double);
    pub fn he_desktop_get_roundness(self_: *mut HeDesktop) -> c_double;
    pub fn he_desktop_set_roundness(self_: *mut HeDesktop, value: c_double);
    pub fn he_desktop_get_contrast(self_: *mut HeDesktop) -> c_double;
    pub fn he_desktop_set_contrast(self_: *mut HeDesktop, value: c_double);

    //=========================================================================
    // HeDialog
    //=========================================================================
    pub fn he_dialog_get_type() -> GType;
    pub fn he_dialog_add(self_: *mut HeDialog, widget: *mut gtk::GtkWidget);
    pub fn he_dialog_new(
        modal: gboolean,
        parent: *mut gtk::GtkWindow,
        title: *const c_char,
        subtitle: *const c_char,
        info: *const c_char,
        icon: *const c_char,
        primary_button: *mut HeButton,
        secondary_button: *mut HeButton,
    ) -> *mut HeDialog;
    pub fn he_dialog_get_title(self_: *mut HeDialog) -> *const c_char;
    pub fn he_dialog_set_title(self_: *mut HeDialog, value: *const c_char);
    pub fn he_dialog_get_info(self_: *mut HeDialog) -> *const c_char;
    pub fn he_dialog_set_info(self_: *mut HeDialog, value: *const c_char);
    pub fn he_dialog_get_icon(self_: *mut HeDialog) -> *const c_char;
    pub fn he_dialog_set_icon(self_: *mut HeDialog, value: *const c_char);
    pub fn he_dialog_get_secondary_button(self_: *mut HeDialog) -> *mut HeButton;
    pub fn he_dialog_set_secondary_button(self_: *mut HeDialog, value: *mut HeButton);
    pub fn he_dialog_get_primary_button(self_: *mut HeDialog) -> *mut HeButton;
    pub fn he_dialog_set_primary_button(self_: *mut HeDialog, value: *mut HeButton);

    //=========================================================================
    // HeDivider
    //=========================================================================
    pub fn he_divider_get_type() -> GType;
    pub fn he_divider_new() -> *mut HeDivider;
    pub fn he_divider_get_is_inset(self_: *mut HeDivider) -> gboolean;
    pub fn he_divider_set_is_inset(self_: *mut HeDivider, value: gboolean);
    pub fn he_divider_get_is_vertical(self_: *mut HeDivider) -> gboolean;
    pub fn he_divider_set_is_vertical(self_: *mut HeDivider, value: gboolean);

    //=========================================================================
    // HeDropdown
    //=========================================================================
    pub fn he_dropdown_get_type() -> GType;
    pub fn he_dropdown_new() -> *mut HeDropdown;
    pub fn he_dropdown_append(self_: *mut HeDropdown, text: *const c_char);
    pub fn he_dropdown_get_active(self_: *mut HeDropdown) -> *mut c_char;
    pub fn he_dropdown_insert(self_: *mut HeDropdown, position: c_int, text: *const c_char);
    pub fn he_dropdown_prepend(self_: *mut HeDropdown, text: *const c_char);
    pub fn he_dropdown_remove(self_: *mut HeDropdown, position: c_int);
    pub fn he_dropdown_remove_all(self_: *mut HeDropdown);
    pub fn he_dropdown_get_active_id(self_: *mut HeDropdown) -> *const c_char;
    pub fn he_dropdown_set_active_id(self_: *mut HeDropdown, value: *const c_char);
    pub fn he_dropdown_get_max_width_chars(self_: *mut HeDropdown) -> c_int;
    pub fn he_dropdown_set_max_width_chars(self_: *mut HeDropdown, value: c_int);
    pub fn he_dropdown_get_ellipsize(self_: *mut HeDropdown) -> pango::PangoEllipsizeMode;
    pub fn he_dropdown_set_ellipsize(self_: *mut HeDropdown, value: pango::PangoEllipsizeMode);
    pub fn he_dropdown_get_dropdown(self_: *mut HeDropdown) -> *mut gtk::GtkDropDown;
    pub fn he_dropdown_set_dropdown(self_: *mut HeDropdown, value: *mut gtk::GtkDropDown);

    //=========================================================================
    // HeDynamicColor
    //=========================================================================
    pub fn he_dynamic_color_get_type() -> GType;
    pub fn he_dynamic_color_new(
        name: *const c_char,
        palette: HePaletteFunc,
        palette_target: *mut c_void,
        tonev: HeToneFunc,
        tonev_target: *mut c_void,
        is_background: *mut gboolean,
        background: HeBackgroundFunc,
        background_target: *mut c_void,
        second_background: HeBackgroundFunc,
        second_background_target: *mut c_void,
        contrast_curve: *mut HeContrastCurve,
        tone_delta_pair: HeToneDeltaPairFunc,
        tone_delta_pair_target: *mut c_void,
    ) -> *mut HeDynamicColor;
    pub fn he_dynamic_color_new_from_palette(
        name: *const c_char,
        palette: HePaletteFunc,
        palette_target: *mut c_void,
        tonev: HeToneFunc,
        tonev_target: *mut c_void,
    ) -> *mut HeDynamicColor;
    pub fn he_dynamic_color_get_hct(
        self_: *mut HeDynamicColor,
        scheme: *mut HeDynamicScheme,
        result: *mut HeHCTColor,
    );
    pub fn he_dynamic_color_get_tone(
        self_: *mut HeDynamicColor,
        scheme: *mut HeDynamicScheme,
    ) -> c_double;
    pub fn he_dynamic_color_foreground_tone(
        self_: *mut HeDynamicColor,
        bg_tone: c_double,
        ratio: c_double,
    ) -> c_double;
    pub fn he_dynamic_color_enable_light_foreground(tone: c_double) -> c_double;
    pub fn he_dynamic_color_tone_prefers_light_foreground(tone: c_double) -> gboolean;
    pub fn he_dynamic_color_tone_allows_light_foreground(tone: c_double) -> gboolean;
    pub fn he_dynamic_color_get_name(self_: *mut HeDynamicColor) -> *const c_char;
    pub fn he_dynamic_color_set_name(self_: *mut HeDynamicColor, value: *const c_char);
    pub fn he_dynamic_color_get_is_background(self_: *mut HeDynamicColor) -> gboolean;
    pub fn he_dynamic_color_set_is_background(self_: *mut HeDynamicColor, value: gboolean);
    pub fn he_dynamic_color_get_contrast_curve(self_: *mut HeDynamicColor) -> *mut HeContrastCurve;
    pub fn he_dynamic_color_set_contrast_curve(
        self_: *mut HeDynamicColor,
        value: *mut HeContrastCurve,
    );

    //=========================================================================
    // HeDynamicScheme
    //=========================================================================
    pub fn he_dynamic_scheme_get_type() -> GType;
    pub fn he_dynamic_scheme_new(
        hct: *mut HeHCTColor,
        variant: HeSchemeVariant,
        is_dark: gboolean,
        contrast_level: c_double,
        primary: *mut HeTonalPalette,
        secondary: *mut HeTonalPalette,
        tertiary: *mut HeTonalPalette,
        neutral: *mut HeTonalPalette,
        neutral_variant: *mut HeTonalPalette,
        _error_: *mut HeTonalPalette,
    ) -> *mut HeDynamicScheme;
    pub fn he_dynamic_scheme_get_hct(
        self_: *mut HeDynamicScheme,
        dynamic_color: *mut HeDynamicColor,
        result: *mut HeHCTColor,
    );
    pub fn he_dynamic_scheme_get_primary_key(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_secondary_key(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_tertiary_key(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_neutral_key(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_neutral_variant_key(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_background(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_on_background(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_surface(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_surface_dim(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_surface_bright(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_surface_container_lowest(
        self_: *mut HeDynamicScheme,
    ) -> *mut c_char;
    pub fn he_dynamic_scheme_get_surface_container_low(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_surface_container(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_surface_container_high(self_: *mut HeDynamicScheme)
        -> *mut c_char;
    pub fn he_dynamic_scheme_get_surface_container_highest(
        self_: *mut HeDynamicScheme,
    ) -> *mut c_char;
    pub fn he_dynamic_scheme_get_on_surface(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_surface_variant(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_on_surface_variant(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_inverse_surface(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_inverse_on_surface(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_outline(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_outline_variant(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_shadow(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_scrim(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_primary(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_on_primary(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_primary_container(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_on_primary_container(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_inverse_primary(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_secondary(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_on_secondary(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_secondary_container(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_on_secondary_container(self_: *mut HeDynamicScheme)
        -> *mut c_char;
    pub fn he_dynamic_scheme_get_tertiary(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_on_tertiary(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_tertiary_container(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_on_tertiary_container(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_error(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_on_error(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_error_container(self_: *mut HeDynamicScheme) -> *mut c_char;
    pub fn he_dynamic_scheme_get_on_error_container(self_: *mut HeDynamicScheme) -> *mut c_char;

    //=========================================================================
    // HeEmptyPage
    //=========================================================================
    pub fn he_empty_page_get_type() -> GType;
    pub fn he_empty_page_new() -> *mut HeEmptyPage;
    pub fn he_empty_page_get_title(self_: *mut HeEmptyPage) -> *const c_char;
    pub fn he_empty_page_set_title(self_: *mut HeEmptyPage, value: *const c_char);
    pub fn he_empty_page_get_description(self_: *mut HeEmptyPage) -> *const c_char;
    pub fn he_empty_page_set_description(self_: *mut HeEmptyPage, value: *const c_char);
    pub fn he_empty_page_get_icon(self_: *mut HeEmptyPage) -> *const c_char;
    pub fn he_empty_page_set_icon(self_: *mut HeEmptyPage, value: *const c_char);
    pub fn he_empty_page_set_resource(self_: *mut HeEmptyPage, value: *const c_char);
    pub fn he_empty_page_get_button(self_: *mut HeEmptyPage) -> *const c_char;
    pub fn he_empty_page_set_button(self_: *mut HeEmptyPage, value: *const c_char);

    //=========================================================================
    // HeKeyColor
    //=========================================================================
    pub fn he_key_color_get_type() -> GType;
    pub fn he_key_color_new(hue: c_double, requested_chroma: c_double) -> *mut HeKeyColor;
    pub fn he_key_color_create(self_: *mut HeKeyColor, result: *mut HeHCTColor);
    pub fn he_key_color_get_hue(self_: *mut HeKeyColor) -> c_double;
    pub fn he_key_color_set_hue(self_: *mut HeKeyColor, value: c_double);
    pub fn he_key_color_get_requested_chroma(self_: *mut HeKeyColor) -> c_double;
    pub fn he_key_color_set_requested_chroma(self_: *mut HeKeyColor, value: c_double);

    //=========================================================================
    // HeMiniContentBlock
    //=========================================================================
    pub fn he_mini_content_block_get_type() -> GType;
    pub fn he_mini_content_block_new_with_details(
        t: *const c_char,
        s: *const c_char,
        pb: *mut HeButton,
        w: *mut gtk::GtkWidget,
    ) -> *mut HeMiniContentBlock;
    pub fn he_mini_content_block_new() -> *mut HeMiniContentBlock;
    pub fn he_mini_content_block_get_widget(self_: *mut HeMiniContentBlock) -> *mut gtk::GtkWidget;
    pub fn he_mini_content_block_set_widget(
        self_: *mut HeMiniContentBlock,
        value: *mut gtk::GtkWidget,
    );
    pub fn he_mini_content_block_get_title(self_: *mut HeMiniContentBlock) -> *const c_char;
    pub fn he_mini_content_block_set_title(self_: *mut HeMiniContentBlock, value: *const c_char);
    pub fn he_mini_content_block_get_subtitle(self_: *mut HeMiniContentBlock) -> *const c_char;
    pub fn he_mini_content_block_set_subtitle(self_: *mut HeMiniContentBlock, value: *const c_char);
    pub fn he_mini_content_block_get_icon(self_: *mut HeMiniContentBlock) -> *const c_char;
    pub fn he_mini_content_block_set_icon(self_: *mut HeMiniContentBlock, value: *const c_char);
    pub fn he_mini_content_block_set_gicon(self_: *mut HeMiniContentBlock, value: *mut gio::GIcon);
    pub fn he_mini_content_block_set_paintable(
        self_: *mut HeMiniContentBlock,
        value: *mut gdk::GdkPaintable,
    );
    pub fn he_mini_content_block_get_primary_button(
        self_: *mut HeMiniContentBlock,
    ) -> *mut HeButton;
    pub fn he_mini_content_block_set_primary_button(
        self_: *mut HeMiniContentBlock,
        value: *mut HeButton,
    );

    //=========================================================================
    // HeModifierBadge
    //=========================================================================
    pub fn he_modifier_badge_get_type() -> GType;
    pub fn he_modifier_badge_new(label: *const c_char) -> *mut HeModifierBadge;
    pub fn he_modifier_badge_get_color(self_: *mut HeModifierBadge) -> HeColors;
    pub fn he_modifier_badge_set_color(self_: *mut HeModifierBadge, value: HeColors);
    pub fn he_modifier_badge_get_tinted(self_: *mut HeModifierBadge) -> gboolean;
    pub fn he_modifier_badge_set_tinted(self_: *mut HeModifierBadge, value: gboolean);
    pub fn he_modifier_badge_get_label(self_: *mut HeModifierBadge) -> *const c_char;
    pub fn he_modifier_badge_set_label(self_: *mut HeModifierBadge, value: *const c_char);
    pub fn he_modifier_badge_get_alignment(self_: *mut HeModifierBadge)
        -> HeModifierBadgeAlignment;
    pub fn he_modifier_badge_set_alignment(
        self_: *mut HeModifierBadge,
        value: HeModifierBadgeAlignment,
    );

    //=========================================================================
    // HeMonochromaticScheme
    //=========================================================================
    pub fn he_monochromatic_scheme_get_type() -> GType;
    pub fn he_monochromatic_scheme_generate(
        self_: *mut HeMonochromaticScheme,
        hct: *mut HeHCTColor,
        is_dark: gboolean,
        contrast: c_double,
    ) -> *mut HeDynamicScheme;
    pub fn he_monochromatic_scheme_new() -> *mut HeMonochromaticScheme;

    //=========================================================================
    // HeMutedScheme
    //=========================================================================
    pub fn he_muted_scheme_get_type() -> GType;
    pub fn he_muted_scheme_generate(
        self_: *mut HeMutedScheme,
        hct: *mut HeHCTColor,
        is_dark: gboolean,
        contrast: c_double,
    ) -> *mut HeDynamicScheme;
    pub fn he_muted_scheme_new() -> *mut HeMutedScheme;

    //=========================================================================
    // HeNavigationRail
    //=========================================================================
    pub fn he_navigation_rail_get_type() -> GType;
    pub fn he_navigation_rail_new() -> *mut HeNavigationRail;
    pub fn he_navigation_rail_get_stack(self_: *mut HeNavigationRail) -> *mut gtk::GtkStack;
    pub fn he_navigation_rail_set_stack(self_: *mut HeNavigationRail, value: *mut gtk::GtkStack);
    pub fn he_navigation_rail_get_orientation(self_: *mut HeNavigationRail) -> gtk::GtkOrientation;
    pub fn he_navigation_rail_set_orientation(
        self_: *mut HeNavigationRail,
        value: gtk::GtkOrientation,
    );
    pub fn he_navigation_rail_get_hide_labels(self_: *mut HeNavigationRail) -> gboolean;
    pub fn he_navigation_rail_set_hide_labels(self_: *mut HeNavigationRail, value: gboolean);

    //=========================================================================
    // HeNavigationSection
    //=========================================================================
    pub fn he_navigation_section_get_type() -> GType;
    pub fn he_navigation_section_new() -> *mut HeNavigationSection;
    pub fn he_navigation_section_get_stack(self_: *mut HeNavigationSection) -> *mut gtk::GtkStack;
    pub fn he_navigation_section_set_stack(
        self_: *mut HeNavigationSection,
        value: *mut gtk::GtkStack,
    );
    pub fn he_navigation_section_get_orientation(
        self_: *mut HeNavigationSection,
    ) -> gtk::GtkOrientation;
    pub fn he_navigation_section_set_orientation(
        self_: *mut HeNavigationSection,
        value: gtk::GtkOrientation,
    );

    //=========================================================================
    // HeOverlayButton
    //=========================================================================
    pub fn he_overlay_button_get_type() -> GType;
    pub fn he_overlay_button_new(
        icon: *const c_char,
        label: *const c_char,
        secondary_icon: *const c_char,
    ) -> *mut HeOverlayButton;
    pub fn he_overlay_button_get_size(self_: *mut HeOverlayButton) -> HeOverlayButtonSize;
    pub fn he_overlay_button_set_size(self_: *mut HeOverlayButton, value: HeOverlayButtonSize);
    pub fn he_overlay_button_get_typeb(self_: *mut HeOverlayButton) -> HeOverlayButtonTypeButton;
    pub fn he_overlay_button_set_typeb(
        self_: *mut HeOverlayButton,
        value: HeOverlayButtonTypeButton,
    );
    pub fn he_overlay_button_get_typeb2(self_: *mut HeOverlayButton) -> HeOverlayButtonTypeButton;
    pub fn he_overlay_button_set_typeb2(
        self_: *mut HeOverlayButton,
        value: HeOverlayButtonTypeButton,
    );
    pub fn he_overlay_button_get_color(self_: *mut HeOverlayButton) -> HeColors;
    pub fn he_overlay_button_set_color(self_: *mut HeOverlayButton, value: HeColors);
    pub fn he_overlay_button_get_secondary_color(self_: *mut HeOverlayButton) -> HeColors;
    pub fn he_overlay_button_set_secondary_color(self_: *mut HeOverlayButton, value: HeColors);
    pub fn he_overlay_button_get_secondary_icon(self_: *mut HeOverlayButton) -> *mut c_char;
    pub fn he_overlay_button_set_secondary_icon(self_: *mut HeOverlayButton, value: *const c_char);
    pub fn he_overlay_button_get_icon(self_: *mut HeOverlayButton) -> *mut c_char;
    pub fn he_overlay_button_set_icon(self_: *mut HeOverlayButton, value: *const c_char);
    pub fn he_overlay_button_get_label(self_: *mut HeOverlayButton) -> *const c_char;
    pub fn he_overlay_button_set_label(self_: *mut HeOverlayButton, value: *const c_char);
    pub fn he_overlay_button_get_primary_tooltip(self_: *mut HeOverlayButton) -> *mut c_char;
    pub fn he_overlay_button_set_primary_tooltip(self_: *mut HeOverlayButton, value: *const c_char);
    pub fn he_overlay_button_get_secondary_tooltip(self_: *mut HeOverlayButton) -> *mut c_char;
    pub fn he_overlay_button_set_secondary_tooltip(
        self_: *mut HeOverlayButton,
        value: *const c_char,
    );
    pub fn he_overlay_button_get_child(self_: *mut HeOverlayButton) -> *mut gtk::GtkWidget;
    pub fn he_overlay_button_set_child(self_: *mut HeOverlayButton, value: *mut gtk::GtkWidget);
    pub fn he_overlay_button_get_alignment(self_: *mut HeOverlayButton)
        -> HeOverlayButtonAlignment;
    pub fn he_overlay_button_set_alignment(
        self_: *mut HeOverlayButton,
        value: HeOverlayButtonAlignment,
    );

    //=========================================================================
    // HeProgressBar
    //=========================================================================
    pub fn he_progress_bar_get_type() -> GType;
    pub fn he_progress_bar_new() -> *mut HeProgressBar;
    pub fn he_progress_bar_get_stop_indicator_visibility(self_: *mut HeProgressBar) -> gboolean;
    pub fn he_progress_bar_set_stop_indicator_visibility(
        self_: *mut HeProgressBar,
        value: gboolean,
    );
    pub fn he_progress_bar_get_is_osd(self_: *mut HeProgressBar) -> gboolean;
    pub fn he_progress_bar_set_is_osd(self_: *mut HeProgressBar, value: gboolean);

    //=========================================================================
    // HePropertyAnimationTarget
    //=========================================================================
    pub fn he_property_animation_target_get_type() -> GType;
    pub fn he_property_animation_target_new() -> *mut HePropertyAnimationTarget;
    pub fn he_property_animation_target_animate_property(
        self_: *mut HePropertyAnimationTarget,
        value: c_double,
    );
    pub fn he_property_animation_target_get_object(
        self_: *mut HePropertyAnimationTarget,
    ) -> *mut gobject::GObject;
    pub fn he_property_animation_target_set_object(
        self_: *mut HePropertyAnimationTarget,
        value: *mut gobject::GObject,
    );
    pub fn he_property_animation_target_get_pspec(
        self_: *mut HePropertyAnimationTarget,
    ) -> *mut gobject::GParamSpec;
    pub fn he_property_animation_target_set_pspec(
        self_: *mut HePropertyAnimationTarget,
        value: *mut gobject::GParamSpec,
    );

    //=========================================================================
    // HeQuantizer
    //=========================================================================
    pub fn he_quantizer_get_type() -> GType;
    pub fn he_quantizer_quantize(
        self_: *mut HeQuantizer,
        pixels: *mut c_int,
        pixels_length1: c_int,
        max_colors: c_int,
    ) -> *mut HeQuantizerResult;

    //=========================================================================
    // HeQuantizerCelebi
    //=========================================================================
    pub fn he_quantizer_celebi_get_type() -> GType;
    pub fn he_quantizer_celebi_new() -> *mut HeQuantizerCelebi;
    pub fn he_quantizer_celebi_quantize(
        self_: *mut HeQuantizerCelebi,
        pixels: *mut c_int,
        pixels_length1: c_int,
        max_colors: c_int,
    ) -> *mut glib::GHashTable;

    //=========================================================================
    // HeQuantizerMap
    //=========================================================================
    pub fn he_quantizer_map_get_type() -> GType;
    pub fn he_quantizer_map_get_color_to_count(self_: *mut HeQuantizerMap)
        -> *mut glib::GHashTable;
    pub fn he_quantizer_map_new() -> *mut HeQuantizerMap;

    //=========================================================================
    // HeQuantizerResult
    //=========================================================================
    pub fn he_quantizer_result_get_type() -> GType;
    pub fn he_quantizer_result_new(color_to_count: *mut glib::GHashTable)
        -> *mut HeQuantizerResult;

    //=========================================================================
    // HeQuantizerWsmeans
    //=========================================================================
    pub fn he_quantizer_wsmeans_get_type() -> GType;
    pub fn he_quantizer_wsmeans_quantize(
        input_pixels: *mut c_int,
        input_pixels_length1: c_int,
        starting_clusters: *mut c_int,
        starting_clusters_length1: c_int,
        max_colors: c_int,
    ) -> *mut glib::GHashTable;

    //=========================================================================
    // HeQuantizerWu
    //=========================================================================
    pub fn he_quantizer_wu_get_type() -> GType;
    pub fn he_quantizer_wu_new() -> *mut HeQuantizerWu;

    //=========================================================================
    // HeSaladScheme
    //=========================================================================
    pub fn he_salad_scheme_get_type() -> GType;
    pub fn he_salad_scheme_generate(
        self_: *mut HeSaladScheme,
        hct: *mut HeHCTColor,
        is_dark: gboolean,
        contrast: c_double,
    ) -> *mut HeDynamicScheme;
    pub fn he_salad_scheme_new() -> *mut HeSaladScheme;

    //=========================================================================
    // HeScheme
    //=========================================================================
    pub fn he_scheme_get_type() -> GType;
    pub fn he_scheme_new() -> *mut HeScheme;
    pub fn he_scheme_highest_surface(
        self_: *mut HeScheme,
        s: *mut HeDynamicScheme,
    ) -> *mut HeDynamicColor;
    pub fn he_scheme_primary_key(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_secondary_key(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_tertiary_key(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_neutral_key(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_neutral_variant_key(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_background(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_on_background(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_surface(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_surface_variant(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_on_surface(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_on_surface_variant(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_outline(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_outline_variant(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_inverse_surface(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_inverse_on_surface(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_inverse_primary(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_surface_bright(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_surface_dim(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_surface_container_lowest(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_surface_container_low(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_surface_container(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_surface_container_high(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_surface_container_highest(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_primary(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_on_primary(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_primary_container(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_on_primary_container(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_secondary(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_on_secondary(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_secondary_container(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_on_secondary_container(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_tertiary(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_on_tertiary(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_tertiary_container(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_on_tertiary_container(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_shadow(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_scrim(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_error(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_on_error(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_error_container(self_: *mut HeScheme) -> *mut HeDynamicColor;
    pub fn he_scheme_on_error_container(self_: *mut HeScheme) -> *mut HeDynamicColor;

    //=========================================================================
    // HeScore
    //=========================================================================
    pub fn he_score_get_type() -> GType;
    pub fn he_score_score(
        self_: *mut HeScore,
        colors_to_population: *mut glib::GHashTable,
        desired: *mut c_int,
    ) -> *mut glib::GArray;
    pub fn he_score_new() -> *mut HeScore;

    //=========================================================================
    // HeScoreAnnotatedColor
    //=========================================================================
    pub fn he_score_annotated_color_get_type() -> GType;
    pub fn he_score_annotated_color_new() -> *mut HeScoreAnnotatedColor;

    //=========================================================================
    // HeSegmentedButton
    //=========================================================================
    pub fn he_segmented_button_get_type() -> GType;
    pub fn he_segmented_button_add_child(
        self_: *mut HeSegmentedButton,
        builder: *mut gtk::GtkBuilder,
        child: *mut gobject::GObject,
        type_: *const c_char,
    );
    pub fn he_segmented_button_new() -> *mut HeSegmentedButton;

    //=========================================================================
    // HeSettingsList
    //=========================================================================
    pub fn he_settings_list_get_type() -> GType;
    pub fn he_settings_list_add(self_: *mut HeSettingsList, child: *mut gtk::GtkWidget);
    pub fn he_settings_list_remove(self_: *mut HeSettingsList, child: *mut gtk::GtkWidget);
    pub fn he_settings_list_new() -> *mut HeSettingsList;
    pub fn he_settings_list_get_title(self_: *mut HeSettingsList) -> *const c_char;
    pub fn he_settings_list_set_title(self_: *mut HeSettingsList, value: *const c_char);
    pub fn he_settings_list_get_description(self_: *mut HeSettingsList) -> *const c_char;
    pub fn he_settings_list_set_description(self_: *mut HeSettingsList, value: *const c_char);

    //=========================================================================
    // HeSettingsPage
    //=========================================================================
    pub fn he_settings_page_get_type() -> GType;
    pub fn he_settings_page_add_list(self_: *mut HeSettingsPage, list: *mut HeSettingsList);
    pub fn he_settings_page_new(title: *const c_char) -> *mut HeSettingsPage;
    pub fn he_settings_page_get_title(self_: *mut HeSettingsPage) -> *const c_char;
    pub fn he_settings_page_set_title(self_: *mut HeSettingsPage, value: *const c_char);

    //=========================================================================
    // HeSettingsRow
    //=========================================================================
    pub fn he_settings_row_get_type() -> GType;
    pub fn he_settings_row_add(self_: *mut HeSettingsRow, child: *mut gtk::GtkWidget);
    pub fn he_settings_row_new_with_details(
        title: *const c_char,
        subtitle: *const c_char,
        primary_button: *mut HeButton,
    ) -> *mut HeSettingsRow;
    pub fn he_settings_row_new() -> *mut HeSettingsRow;
    pub fn he_settings_row_get_title(self_: *mut HeSettingsRow) -> *const c_char;
    pub fn he_settings_row_set_title(self_: *mut HeSettingsRow, value: *const c_char);
    pub fn he_settings_row_get_subtitle(self_: *mut HeSettingsRow) -> *const c_char;
    pub fn he_settings_row_set_subtitle(self_: *mut HeSettingsRow, value: *const c_char);
    pub fn he_settings_row_get_icon(self_: *mut HeSettingsRow) -> *const c_char;
    pub fn he_settings_row_set_icon(self_: *mut HeSettingsRow, value: *const c_char);
    pub fn he_settings_row_set_gicon(self_: *mut HeSettingsRow, value: *mut gio::GIcon);
    pub fn he_settings_row_set_paintable(self_: *mut HeSettingsRow, value: *mut gdk::GdkPaintable);
    pub fn he_settings_row_get_primary_button(self_: *mut HeSettingsRow) -> *mut HeButton;
    pub fn he_settings_row_set_primary_button(self_: *mut HeSettingsRow, value: *mut HeButton);
    pub fn he_settings_row_get_activatable_widget(self_: *mut HeSettingsRow)
        -> *mut gtk::GtkWidget;
    pub fn he_settings_row_set_activatable_widget(
        self_: *mut HeSettingsRow,
        value: *mut gtk::GtkWidget,
    );

    //=========================================================================
    // HeSettingsWindow
    //=========================================================================
    pub fn he_settings_window_get_type() -> GType;
    pub fn he_settings_window_add_page(self_: *mut HeSettingsWindow, page: *mut HeSettingsPage);
    pub fn he_settings_window_add_list(self_: *mut HeSettingsWindow, list: *mut HeSettingsList);
    pub fn he_settings_window_new(parent: *mut gtk::GtkWindow) -> *mut HeSettingsWindow;

    //=========================================================================
    // HeSideBar
    //=========================================================================
    pub fn he_side_bar_get_type() -> GType;
    pub fn he_side_bar_new(title: *mut gtk::GtkWidget, subtitle: *const c_char) -> *mut HeSideBar;
    pub fn he_side_bar_get_title(self_: *mut HeSideBar) -> *mut gtk::GtkWidget;
    pub fn he_side_bar_set_title(self_: *mut HeSideBar, value: *mut gtk::GtkWidget);
    pub fn he_side_bar_get_titlewidget(self_: *mut HeSideBar) -> *mut gtk::GtkWidget;
    pub fn he_side_bar_set_titlewidget(self_: *mut HeSideBar, value: *mut gtk::GtkWidget);
    pub fn he_side_bar_get_subtitle(self_: *mut HeSideBar) -> *const c_char;
    pub fn he_side_bar_set_subtitle(self_: *mut HeSideBar, value: *const c_char);
    pub fn he_side_bar_get_show_right_title_buttons(self_: *mut HeSideBar) -> gboolean;
    pub fn he_side_bar_set_show_right_title_buttons(self_: *mut HeSideBar, value: gboolean);
    pub fn he_side_bar_get_show_left_title_buttons(self_: *mut HeSideBar) -> gboolean;
    pub fn he_side_bar_set_show_left_title_buttons(self_: *mut HeSideBar, value: gboolean);
    pub fn he_side_bar_get_show_back(self_: *mut HeSideBar) -> gboolean;
    pub fn he_side_bar_set_show_back(self_: *mut HeSideBar, value: gboolean);
    pub fn he_side_bar_get_stack(self_: *mut HeSideBar) -> *mut gtk::GtkStack;
    pub fn he_side_bar_set_stack(self_: *mut HeSideBar, value: *mut gtk::GtkStack);
    pub fn he_side_bar_get_scroller(self_: *mut HeSideBar) -> *mut gtk::GtkScrolledWindow;
    pub fn he_side_bar_set_scroller(self_: *mut HeSideBar, value: *mut gtk::GtkScrolledWindow);
    pub fn he_side_bar_get_has_margins(self_: *mut HeSideBar) -> gboolean;
    pub fn he_side_bar_set_has_margins(self_: *mut HeSideBar, value: gboolean);

    //=========================================================================
    // HeSlider
    //=========================================================================
    pub fn he_slider_get_type() -> GType;
    pub fn he_slider_new() -> *mut HeSlider;
    pub fn he_slider_add_mark(self_: *mut HeSlider, value: c_double, text: *const c_char);
    pub fn he_slider_get_left_icon(self_: *mut HeSlider) -> *const c_char;
    pub fn he_slider_set_left_icon(self_: *mut HeSlider, value: *const c_char);
    pub fn he_slider_get_right_icon(self_: *mut HeSlider) -> *const c_char;
    pub fn he_slider_set_right_icon(self_: *mut HeSlider, value: *const c_char);
    pub fn he_slider_get_stop_indicator_visibility(self_: *mut HeSlider) -> gboolean;
    pub fn he_slider_set_stop_indicator_visibility(self_: *mut HeSlider, value: gboolean);

    //=========================================================================
    // HeSpringAnimation
    //=========================================================================
    pub fn he_spring_animation_get_type() -> GType;
    pub fn he_spring_animation_new(
        widget: *mut gtk::GtkWidget,
        from: c_double,
        to: c_double,
        sparams: *mut HeSpringParams,
        target: *mut HeAnimationTarget,
    ) -> *mut HeSpringAnimation;
    pub fn he_spring_animation_get_epsilon(self_: *mut HeSpringAnimation) -> c_double;
    pub fn he_spring_animation_set_epsilon(self_: *mut HeSpringAnimation, value: c_double);
    pub fn he_spring_animation_get_estimated_duration(self_: *mut HeSpringAnimation) -> c_uint;
    pub fn he_spring_animation_set_estimated_duration(self_: *mut HeSpringAnimation, value: c_uint);
    pub fn he_spring_animation_get_initial_velocity(self_: *mut HeSpringAnimation) -> c_double;
    pub fn he_spring_animation_set_initial_velocity(self_: *mut HeSpringAnimation, value: c_double);
    pub fn he_spring_animation_get_latch(self_: *mut HeSpringAnimation) -> gboolean;
    pub fn he_spring_animation_set_latch(self_: *mut HeSpringAnimation, value: gboolean);
    pub fn he_spring_animation_get_spring_params(
        self_: *mut HeSpringAnimation,
    ) -> *mut HeSpringParams;
    pub fn he_spring_animation_set_spring_params(
        self_: *mut HeSpringAnimation,
        value: *mut HeSpringParams,
    );
    pub fn he_spring_animation_get_value_from(self_: *mut HeSpringAnimation) -> c_double;
    pub fn he_spring_animation_set_value_from(self_: *mut HeSpringAnimation, value: c_double);
    pub fn he_spring_animation_get_value_to(self_: *mut HeSpringAnimation) -> c_double;
    pub fn he_spring_animation_set_value_to(self_: *mut HeSpringAnimation, value: c_double);
    pub fn he_spring_animation_get_velocity(self_: *mut HeSpringAnimation) -> c_double;
    pub fn he_spring_animation_set_velocity(self_: *mut HeSpringAnimation, value: c_double);

    //=========================================================================
    // HeSpringParams
    //=========================================================================
    pub fn he_spring_params_get_type() -> GType;
    pub fn he_spring_params_new(
        damping_ratio: c_double,
        mass: c_double,
        stiffness: c_double,
    ) -> *mut HeSpringParams;
    pub fn he_spring_params_new_full(
        damping: c_double,
        mass: c_double,
        stiffness: c_double,
    ) -> *mut HeSpringParams;
    pub fn he_spring_params_get_damping(self_: *mut HeSpringParams) -> c_double;
    pub fn he_spring_params_set_damping(self_: *mut HeSpringParams, value: c_double);
    pub fn he_spring_params_get_damping_ratio(self_: *mut HeSpringParams) -> c_double;
    pub fn he_spring_params_set_damping_ratio(self_: *mut HeSpringParams, value: c_double);
    pub fn he_spring_params_get_mass(self_: *mut HeSpringParams) -> c_double;
    pub fn he_spring_params_set_mass(self_: *mut HeSpringParams, value: c_double);
    pub fn he_spring_params_get_stiffness(self_: *mut HeSpringParams) -> c_double;
    pub fn he_spring_params_set_stiffness(self_: *mut HeSpringParams, value: c_double);

    //=========================================================================
    // HeStyleManager
    //=========================================================================
    pub fn he_style_manager_get_type() -> GType;
    pub fn he_style_manager_update(self_: *mut HeStyleManager);
    pub fn he_style_manager_style_refresh(
        self_: *mut HeStyleManager,
        scheme_factory: *mut HeDynamicScheme,
    ) -> *mut c_char;
    pub fn he_style_manager_weight_refresh(
        self_: *mut HeStyleManager,
        font_weight: c_double,
    ) -> *mut c_char;
    pub fn he_style_manager_register(self_: *mut HeStyleManager);
    pub fn he_style_manager_unregister(self_: *mut HeStyleManager);
    pub fn he_style_manager_new() -> *mut HeStyleManager;
    pub fn he_style_manager_get_is_registered(self_: *mut HeStyleManager) -> gboolean;
    pub fn he_style_manager_get_user_base(self_: *mut HeStyleManager) -> *mut gtk::GtkCssProvider;
    pub fn he_style_manager_get_user_dark(self_: *mut HeStyleManager) -> *mut gtk::GtkCssProvider;

    //=========================================================================
    // HeSwitch
    //=========================================================================
    pub fn he_switch_get_type() -> GType;
    pub fn he_switch_new() -> *mut HeSwitch;
    pub fn he_switch_get_left_icon(self_: *mut HeSwitch) -> *const c_char;
    pub fn he_switch_set_left_icon(self_: *mut HeSwitch, value: *const c_char);
    pub fn he_switch_get_right_icon(self_: *mut HeSwitch) -> *const c_char;
    pub fn he_switch_set_right_icon(self_: *mut HeSwitch, value: *const c_char);

    //=========================================================================
    // HeSwitchBar
    //=========================================================================
    pub fn he_switch_bar_get_type() -> GType;
    pub fn he_switch_bar_new() -> *mut HeSwitchBar;
    pub fn he_switch_bar_get_title(self_: *mut HeSwitchBar) -> *const c_char;
    pub fn he_switch_bar_set_title(self_: *mut HeSwitchBar, value: *const c_char);
    pub fn he_switch_bar_get_subtitle(self_: *mut HeSwitchBar) -> *const c_char;
    pub fn he_switch_bar_set_subtitle(self_: *mut HeSwitchBar, value: *const c_char);
    pub fn he_switch_bar_get_sensitive_widget(self_: *mut HeSwitchBar) -> *mut gtk::GtkWidget;
    pub fn he_switch_bar_set_sensitive_widget(self_: *mut HeSwitchBar, value: *mut gtk::GtkWidget);

    //=========================================================================
    // HeTab
    //=========================================================================
    pub fn he_tab_get_type() -> GType;
    pub fn he_tab_new(label: *const c_char, page: *mut gtk::GtkWidget) -> *mut HeTab;
    pub fn he_tab_get_label(self_: *mut HeTab) -> *const c_char;
    pub fn he_tab_set_label(self_: *mut HeTab, value: *const c_char);
    pub fn he_tab_set_tooltip(self_: *mut HeTab, value: *const c_char);
    pub fn he_tab_get_pinned(self_: *mut HeTab) -> gboolean;
    pub fn he_tab_set_pinned(self_: *mut HeTab, value: gboolean);
    pub fn he_tab_get_can_pin(self_: *mut HeTab) -> gboolean;
    pub fn he_tab_set_can_pin(self_: *mut HeTab, value: gboolean);
    pub fn he_tab_get_can_close(self_: *mut HeTab) -> gboolean;
    pub fn he_tab_set_can_close(self_: *mut HeTab, value: gboolean);
    pub fn he_tab_get_page(self_: *mut HeTab) -> *mut gtk::GtkWidget;
    pub fn he_tab_set_page(self_: *mut HeTab, value: *mut gtk::GtkWidget);
    pub fn he_tab_get_menu(self_: *mut HeTab) -> *mut gio::GMenu;
    pub fn he_tab_get_actions(self_: *mut HeTab) -> *mut gio::GSimpleActionGroup;

    //=========================================================================
    // HeTabPage
    //=========================================================================
    pub fn he_tab_page_get_type() -> GType;
    pub fn he_tab_page_new(tab: *mut HeTab) -> *mut HeTabPage;
    pub fn he_tab_page_get_tab(self_: *mut HeTabPage) -> *mut HeTab;
    pub fn he_tab_page_set_tab(self_: *mut HeTabPage, value: *mut HeTab);

    //=========================================================================
    // HeTabSwitcher
    //=========================================================================
    pub fn he_tab_switcher_get_type() -> GType;
    pub fn he_tab_switcher_get_tab_position(self_: *mut HeTabSwitcher, tab: *mut HeTab) -> c_int;
    pub fn he_tab_switcher_insert_tab(
        self_: *mut HeTabSwitcher,
        tab: *mut HeTab,
        index: c_int,
    ) -> c_uint;
    pub fn he_tab_switcher_remove_tab(self_: *mut HeTabSwitcher, tab: *mut HeTab);
    pub fn he_tab_switcher_new() -> *mut HeTabSwitcher;
    pub fn he_tab_switcher_get_n_tabs(self_: *mut HeTabSwitcher) -> c_int;
    pub fn he_tab_switcher_get_tabs(self_: *mut HeTabSwitcher) -> *mut glib::GList;
    pub fn he_tab_switcher_get_tab_bar_behavior(
        self_: *mut HeTabSwitcher,
    ) -> HeTabSwitcherTabBarBehavior;
    pub fn he_tab_switcher_set_tab_bar_behavior(
        self_: *mut HeTabSwitcher,
        value: HeTabSwitcherTabBarBehavior,
    );
    pub fn he_tab_switcher_get_allow_duplicate_tabs(self_: *mut HeTabSwitcher) -> gboolean;
    pub fn he_tab_switcher_set_allow_duplicate_tabs(self_: *mut HeTabSwitcher, value: gboolean);
    pub fn he_tab_switcher_get_allow_drag(self_: *mut HeTabSwitcher) -> gboolean;
    pub fn he_tab_switcher_set_allow_drag(self_: *mut HeTabSwitcher, value: gboolean);
    pub fn he_tab_switcher_get_allow_pinning(self_: *mut HeTabSwitcher) -> gboolean;
    pub fn he_tab_switcher_set_allow_pinning(self_: *mut HeTabSwitcher, value: gboolean);
    pub fn he_tab_switcher_get_allow_closing(self_: *mut HeTabSwitcher) -> gboolean;
    pub fn he_tab_switcher_set_allow_closing(self_: *mut HeTabSwitcher, value: gboolean);
    pub fn he_tab_switcher_get_allow_new_window(self_: *mut HeTabSwitcher) -> gboolean;
    pub fn he_tab_switcher_set_allow_new_window(self_: *mut HeTabSwitcher, value: gboolean);
    pub fn he_tab_switcher_get_current(self_: *mut HeTabSwitcher) -> *mut HeTab;
    pub fn he_tab_switcher_set_current(self_: *mut HeTabSwitcher, value: *mut HeTab);
    pub fn he_tab_switcher_get_menu(self_: *mut HeTabSwitcher) -> *mut gio::GMenu;
    pub fn he_tab_switcher_get_actions(self_: *mut HeTabSwitcher) -> *mut gio::GSimpleActionGroup;

    //=========================================================================
    // HeTemperatureCache
    //=========================================================================
    pub fn he_temperature_cache_get_type() -> GType;
    pub fn he_temperature_cache_new(input: *mut HeHCTColor) -> *mut HeTemperatureCache;
    pub fn he_temperature_cache_get_hcts_by_temp(
        self_: *mut HeTemperatureCache,
    ) -> *mut glib::GList;
    pub fn he_temperature_cache_diff_temps(
        self_: *mut HeTemperatureCache,
        a: *mut HeHCTColor,
        b: *mut HeHCTColor,
    ) -> c_int;
    pub fn he_temperature_cache_get_warmest(
        self_: *mut HeTemperatureCache,
        result: *mut HeHCTColor,
    );
    pub fn he_temperature_cache_get_coldest(
        self_: *mut HeTemperatureCache,
        result: *mut HeHCTColor,
    );
    pub fn he_temperature_cache_get_complement(
        self_: *mut HeTemperatureCache,
        result: *mut HeHCTColor,
    );
    pub fn he_temperature_cache_analogous(
        self_: *mut HeTemperatureCache,
        count: c_int,
        divisions: c_int,
    ) -> *mut glib::GList;
    pub fn he_temperature_cache_get_input_relative_temperature(
        self_: *mut HeTemperatureCache,
    ) -> c_double;
    pub fn he_temperature_cache_get_temp(
        self_: *mut HeTemperatureCache,
        hct: *mut HeHCTColor,
    ) -> c_double;
    pub fn he_temperature_cache_get_input(self_: *mut HeTemperatureCache, result: *mut HeHCTColor);
    pub fn he_temperature_cache_set_input(self_: *mut HeTemperatureCache, value: *mut HeHCTColor);

    //=========================================================================
    // HeTextField
    //=========================================================================
    pub fn he_text_field_get_type() -> GType;
    pub fn he_text_field_get_internal_entry(self_: *mut HeTextField) -> *mut gtk::GtkText;
    pub fn he_text_field_new_from_regex(regex_arg: *mut glib::GRegex) -> *mut HeTextField;
    pub fn he_text_field_new() -> *mut HeTextField;
    pub fn he_text_field_get_is_valid(self_: *mut HeTextField) -> gboolean;
    pub fn he_text_field_set_is_valid(self_: *mut HeTextField, value: gboolean);
    pub fn he_text_field_get_needs_validation(self_: *mut HeTextField) -> gboolean;
    pub fn he_text_field_set_needs_validation(self_: *mut HeTextField, value: gboolean);
    pub fn he_text_field_get_min_length(self_: *mut HeTextField) -> c_int;
    pub fn he_text_field_set_min_length(self_: *mut HeTextField, value: c_int);
    pub fn he_text_field_get_regex(self_: *mut HeTextField) -> *mut glib::GRegex;
    pub fn he_text_field_set_regex(self_: *mut HeTextField, value: *mut glib::GRegex);
    pub fn he_text_field_get_is_search(self_: *mut HeTextField) -> gboolean;
    pub fn he_text_field_set_is_search(self_: *mut HeTextField, value: gboolean);
    pub fn he_text_field_get_is_outline(self_: *mut HeTextField) -> gboolean;
    pub fn he_text_field_set_is_outline(self_: *mut HeTextField, value: gboolean);
    pub fn he_text_field_get_entry(self_: *mut HeTextField) -> *mut gtk::GtkText;
    pub fn he_text_field_get_text(self_: *mut HeTextField) -> *const c_char;
    pub fn he_text_field_set_text(self_: *mut HeTextField, value: *const c_char);
    pub fn he_text_field_get_suffix_icon(self_: *mut HeTextField) -> *const c_char;
    pub fn he_text_field_set_suffix_icon(self_: *mut HeTextField, value: *const c_char);
    pub fn he_text_field_get_prefix_icon(self_: *mut HeTextField) -> *const c_char;
    pub fn he_text_field_set_prefix_icon(self_: *mut HeTextField, value: *const c_char);
    pub fn he_text_field_get_support_text(self_: *mut HeTextField) -> *const c_char;
    pub fn he_text_field_set_support_text(self_: *mut HeTextField, value: *const c_char);
    pub fn he_text_field_get_placeholder_text(self_: *mut HeTextField) -> *const c_char;
    pub fn he_text_field_set_placeholder_text(self_: *mut HeTextField, value: *const c_char);
    pub fn he_text_field_get_max_length(self_: *mut HeTextField) -> c_int;
    pub fn he_text_field_set_max_length(self_: *mut HeTextField, value: c_int);
    pub fn he_text_field_get_visibility(self_: *mut HeTextField) -> gboolean;
    pub fn he_text_field_set_visibility(self_: *mut HeTextField, value: gboolean);

    //=========================================================================
    // HeTimePicker
    //=========================================================================
    pub fn he_time_picker_get_type() -> GType;
    pub fn he_time_picker_new_with_format(
        format_12: *const c_char,
        format_24: *const c_char,
    ) -> *mut HeTimePicker;
    pub fn he_time_picker_new() -> *mut HeTimePicker;
    pub fn he_time_picker_get_format_12(self_: *mut HeTimePicker) -> *const c_char;
    pub fn he_time_picker_get_format_24(self_: *mut HeTimePicker) -> *const c_char;
    pub fn he_time_picker_get_time(self_: *mut HeTimePicker) -> *mut glib::GDateTime;
    pub fn he_time_picker_set_time(self_: *mut HeTimePicker, value: *mut glib::GDateTime);

    //=========================================================================
    // HeTimedAnimation
    //=========================================================================
    pub fn he_timed_animation_get_type() -> GType;
    pub fn he_timed_animation_new(
        widget: *mut gtk::GtkWidget,
        from: c_double,
        to: c_double,
        duration: c_uint,
        target: *mut HeAnimationTarget,
    ) -> *mut HeTimedAnimation;
    pub fn he_timed_animation_get_value_from(self_: *mut HeTimedAnimation) -> c_double;
    pub fn he_timed_animation_set_value_from(self_: *mut HeTimedAnimation, value: c_double);
    pub fn he_timed_animation_get_value_to(self_: *mut HeTimedAnimation) -> c_double;
    pub fn he_timed_animation_set_value_to(self_: *mut HeTimedAnimation, value: c_double);
    pub fn he_timed_animation_get_duration(self_: *mut HeTimedAnimation) -> c_uint;
    pub fn he_timed_animation_set_duration(self_: *mut HeTimedAnimation, value: c_uint);
    pub fn he_timed_animation_get_easing(self_: *mut HeTimedAnimation) -> HeEasing;
    pub fn he_timed_animation_set_easing(self_: *mut HeTimedAnimation, value: HeEasing);
    pub fn he_timed_animation_get_repeat_count(self_: *mut HeTimedAnimation) -> c_uint;
    pub fn he_timed_animation_set_repeat_count(self_: *mut HeTimedAnimation, value: c_uint);
    pub fn he_timed_animation_get_reverse(self_: *mut HeTimedAnimation) -> gboolean;
    pub fn he_timed_animation_set_reverse(self_: *mut HeTimedAnimation, value: gboolean);
    pub fn he_timed_animation_get_alternate(self_: *mut HeTimedAnimation) -> gboolean;
    pub fn he_timed_animation_set_alternate(self_: *mut HeTimedAnimation, value: gboolean);

    //=========================================================================
    // HeTip
    //=========================================================================
    pub fn he_tip_get_type() -> GType;
    pub fn he_tip_new(
        title: *const c_char,
        image: *const c_char,
        message: *const c_char,
        action_label: *const c_char,
    ) -> *mut HeTip;
    pub fn he_tip_get_title(self_: *mut HeTip) -> *const c_char;
    pub fn he_tip_set_title(self_: *mut HeTip, value: *const c_char);
    pub fn he_tip_get_image(self_: *mut HeTip) -> *const c_char;
    pub fn he_tip_set_image(self_: *mut HeTip, value: *const c_char);
    pub fn he_tip_get_message(self_: *mut HeTip) -> *const c_char;
    pub fn he_tip_set_message(self_: *mut HeTip, value: *const c_char);
    pub fn he_tip_get_action_label(self_: *mut HeTip) -> *const c_char;
    pub fn he_tip_set_action_label(self_: *mut HeTip, value: *const c_char);

    //=========================================================================
    // HeTipView
    //=========================================================================
    pub fn he_tip_view_get_type() -> GType;
    pub fn he_tip_view_new(tip: *mut HeTip, tip_style: *mut HeTipViewStyle) -> *mut HeTipView;
    pub fn he_tip_view_get_tip_style(self_: *mut HeTipView) -> HeTipViewStyle;
    pub fn he_tip_view_set_tip_style(self_: *mut HeTipView, value: HeTipViewStyle);
    pub fn he_tip_view_get_tip(self_: *mut HeTipView) -> *mut HeTip;
    pub fn he_tip_view_set_tip(self_: *mut HeTipView, value: *mut HeTip);

    //=========================================================================
    // HeToast
    //=========================================================================
    pub fn he_toast_get_type() -> GType;
    pub fn he_toast_new(label: *const c_char) -> *mut HeToast;
    pub fn he_toast_send_notification(self_: *mut HeToast);
    pub fn he_toast_get_label(self_: *mut HeToast) -> *const c_char;
    pub fn he_toast_set_label(self_: *mut HeToast, value: *const c_char);
    pub fn he_toast_get_default_action(self_: *mut HeToast) -> *const c_char;
    pub fn he_toast_set_default_action(self_: *mut HeToast, value: *const c_char);

    //=========================================================================
    // HeTonalPalette
    //=========================================================================
    pub fn he_tonal_palette_get_type() -> GType;
    pub fn he_tonal_palette_new(
        hue: c_double,
        chroma: c_double,
        key_color: *mut HeHCTColor,
    ) -> *mut HeTonalPalette;
    pub fn he_tonal_palette_from_int(argb: c_int) -> *mut HeTonalPalette;
    pub fn he_tonal_palette_from_hct(hct: *mut HeHCTColor) -> *mut HeTonalPalette;
    pub fn he_tonal_palette_from_hue_and_chroma(
        hue: c_double,
        chroma: c_double,
    ) -> *mut HeTonalPalette;
    pub fn he_tonal_palette_get_tone(self_: *mut HeTonalPalette, tone: c_int) -> c_int;
    pub fn he_tonal_palette_get_hct(
        self_: *mut HeTonalPalette,
        tone: c_double,
        result: *mut HeHCTColor,
    );
    pub fn he_tonal_palette_get_hue(self_: *mut HeTonalPalette) -> c_double;
    pub fn he_tonal_palette_set_hue(self_: *mut HeTonalPalette, value: c_double);
    pub fn he_tonal_palette_get_chroma(self_: *mut HeTonalPalette) -> c_double;
    pub fn he_tonal_palette_set_chroma(self_: *mut HeTonalPalette, value: c_double);
    pub fn he_tonal_palette_get_key_color(self_: *mut HeTonalPalette, result: *mut HeHCTColor);
    pub fn he_tonal_palette_set_key_color(self_: *mut HeTonalPalette, value: *mut HeHCTColor);

    //=========================================================================
    // HeToneDeltaPair
    //=========================================================================
    pub fn he_tone_delta_pair_get_type() -> GType;
    pub fn he_tone_delta_pair_new(
        role_a: *mut HeDynamicColor,
        role_b: *mut HeDynamicColor,
        delta: c_double,
        polarity: *mut HeTonePolarity,
        stay_together: gboolean,
    ) -> *mut HeToneDeltaPair;

    //=========================================================================
    // HeVibrantScheme
    //=========================================================================
    pub fn he_vibrant_scheme_get_type() -> GType;
    pub fn he_vibrant_scheme_generate(
        self_: *mut HeVibrantScheme,
        hct: *mut HeHCTColor,
        is_dark: gboolean,
        contrast: c_double,
    ) -> *mut HeDynamicScheme;
    pub fn he_vibrant_scheme_new() -> *mut HeVibrantScheme;

    //=========================================================================
    // HeView
    //=========================================================================
    pub fn he_view_get_type() -> GType;
    pub fn he_view_add_child(
        self_: *mut HeView,
        builder: *mut gtk::GtkBuilder,
        child: *mut gobject::GObject,
        type_: *const c_char,
    );
    pub fn he_view_add(self_: *mut HeView, widget: *mut gtk::GtkWidget);
    pub fn he_view_get_title(self_: *mut HeView) -> *const c_char;
    pub fn he_view_set_title(self_: *mut HeView, value: *const c_char);
    pub fn he_view_get_stack(self_: *mut HeView) -> *mut gtk::GtkStack;
    pub fn he_view_set_stack(self_: *mut HeView, value: *mut gtk::GtkStack);
    pub fn he_view_get_subtitle(self_: *mut HeView) -> *const c_char;
    pub fn he_view_set_subtitle(self_: *mut HeView, value: *const c_char);
    pub fn he_view_get_has_margins(self_: *mut HeView) -> gboolean;
    pub fn he_view_set_has_margins(self_: *mut HeView, value: gboolean);

    //=========================================================================
    // HeViewAux
    //=========================================================================
    pub fn he_view_aux_get_type() -> GType;
    pub fn he_view_aux_new() -> *mut HeViewAux;
    pub fn he_view_aux_get_show_aux(self_: *mut HeViewAux) -> gboolean;
    pub fn he_view_aux_set_show_aux(self_: *mut HeViewAux, value: gboolean);

    //=========================================================================
    // HeViewChooser
    //=========================================================================
    pub fn he_view_chooser_get_type() -> GType;
    pub fn he_view_chooser_new() -> *mut HeViewChooser;
    pub fn he_view_chooser_stack_clear(self_: *mut HeViewChooser);
    pub fn he_view_chooser_get_stack(self_: *mut HeViewChooser) -> *mut gtk::GtkStack;
    pub fn he_view_chooser_set_stack(self_: *mut HeViewChooser, value: *mut gtk::GtkStack);

    //=========================================================================
    // HeViewDual
    //=========================================================================
    pub fn he_view_dual_get_type() -> GType;
    pub fn he_view_dual_new(
        orientation: gtk::GtkOrientation,
        show_handle: gboolean,
    ) -> *mut HeViewDual;
    pub fn he_view_dual_get_orientation(self_: *mut HeViewDual) -> gtk::GtkOrientation;
    pub fn he_view_dual_set_orientation(self_: *mut HeViewDual, value: gtk::GtkOrientation);
    pub fn he_view_dual_get_show_handle(self_: *mut HeViewDual) -> gboolean;
    pub fn he_view_dual_set_show_handle(self_: *mut HeViewDual, value: gboolean);
    pub fn he_view_dual_get_child_start(self_: *mut HeViewDual) -> *mut gtk::GtkWidget;
    pub fn he_view_dual_set_child_start(self_: *mut HeViewDual, value: *mut gtk::GtkWidget);
    pub fn he_view_dual_get_child_end(self_: *mut HeViewDual) -> *mut gtk::GtkWidget;
    pub fn he_view_dual_set_child_end(self_: *mut HeViewDual, value: *mut gtk::GtkWidget);

    //=========================================================================
    // HeViewMono
    //=========================================================================
    pub fn he_view_mono_get_type() -> GType;
    pub fn he_view_mono_new(title: *mut gtk::GtkWidget, subtitle: *const c_char)
        -> *mut HeViewMono;
    pub fn he_view_mono_add_titlebar_button(self_: *mut HeViewMono, child: *mut gtk::GtkButton);
    pub fn he_view_mono_add_titlebar_menu(self_: *mut HeViewMono, child: *mut gtk::GtkMenuButton);
    pub fn he_view_mono_add_titlebar_toggle(
        self_: *mut HeViewMono,
        child: *mut gtk::GtkToggleButton,
    );
    pub fn he_view_mono_append(self_: *mut HeViewMono, child: *mut gtk::GtkWidget);
    pub fn he_view_mono_get_title(self_: *mut HeViewMono) -> *mut gtk::GtkWidget;
    pub fn he_view_mono_set_title(self_: *mut HeViewMono, value: *mut gtk::GtkWidget);
    pub fn he_view_mono_get_titlewidget(self_: *mut HeViewMono) -> *mut gtk::GtkWidget;
    pub fn he_view_mono_set_titlewidget(self_: *mut HeViewMono, value: *mut gtk::GtkWidget);
    pub fn he_view_mono_get_subtitle(self_: *mut HeViewMono) -> *const c_char;
    pub fn he_view_mono_set_subtitle(self_: *mut HeViewMono, value: *const c_char);
    pub fn he_view_mono_get_show_right_title_buttons(self_: *mut HeViewMono) -> gboolean;
    pub fn he_view_mono_set_show_right_title_buttons(self_: *mut HeViewMono, value: gboolean);
    pub fn he_view_mono_get_show_left_title_buttons(self_: *mut HeViewMono) -> gboolean;
    pub fn he_view_mono_set_show_left_title_buttons(self_: *mut HeViewMono, value: gboolean);
    pub fn he_view_mono_get_show_back(self_: *mut HeViewMono) -> gboolean;
    pub fn he_view_mono_set_show_back(self_: *mut HeViewMono, value: gboolean);
    pub fn he_view_mono_get_stack(self_: *mut HeViewMono) -> *mut gtk::GtkStack;
    pub fn he_view_mono_set_stack(self_: *mut HeViewMono, value: *mut gtk::GtkStack);
    pub fn he_view_mono_get_scroller(self_: *mut HeViewMono) -> *mut gtk::GtkScrolledWindow;
    pub fn he_view_mono_set_scroller(self_: *mut HeViewMono, value: *mut gtk::GtkScrolledWindow);
    pub fn he_view_mono_get_has_margins(self_: *mut HeViewMono) -> gboolean;
    pub fn he_view_mono_set_has_margins(self_: *mut HeViewMono, value: gboolean);

    //=========================================================================
    // HeViewSubTitle
    //=========================================================================
    pub fn he_view_sub_title_get_type() -> GType;
    pub fn he_view_sub_title_new() -> *mut HeViewSubTitle;
    pub fn he_view_sub_title_get_label(self_: *mut HeViewSubTitle) -> *const c_char;
    pub fn he_view_sub_title_set_label(self_: *mut HeViewSubTitle, value: *const c_char);

    //=========================================================================
    // HeViewSwitcher
    //=========================================================================
    pub fn he_view_switcher_get_type() -> GType;
    pub fn he_view_switcher_new() -> *mut HeViewSwitcher;
    pub fn he_view_switcher_get_stack(self_: *mut HeViewSwitcher) -> *mut gtk::GtkStack;
    pub fn he_view_switcher_set_stack(self_: *mut HeViewSwitcher, value: *mut gtk::GtkStack);

    //=========================================================================
    // HeViewTitle
    //=========================================================================
    pub fn he_view_title_get_type() -> GType;
    pub fn he_view_title_new() -> *mut HeViewTitle;
    pub fn he_view_title_get_label(self_: *mut HeViewTitle) -> *const c_char;
    pub fn he_view_title_set_label(self_: *mut HeViewTitle, value: *const c_char);

    //=========================================================================
    // HeViewingConditions
    //=========================================================================
    pub fn he_viewing_conditions_get_type() -> GType;
    pub fn he_viewing_conditions_lerp(
        start: c_double,
        stop: c_double,
        amount: c_double,
    ) -> c_double;
    pub fn he_viewing_conditions_make(
        white_point: *mut c_double,
        white_point_length1: c_int,
        adapting_luminance: c_double,
        bg_lstar: c_double,
        surround: c_double,
        discount_illuminant: gboolean,
    ) -> *mut HeViewingConditions;
    pub fn he_viewing_conditions_with_lstar(lstar: c_double) -> *mut HeViewingConditions;
    pub fn he_viewing_conditions_get_aw(self_: *mut HeViewingConditions) -> c_double;
    pub fn he_viewing_conditions_set_aw(self_: *mut HeViewingConditions, value: c_double);
    pub fn he_viewing_conditions_get_nbb(self_: *mut HeViewingConditions) -> c_double;
    pub fn he_viewing_conditions_set_nbb(self_: *mut HeViewingConditions, value: c_double);
    pub fn he_viewing_conditions_get_ncb(self_: *mut HeViewingConditions) -> c_double;
    pub fn he_viewing_conditions_set_ncb(self_: *mut HeViewingConditions, value: c_double);
    pub fn he_viewing_conditions_get_c(self_: *mut HeViewingConditions) -> c_double;
    pub fn he_viewing_conditions_set_c(self_: *mut HeViewingConditions, value: c_double);
    pub fn he_viewing_conditions_get_nc(self_: *mut HeViewingConditions) -> c_double;
    pub fn he_viewing_conditions_set_nc(self_: *mut HeViewingConditions, value: c_double);
    pub fn he_viewing_conditions_get_n(self_: *mut HeViewingConditions) -> c_double;
    pub fn he_viewing_conditions_set_n(self_: *mut HeViewingConditions, value: c_double);
    pub fn he_viewing_conditions_get_fl(self_: *mut HeViewingConditions) -> c_double;
    pub fn he_viewing_conditions_set_fl(self_: *mut HeViewingConditions, value: c_double);
    pub fn he_viewing_conditions_get_fl_root(self_: *mut HeViewingConditions) -> c_double;
    pub fn he_viewing_conditions_set_fl_root(self_: *mut HeViewingConditions, value: c_double);
    pub fn he_viewing_conditions_get_z(self_: *mut HeViewingConditions) -> c_double;
    pub fn he_viewing_conditions_set_z(self_: *mut HeViewingConditions, value: c_double);

    //=========================================================================
    // HeWelcomeScreen
    //=========================================================================
    pub fn he_welcome_screen_get_type() -> GType;
    pub fn he_welcome_screen_add_child(
        self_: *mut HeWelcomeScreen,
        builder: *mut gtk::GtkBuilder,
        child: *mut gobject::GObject,
        type_: *const c_char,
    );
    pub fn he_welcome_screen_new(
        appname: *const c_char,
        description: *const c_char,
    ) -> *mut HeWelcomeScreen;
    pub fn he_welcome_screen_get_appname(self_: *mut HeWelcomeScreen) -> *const c_char;
    pub fn he_welcome_screen_set_appname(self_: *mut HeWelcomeScreen, value: *const c_char);
    pub fn he_welcome_screen_get_description(self_: *mut HeWelcomeScreen) -> *const c_char;
    pub fn he_welcome_screen_set_description(self_: *mut HeWelcomeScreen, value: *const c_char);

    //=========================================================================
    // HeWindow
    //=========================================================================
    pub fn he_window_get_type() -> GType;
    pub fn he_window_new() -> *mut HeWindow;
    pub fn he_window_get_parent(self_: *mut HeWindow) -> *mut gtk::GtkWindow;
    pub fn he_window_set_parent(self_: *mut HeWindow, value: *mut gtk::GtkWindow);
    pub fn he_window_get_has_title(self_: *mut HeWindow) -> gboolean;
    pub fn he_window_set_has_title(self_: *mut HeWindow, value: gboolean);
    pub fn he_window_get_has_back_button(self_: *mut HeWindow) -> gboolean;
    pub fn he_window_set_has_back_button(self_: *mut HeWindow, value: gboolean);

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn he_ensor_accent_from_pixels_async(
        pixels: *mut u8,
        pixels_length1: c_int,
        alpha: gboolean,
        _callback_: gio::GAsyncReadyCallback,
        _callback__target: *mut c_void,
    );
    pub fn he_ensor_accent_from_pixels_finish(_res_: *mut gio::GAsyncResult) -> *mut glib::GArray;
    pub fn he_math_utils_clamp_double(min: c_double, max: c_double, input: c_double) -> c_double;
    pub fn he_math_utils_signum(x: c_double) -> c_int;
    pub fn he_math_utils_to_degrees(radians: c_double) -> c_double;
    pub fn he_math_utils_to_radians(degrees: c_double) -> c_double;
    pub fn he_math_utils_chromatic_adaptation(component: c_double) -> c_double;
    pub fn he_math_utils_inverse_chromatic_adaptation(adapted: c_double) -> c_double;
    pub fn he_math_utils_lerp_point(
        source: *mut c_double,
        source_length1: c_int,
        t: c_double,
        target: *mut c_double,
        target_length1: c_int,
        result_length1: *mut c_int,
    ) -> *mut c_double;
    pub fn he_math_utils_lerp(a: c_double, b: c_double, t: c_double) -> c_double;
    pub fn he_math_utils_sanitize_radians(angle: c_double) -> c_double;
    pub fn he_math_utils_is_bounded_rgb(x: c_double) -> gboolean;
    pub fn he_math_utils_adapt(color_channel: c_double) -> c_double;
    pub fn he_math_utils_elem_mul(
        row: *mut c_double,
        row_length1: c_int,
        matrix: *mut c_double,
        matrix_length1: c_int,
        matrix_length2: c_int,
        result_length1: *mut c_int,
    ) -> *mut c_double;
    pub fn he_math_utils_lab_inverse_fovea(ft: c_double) -> c_double;
    pub fn he_math_utils_lab_fovea(t: c_double) -> c_double;
    pub fn he_math_utils_sanitize_degrees(degrees: c_double) -> c_double;
    pub fn he_math_utils_sanitize_degrees_int(degrees: c_int) -> c_int;
    pub fn he_math_utils_rotate_direction(from: c_double, to: c_double) -> c_double;
    pub fn he_math_utils_difference_degrees(a: c_double, b: c_double) -> c_double;
    pub fn he_math_utils_abs(n: c_double) -> c_double;
    pub fn he_math_utils_max(n: c_double, m: c_double) -> c_double;
    pub fn he_math_utils_min(n: c_double, m: c_double) -> c_double;
    pub fn he_math_utils_linearized(rgb_component: c_int) -> c_double;
    pub fn he_math_utils_delinearized(rgb_component: c_double) -> c_int;
    pub fn he_math_utils_double_delinearized(rgb_component: c_double) -> c_double;
    pub fn he_math_utils_midpoint(
        a: *mut c_double,
        a_length1: c_int,
        b: *mut c_double,
        b_length1: c_int,
        result_length1: *mut c_int,
    ) -> *mut c_double;
    pub fn he_math_utils_intercept(source: c_double, mid: c_double, target: c_double) -> c_double;
    pub fn he_math_utils_hue_of(linrgb: *mut c_double, linrgb_length1: c_int) -> c_double;
    pub fn he_math_utils_nth_vertex(
        y: c_double,
        n: c_int,
        result_length1: *mut c_int,
    ) -> *mut c_double;
    pub fn he_math_utils_are_in_cyclic_order(a: c_double, b: c_double, c: c_double) -> gboolean;
    pub fn he_math_utils_set_coordinate(
        source: *mut c_double,
        source_length1: c_int,
        coordinate: c_double,
        target: *mut c_double,
        target_length1: c_int,
        axis: c_int,
        result_length1: *mut c_int,
    ) -> *mut c_double;
    pub fn he_math_utils_convert(value: c_double) -> c_double;
    pub fn he_math_utils_bisect_to_segment(
        y: c_double,
        target_hue: c_double,
        result_length1: *mut c_int,
    ) -> *mut c_double;
    pub fn he_math_utils_bisect_to_limit(
        y: c_double,
        target_hue: c_double,
        result_length1: *mut c_int,
    ) -> *mut c_double;
    pub fn he_math_utils_y_from_lstar(lstar: c_double) -> c_double;
    pub fn he_math_utils_argb_from_lstar(lstar: c_double) -> c_int;
    pub fn he_math_utils_lstar_from_argb(argb: c_int) -> c_double;
    pub fn he_math_utils_lstar_from_y(y: c_double) -> c_double;
    pub fn he_math_utils_clamp(start: c_double, end: c_double, value: c_double) -> c_double;
    pub fn he_misc_find_ancestor_of_type(
        t_type: GType,
        t_dup_func: gobject::GBoxedCopyFunc,
        t_destroy_func: glib::GDestroyNotify,
        widget: *mut gtk::GtkWidget,
    ) -> gpointer;
    pub fn he_misc_contrast_ratio(
        red: c_double,
        green: c_double,
        blue: c_double,
        red2: c_double,
        green2: c_double,
        blue2: c_double,
    ) -> c_double;
    pub fn he_misc_fix_fg_contrast(
        red: c_double,
        green: c_double,
        blue: c_double,
        red2: c_double,
        green2: c_double,
        blue2: c_double,
        result_length1: *mut c_int,
    ) -> *mut c_double;
    pub fn he_misc_accel_label(accel: *const c_char) -> *mut c_char;
    pub fn he_misc_accel_string(
        accels: *mut *mut c_char,
        accels_length1: c_int,
        description: *const c_char,
    ) -> *mut c_char;
    pub fn he_colors_to_css_class(self_: HeColors) -> *mut c_char;
    pub fn he_colors_to_string(self_: HeColors) -> *mut c_char;
    pub fn he_tip_view_style_to_css_class(self_: HeTipViewStyle) -> *mut c_char;
    pub fn he_tip_view_style_to_string(self_: HeTipViewStyle) -> *mut c_char;
    pub fn he_desktop_ensor_scheme_to_variant(self_: HeDesktopEnsorScheme) -> HeSchemeVariant;
    pub fn he_about_window_licenses_get_url(self_: HeAboutWindowLicenses) -> *mut c_char;
    pub fn he_about_window_licenses_get_name(self_: HeAboutWindowLicenses) -> *mut c_char;
    pub fn he_content_block_image_cluster_image_position_get_column(
        self_: HeContentBlockImageClusterImagePosition,
    ) -> c_int;
    pub fn he_content_block_image_cluster_image_position_get_row(
        self_: HeContentBlockImageClusterImagePosition,
    ) -> c_int;
    pub fn he_modifier_badge_alignment_to_gtk_align(
        self_: HeModifierBadgeAlignment,
    ) -> gtk::GtkAlign;
    pub fn he_modifier_badge_alignment_from_gtk_align(
        align: gtk::GtkAlign,
    ) -> HeModifierBadgeAlignment;
    pub fn he_overlay_button_size_to_css_class(self_: HeOverlayButtonSize) -> *mut c_char;
    pub fn he_overlay_button_type_button_to_css_class(
        self_: HeOverlayButtonTypeButton,
    ) -> *mut c_char;
    pub fn he_overlay_button_alignment_to_gtk_align(
        self_: HeOverlayButtonAlignment,
    ) -> gtk::GtkAlign;
    pub fn he_overlay_button_alignment_from_gtk_align(
        align: gtk::GtkAlign,
    ) -> HeOverlayButtonAlignment;
    pub fn he_rgb_to_argb_int(color: *mut HeRGBColor) -> c_int;
    pub fn he_lab_to_argb_int(lab: *mut HeLABColor) -> c_int;
    pub fn he_argb_from_rgb_int(red: c_int, green: c_int, blue: c_int) -> c_int;
    pub fn he_xyz_to_argb(xyz: *mut HeXYZColor) -> c_int;
    pub fn he_argb_to_rgb(argb: c_int, result_length1: *mut c_int) -> *mut c_double;
    pub fn he_alpha_from_rgba_int(argb: c_int) -> c_int;
    pub fn he_red_from_rgba_int(argb: c_int) -> c_int;
    pub fn he_green_from_rgba_int(argb: c_int) -> c_int;
    pub fn he_blue_from_rgba_int(argb: c_int) -> c_int;
    pub fn he_xyz_to_cam16(color: *mut HeXYZColor, result: *mut HeCAM16Color);
    pub fn he_cam16_from_int(argb: c_int, result: *mut HeCAM16Color);
    pub fn he_to_gdk_rgba(color: *mut HeRGBColor, result: *mut gdk::GdkRGBA);
    pub fn he_critical_plane_below(x: c_double) -> c_int;
    pub fn he_critical_plane_above(x: c_double) -> c_int;
    pub fn he_from_params(hue: c_double, chroma: c_double, tone: c_double, result: *mut HeHCTColor);
    pub fn he_disliked(hct: *mut HeHCTColor) -> gboolean;
    pub fn he_fix_disliked(hct: *mut HeHCTColor, result: *mut HeHCTColor);
    pub fn he_hct_from_int(argb: c_int, result: *mut HeHCTColor);
    pub fn he_hct_to_hex(hue: c_double, chroma: c_double, lstar: c_double) -> *mut c_char;
    pub fn he_hex_from_hct_with_contrast(hct: *mut HeHCTColor, contrast: c_double) -> *mut c_char;
    pub fn he_hex_from_hct(hct: *mut HeHCTColor) -> *mut c_char;
    pub fn he_hct_to_argb(hue: c_double, chroma: c_double, lstar: c_double) -> c_int;
    pub fn he_hct_blend(a: *mut HeHCTColor, b: *mut HeHCTColor, result: *mut HeHCTColor);
    pub fn he_get_rotated_hue(
        hue: c_double,
        hues: *mut c_double,
        hues_length1: c_int,
        rotations: *mut c_double,
        rotations_length1: c_int,
    ) -> c_double;
    pub fn he_rgb_from_linrgb(red: c_int, green: c_int, blue: c_int) -> c_int;
    pub fn he_argb_from_linrgb(linrgb: *mut c_double, linrgb_length1: c_int) -> c_int;
    pub fn he_find_result_by_j(hr: c_double, c: c_double, y: c_double) -> c_int;
    pub fn he_hexcode(r: c_double, g: c_double, b: c_double) -> *mut c_char;
    pub fn he_hexcode_argb(color: c_int) -> *mut c_char;
    pub fn he_xyz_value_to_lab(v: c_double) -> c_double;
    pub fn he_xyz_to_lab(color: *mut HeXYZColor, result: *mut HeLABColor);
    pub fn he_lch_to_lab(color: *mut HeLCHColor, result: *mut HeLABColor);
    pub fn he_rgb_to_lab(color: *mut HeRGBColor, result: *mut HeLABColor);
    pub fn he_lab_from_argb(argb: c_int, result: *mut HeLABColor);
    pub fn he_rgb_to_lch(color: *mut HeRGBColor, result: *mut HeLCHColor);
    pub fn he_lab_to_lch(color: *mut HeLABColor, result: *mut HeLCHColor);
    pub fn he_hct_to_lch(color: *mut HeHCTColor, result: *mut HeLCHColor);
    pub fn he_xyz_to_rgb(color: *mut HeXYZColor, result: *mut HeRGBColor);
    pub fn he_lab_to_rgb(color: *mut HeLABColor, result: *mut HeRGBColor);
    pub fn he_lch_to_rgb(color: *mut HeLCHColor, result: *mut HeRGBColor);
    pub fn he_from_gdk_rgba(color: *mut gdk::GdkRGBA, result: *mut HeRGBColor);
    pub fn he_from_hex(color: *const c_char, result: *mut HeRGBColor);
    pub fn he_from_argb_int(argb: c_int, result: *mut HeRGBColor);
    pub fn he_argb_to_xyz(argb: c_int, result: *mut HeXYZColor);
    pub fn he_rgb_value_to_xyz(v: c_double) -> c_double;
    pub fn he_rgb_to_xyz(color: *mut HeRGBColor, result: *mut HeXYZColor);
    pub fn he_cam16_to_xyz(color: *mut HeCAM16Color, result: *mut HeXYZColor);
    pub fn he_lab_to_xyz(color: *mut HeLABColor, result: *mut HeXYZColor);
    pub fn he_init();

}