// Generated by gir (https://github.com/gtk-rs/gir @ b3d444a058cf)
// from
// from gir-files (https://github.com/gtk-rs/gir-files.git @ 5c1e490fe50a)
// 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;

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

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

// Enums
pub type AdwAccentColor = c_int;
pub const ADW_ACCENT_COLOR_BLUE: AdwAccentColor = 0;
pub const ADW_ACCENT_COLOR_TEAL: AdwAccentColor = 1;
pub const ADW_ACCENT_COLOR_GREEN: AdwAccentColor = 2;
pub const ADW_ACCENT_COLOR_YELLOW: AdwAccentColor = 3;
pub const ADW_ACCENT_COLOR_ORANGE: AdwAccentColor = 4;
pub const ADW_ACCENT_COLOR_RED: AdwAccentColor = 5;
pub const ADW_ACCENT_COLOR_PINK: AdwAccentColor = 6;
pub const ADW_ACCENT_COLOR_PURPLE: AdwAccentColor = 7;
pub const ADW_ACCENT_COLOR_SLATE: AdwAccentColor = 8;

pub type AdwAnimationState = c_int;
pub const ADW_ANIMATION_IDLE: AdwAnimationState = 0;
pub const ADW_ANIMATION_PAUSED: AdwAnimationState = 1;
pub const ADW_ANIMATION_PLAYING: AdwAnimationState = 2;
pub const ADW_ANIMATION_FINISHED: AdwAnimationState = 3;

pub type AdwBannerButtonStyle = c_int;
pub const ADW_BANNER_BUTTON_DEFAULT: AdwBannerButtonStyle = 0;
pub const ADW_BANNER_BUTTON_SUGGESTED: AdwBannerButtonStyle = 1;

pub type AdwBreakpointConditionLengthType = c_int;
pub const ADW_BREAKPOINT_CONDITION_MIN_WIDTH: AdwBreakpointConditionLengthType = 0;
pub const ADW_BREAKPOINT_CONDITION_MAX_WIDTH: AdwBreakpointConditionLengthType = 1;
pub const ADW_BREAKPOINT_CONDITION_MIN_HEIGHT: AdwBreakpointConditionLengthType = 2;
pub const ADW_BREAKPOINT_CONDITION_MAX_HEIGHT: AdwBreakpointConditionLengthType = 3;

pub type AdwBreakpointConditionRatioType = c_int;
pub const ADW_BREAKPOINT_CONDITION_MIN_ASPECT_RATIO: AdwBreakpointConditionRatioType = 0;
pub const ADW_BREAKPOINT_CONDITION_MAX_ASPECT_RATIO: AdwBreakpointConditionRatioType = 1;

pub type AdwCenteringPolicy = c_int;
pub const ADW_CENTERING_POLICY_LOOSE: AdwCenteringPolicy = 0;
pub const ADW_CENTERING_POLICY_STRICT: AdwCenteringPolicy = 1;

pub type AdwColorScheme = c_int;
pub const ADW_COLOR_SCHEME_DEFAULT: AdwColorScheme = 0;
pub const ADW_COLOR_SCHEME_FORCE_LIGHT: AdwColorScheme = 1;
pub const ADW_COLOR_SCHEME_PREFER_LIGHT: AdwColorScheme = 2;
pub const ADW_COLOR_SCHEME_PREFER_DARK: AdwColorScheme = 3;
pub const ADW_COLOR_SCHEME_FORCE_DARK: AdwColorScheme = 4;

pub type AdwDialogPresentationMode = c_int;
pub const ADW_DIALOG_AUTO: AdwDialogPresentationMode = 0;
pub const ADW_DIALOG_FLOATING: AdwDialogPresentationMode = 1;
pub const ADW_DIALOG_BOTTOM_SHEET: AdwDialogPresentationMode = 2;

pub type AdwEasing = c_int;
pub const ADW_LINEAR: AdwEasing = 0;
pub const ADW_EASE_IN_QUAD: AdwEasing = 1;
pub const ADW_EASE_OUT_QUAD: AdwEasing = 2;
pub const ADW_EASE_IN_OUT_QUAD: AdwEasing = 3;
pub const ADW_EASE_IN_CUBIC: AdwEasing = 4;
pub const ADW_EASE_OUT_CUBIC: AdwEasing = 5;
pub const ADW_EASE_IN_OUT_CUBIC: AdwEasing = 6;
pub const ADW_EASE_IN_QUART: AdwEasing = 7;
pub const ADW_EASE_OUT_QUART: AdwEasing = 8;
pub const ADW_EASE_IN_OUT_QUART: AdwEasing = 9;
pub const ADW_EASE_IN_QUINT: AdwEasing = 10;
pub const ADW_EASE_OUT_QUINT: AdwEasing = 11;
pub const ADW_EASE_IN_OUT_QUINT: AdwEasing = 12;
pub const ADW_EASE_IN_SINE: AdwEasing = 13;
pub const ADW_EASE_OUT_SINE: AdwEasing = 14;
pub const ADW_EASE_IN_OUT_SINE: AdwEasing = 15;
pub const ADW_EASE_IN_EXPO: AdwEasing = 16;
pub const ADW_EASE_OUT_EXPO: AdwEasing = 17;
pub const ADW_EASE_IN_OUT_EXPO: AdwEasing = 18;
pub const ADW_EASE_IN_CIRC: AdwEasing = 19;
pub const ADW_EASE_OUT_CIRC: AdwEasing = 20;
pub const ADW_EASE_IN_OUT_CIRC: AdwEasing = 21;
pub const ADW_EASE_IN_ELASTIC: AdwEasing = 22;
pub const ADW_EASE_OUT_ELASTIC: AdwEasing = 23;
pub const ADW_EASE_IN_OUT_ELASTIC: AdwEasing = 24;
pub const ADW_EASE_IN_BACK: AdwEasing = 25;
pub const ADW_EASE_OUT_BACK: AdwEasing = 26;
pub const ADW_EASE_IN_OUT_BACK: AdwEasing = 27;
pub const ADW_EASE_IN_BOUNCE: AdwEasing = 28;
pub const ADW_EASE_OUT_BOUNCE: AdwEasing = 29;
pub const ADW_EASE_IN_OUT_BOUNCE: AdwEasing = 30;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub const ADW_EASE: AdwEasing = 31;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub const ADW_EASE_IN: AdwEasing = 32;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub const ADW_EASE_OUT: AdwEasing = 33;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub const ADW_EASE_IN_OUT: AdwEasing = 34;

pub type AdwFlapFoldPolicy = c_int;
pub const ADW_FLAP_FOLD_POLICY_NEVER: AdwFlapFoldPolicy = 0;
pub const ADW_FLAP_FOLD_POLICY_ALWAYS: AdwFlapFoldPolicy = 1;
pub const ADW_FLAP_FOLD_POLICY_AUTO: AdwFlapFoldPolicy = 2;

pub type AdwFlapTransitionType = c_int;
pub const ADW_FLAP_TRANSITION_TYPE_OVER: AdwFlapTransitionType = 0;
pub const ADW_FLAP_TRANSITION_TYPE_UNDER: AdwFlapTransitionType = 1;
pub const ADW_FLAP_TRANSITION_TYPE_SLIDE: AdwFlapTransitionType = 2;

pub type AdwFoldThresholdPolicy = c_int;
pub const ADW_FOLD_THRESHOLD_POLICY_MINIMUM: AdwFoldThresholdPolicy = 0;
pub const ADW_FOLD_THRESHOLD_POLICY_NATURAL: AdwFoldThresholdPolicy = 1;

pub type AdwInlineViewSwitcherDisplayMode = c_int;
pub const ADW_INLINE_VIEW_SWITCHER_LABELS: AdwInlineViewSwitcherDisplayMode = 0;
pub const ADW_INLINE_VIEW_SWITCHER_ICONS: AdwInlineViewSwitcherDisplayMode = 1;
pub const ADW_INLINE_VIEW_SWITCHER_BOTH: AdwInlineViewSwitcherDisplayMode = 2;

pub type AdwJustifyMode = c_int;
pub const ADW_JUSTIFY_NONE: AdwJustifyMode = 0;
pub const ADW_JUSTIFY_FILL: AdwJustifyMode = 1;
pub const ADW_JUSTIFY_SPREAD: AdwJustifyMode = 2;

pub type AdwLeafletTransitionType = c_int;
pub const ADW_LEAFLET_TRANSITION_TYPE_OVER: AdwLeafletTransitionType = 0;
pub const ADW_LEAFLET_TRANSITION_TYPE_UNDER: AdwLeafletTransitionType = 1;
pub const ADW_LEAFLET_TRANSITION_TYPE_SLIDE: AdwLeafletTransitionType = 2;

pub type AdwLengthUnit = c_int;
pub const ADW_LENGTH_UNIT_PX: AdwLengthUnit = 0;
pub const ADW_LENGTH_UNIT_PT: AdwLengthUnit = 1;
pub const ADW_LENGTH_UNIT_SP: AdwLengthUnit = 2;

pub type AdwNavigationDirection = c_int;
pub const ADW_NAVIGATION_DIRECTION_BACK: AdwNavigationDirection = 0;
pub const ADW_NAVIGATION_DIRECTION_FORWARD: AdwNavigationDirection = 1;

pub type AdwPackDirection = c_int;
pub const ADW_PACK_START_TO_END: AdwPackDirection = 0;
pub const ADW_PACK_END_TO_START: AdwPackDirection = 1;

pub type AdwResponseAppearance = c_int;
pub const ADW_RESPONSE_DEFAULT: AdwResponseAppearance = 0;
pub const ADW_RESPONSE_SUGGESTED: AdwResponseAppearance = 1;
pub const ADW_RESPONSE_DESTRUCTIVE: AdwResponseAppearance = 2;

pub type AdwSqueezerTransitionType = c_int;
pub const ADW_SQUEEZER_TRANSITION_TYPE_NONE: AdwSqueezerTransitionType = 0;
pub const ADW_SQUEEZER_TRANSITION_TYPE_CROSSFADE: AdwSqueezerTransitionType = 1;

pub type AdwToastPriority = c_int;
pub const ADW_TOAST_PRIORITY_NORMAL: AdwToastPriority = 0;
pub const ADW_TOAST_PRIORITY_HIGH: AdwToastPriority = 1;

pub type AdwToolbarStyle = c_int;
pub const ADW_TOOLBAR_FLAT: AdwToolbarStyle = 0;
pub const ADW_TOOLBAR_RAISED: AdwToolbarStyle = 1;
pub const ADW_TOOLBAR_RAISED_BORDER: AdwToolbarStyle = 2;

pub type AdwViewSwitcherPolicy = c_int;
pub const ADW_VIEW_SWITCHER_POLICY_NARROW: AdwViewSwitcherPolicy = 0;
pub const ADW_VIEW_SWITCHER_POLICY_WIDE: AdwViewSwitcherPolicy = 1;

pub type AdwWrapPolicy = c_int;
pub const ADW_WRAP_MINIMUM: AdwWrapPolicy = 0;
pub const ADW_WRAP_NATURAL: AdwWrapPolicy = 1;

// Constants
pub const ADW_DURATION_INFINITE: c_uint = 4294967295;

// Flags
pub type AdwTabViewShortcuts = c_uint;
pub const ADW_TAB_VIEW_SHORTCUT_NONE: AdwTabViewShortcuts = 0;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_TAB: AdwTabViewShortcuts = 1;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_TAB: AdwTabViewShortcuts = 2;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_PAGE_UP: AdwTabViewShortcuts = 4;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_PAGE_DOWN: AdwTabViewShortcuts = 8;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_HOME: AdwTabViewShortcuts = 16;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_END: AdwTabViewShortcuts = 32;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_PAGE_UP: AdwTabViewShortcuts = 64;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_PAGE_DOWN: AdwTabViewShortcuts = 128;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_HOME: AdwTabViewShortcuts = 256;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_END: AdwTabViewShortcuts = 512;
pub const ADW_TAB_VIEW_SHORTCUT_ALT_DIGITS: AdwTabViewShortcuts = 1024;
pub const ADW_TAB_VIEW_SHORTCUT_ALT_ZERO: AdwTabViewShortcuts = 2048;
pub const ADW_TAB_VIEW_SHORTCUT_ALL_SHORTCUTS: AdwTabViewShortcuts = 4095;

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwActionRowClass {
    pub parent_class: AdwPreferencesRowClass,
    pub activate: Option<unsafe extern "C" fn(*mut AdwActionRow)>,
    pub padding: [gpointer; 4],
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwAlertDialogClass {
    pub parent_class: AdwDialogClass,
    pub response: Option<unsafe extern "C" fn(*mut AdwAlertDialog, *const c_char)>,
    pub padding: [gpointer; 4],
}

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

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

pub type AdwAnimationClass = _AdwAnimationClass;

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

pub type AdwAnimationTargetClass = _AdwAnimationTargetClass;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwApplicationClass {
    pub parent_class: gtk::GtkApplicationClass,
    pub padding: [gpointer; 4],
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwApplicationWindowClass {
    pub parent_class: gtk::GtkApplicationWindowClass,
    pub padding: [gpointer; 4],
}

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

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

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

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwBreakpointBinClass {
    pub parent_class: gtk::GtkWidgetClass,
    pub padding: [gpointer; 4],
}

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

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

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

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

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

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

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

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

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

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

pub type AdwCallbackAnimationTargetClass = _AdwCallbackAnimationTargetClass;

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwComboRowClass {
    pub parent_class: AdwActionRowClass,
    pub padding: [gpointer; 4],
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwDialogClass {
    pub parent_class: gtk::GtkWidgetClass,
    pub close_attempt: Option<unsafe extern "C" fn(*mut AdwDialog)>,
    pub closed: Option<unsafe extern "C" fn(*mut AdwDialog)>,
    pub padding: [gpointer; 4],
}

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

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwExpanderRowClass {
    pub parent_class: AdwPreferencesRowClass,
    pub padding: [gpointer; 4],
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwMessageDialogClass {
    pub parent_class: gtk::GtkWindowClass,
    pub response: Option<unsafe extern "C" fn(*mut AdwMessageDialog, *const c_char)>,
    pub padding: [gpointer; 4],
}

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwNavigationPageClass {
    pub parent_class: gtk::GtkWidgetClass,
    pub showing: Option<unsafe extern "C" fn(*mut AdwNavigationPage)>,
    pub shown: Option<unsafe extern "C" fn(*mut AdwNavigationPage)>,
    pub hiding: Option<unsafe extern "C" fn(*mut AdwNavigationPage)>,
    pub hidden: Option<unsafe extern "C" fn(*mut AdwNavigationPage)>,
    pub padding: [gpointer; 8],
}

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

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

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

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesDialogClass {
    pub parent_class: AdwDialogClass,
    pub padding: [gpointer; 4],
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesGroupClass {
    pub parent_class: gtk::GtkWidgetClass,
    pub padding: [gpointer; 4],
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesPageClass {
    pub parent_class: gtk::GtkWidgetClass,
    pub padding: [gpointer; 4],
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesRowClass {
    pub parent_class: gtk::GtkListBoxRowClass,
    pub padding: [gpointer; 4],
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesWindowClass {
    pub parent_class: AdwWindowClass,
    pub padding: [gpointer; 4],
}

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

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

pub type AdwPropertyAnimationTargetClass = _AdwPropertyAnimationTargetClass;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub type AdwSpringAnimationClass = _AdwSpringAnimationClass;

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwSwipeableInterface {
    pub parent: gobject::GTypeInterface,
    pub get_distance: Option<unsafe extern "C" fn(*mut AdwSwipeable) -> c_double>,
    pub get_snap_points:
        Option<unsafe extern "C" fn(*mut AdwSwipeable, *mut c_int) -> *mut c_double>,
    pub get_progress: Option<unsafe extern "C" fn(*mut AdwSwipeable) -> c_double>,
    pub get_cancel_progress: Option<unsafe extern "C" fn(*mut AdwSwipeable) -> c_double>,
    pub get_swipe_area: Option<
        unsafe extern "C" fn(
            *mut AdwSwipeable,
            AdwNavigationDirection,
            gboolean,
            *mut gdk::GdkRectangle,
        ),
    >,
    pub padding: [gpointer; 4],
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub type AdwTimedAnimationClass = _AdwTimedAnimationClass;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwWindowClass {
    pub parent_class: gtk::GtkWindowClass,
    pub padding: [gpointer; 4],
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern "C" {

    //=========================================================================
    // AdwAccentColor
    //=========================================================================
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_accent_color_get_type() -> GType;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_accent_color_to_rgba(self_: AdwAccentColor, rgba: *mut gdk::GdkRGBA);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_accent_color_to_standalone_rgba(
        self_: AdwAccentColor,
        dark: gboolean,
        rgba: *mut gdk::GdkRGBA,
    );

    //=========================================================================
    // AdwAnimationState
    //=========================================================================
    pub fn adw_animation_state_get_type() -> GType;

    //=========================================================================
    // AdwBannerButtonStyle
    //=========================================================================
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_banner_button_style_get_type() -> GType;

    //=========================================================================
    // AdwBreakpointConditionLengthType
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_condition_length_type_get_type() -> GType;

    //=========================================================================
    // AdwBreakpointConditionRatioType
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_condition_ratio_type_get_type() -> GType;

    //=========================================================================
    // AdwCenteringPolicy
    //=========================================================================
    pub fn adw_centering_policy_get_type() -> GType;

    //=========================================================================
    // AdwColorScheme
    //=========================================================================
    pub fn adw_color_scheme_get_type() -> GType;

    //=========================================================================
    // AdwDialogPresentationMode
    //=========================================================================
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_presentation_mode_get_type() -> GType;

    //=========================================================================
    // AdwEasing
    //=========================================================================
    pub fn adw_easing_get_type() -> GType;
    pub fn adw_easing_ease(self_: AdwEasing, value: c_double) -> c_double;

    //=========================================================================
    // AdwFlapFoldPolicy
    //=========================================================================
    pub fn adw_flap_fold_policy_get_type() -> GType;

    //=========================================================================
    // AdwFlapTransitionType
    //=========================================================================
    pub fn adw_flap_transition_type_get_type() -> GType;

    //=========================================================================
    // AdwFoldThresholdPolicy
    //=========================================================================
    pub fn adw_fold_threshold_policy_get_type() -> GType;

    //=========================================================================
    // AdwInlineViewSwitcherDisplayMode
    //=========================================================================
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_inline_view_switcher_display_mode_get_type() -> GType;

    //=========================================================================
    // AdwJustifyMode
    //=========================================================================
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_justify_mode_get_type() -> GType;

    //=========================================================================
    // AdwLeafletTransitionType
    //=========================================================================
    pub fn adw_leaflet_transition_type_get_type() -> GType;

    //=========================================================================
    // AdwLengthUnit
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_length_unit_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_length_unit_from_px(
        unit: AdwLengthUnit,
        value: c_double,
        settings: *mut gtk::GtkSettings,
    ) -> c_double;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_length_unit_to_px(
        unit: AdwLengthUnit,
        value: c_double,
        settings: *mut gtk::GtkSettings,
    ) -> c_double;

    //=========================================================================
    // AdwNavigationDirection
    //=========================================================================
    pub fn adw_navigation_direction_get_type() -> GType;

    //=========================================================================
    // AdwPackDirection
    //=========================================================================
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_pack_direction_get_type() -> GType;

    //=========================================================================
    // AdwResponseAppearance
    //=========================================================================
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_response_appearance_get_type() -> GType;

    //=========================================================================
    // AdwSqueezerTransitionType
    //=========================================================================
    pub fn adw_squeezer_transition_type_get_type() -> GType;

    //=========================================================================
    // AdwToastPriority
    //=========================================================================
    pub fn adw_toast_priority_get_type() -> GType;

    //=========================================================================
    // AdwToolbarStyle
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_style_get_type() -> GType;

    //=========================================================================
    // AdwViewSwitcherPolicy
    //=========================================================================
    pub fn adw_view_switcher_policy_get_type() -> GType;

    //=========================================================================
    // AdwWrapPolicy
    //=========================================================================
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_policy_get_type() -> GType;

    //=========================================================================
    // AdwTabViewShortcuts
    //=========================================================================
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_tab_view_shortcuts_get_type() -> GType;

    //=========================================================================
    // AdwBreakpointCondition
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_condition_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_condition_new_and(
        condition_1: *mut AdwBreakpointCondition,
        condition_2: *mut AdwBreakpointCondition,
    ) -> *mut AdwBreakpointCondition;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_condition_new_length(
        type_: AdwBreakpointConditionLengthType,
        value: c_double,
        unit: AdwLengthUnit,
    ) -> *mut AdwBreakpointCondition;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_condition_new_or(
        condition_1: *mut AdwBreakpointCondition,
        condition_2: *mut AdwBreakpointCondition,
    ) -> *mut AdwBreakpointCondition;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_condition_new_ratio(
        type_: AdwBreakpointConditionRatioType,
        width: c_int,
        height: c_int,
    ) -> *mut AdwBreakpointCondition;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_condition_copy(
        self_: *mut AdwBreakpointCondition,
    ) -> *mut AdwBreakpointCondition;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_condition_free(self_: *mut AdwBreakpointCondition);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_condition_to_string(self_: *mut AdwBreakpointCondition) -> *mut c_char;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_condition_parse(str: *const c_char) -> *mut AdwBreakpointCondition;

    //=========================================================================
    // AdwSpringParams
    //=========================================================================
    pub fn adw_spring_params_get_type() -> GType;
    pub fn adw_spring_params_new(
        damping_ratio: c_double,
        mass: c_double,
        stiffness: c_double,
    ) -> *mut AdwSpringParams;
    pub fn adw_spring_params_new_full(
        damping: c_double,
        mass: c_double,
        stiffness: c_double,
    ) -> *mut AdwSpringParams;
    pub fn adw_spring_params_get_damping(self_: *mut AdwSpringParams) -> c_double;
    pub fn adw_spring_params_get_damping_ratio(self_: *mut AdwSpringParams) -> c_double;
    pub fn adw_spring_params_get_mass(self_: *mut AdwSpringParams) -> c_double;
    pub fn adw_spring_params_get_stiffness(self_: *mut AdwSpringParams) -> c_double;
    pub fn adw_spring_params_ref(self_: *mut AdwSpringParams) -> *mut AdwSpringParams;
    pub fn adw_spring_params_unref(self_: *mut AdwSpringParams);

    //=========================================================================
    // AdwAboutDialog
    //=========================================================================
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_type() -> GType;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_new() -> *mut AdwDialog;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    #[cfg(not(target_env = "msvc"))]
    #[cfg_attr(docsrs, doc(cfg(not(target_env = "msvc"))))]
    pub fn adw_about_dialog_new_from_appdata(
        resource_path: *const c_char,
        release_notes_version: *const c_char,
    ) -> *mut AdwDialog;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_add_acknowledgement_section(
        self_: *mut AdwAboutDialog,
        name: *const c_char,
        people: *mut *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_add_credit_section(
        self_: *mut AdwAboutDialog,
        name: *const c_char,
        people: *mut *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_add_legal_section(
        self_: *mut AdwAboutDialog,
        title: *const c_char,
        copyright: *const c_char,
        license_type: gtk::GtkLicense,
        license: *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_add_link(
        self_: *mut AdwAboutDialog,
        title: *const c_char,
        url: *const c_char,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_about_dialog_add_other_app(
        self_: *mut AdwAboutDialog,
        appid: *const c_char,
        name: *const c_char,
        summary: *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_application_icon(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_application_name(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_artists(self_: *mut AdwAboutDialog) -> *const *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_comments(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_copyright(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_debug_info(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_debug_info_filename(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_designers(self_: *mut AdwAboutDialog) -> *const *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_developer_name(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_developers(self_: *mut AdwAboutDialog) -> *const *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_documenters(self_: *mut AdwAboutDialog) -> *const *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_issue_url(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_license(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_license_type(self_: *mut AdwAboutDialog) -> gtk::GtkLicense;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_release_notes(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_release_notes_version(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_support_url(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_translator_credits(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_version(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_get_website(self_: *mut AdwAboutDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_application_icon(
        self_: *mut AdwAboutDialog,
        application_icon: *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_application_name(
        self_: *mut AdwAboutDialog,
        application_name: *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_artists(self_: *mut AdwAboutDialog, artists: *mut *const c_char);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_comments(self_: *mut AdwAboutDialog, comments: *const c_char);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_copyright(self_: *mut AdwAboutDialog, copyright: *const c_char);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_debug_info(self_: *mut AdwAboutDialog, debug_info: *const c_char);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_debug_info_filename(
        self_: *mut AdwAboutDialog,
        filename: *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_designers(
        self_: *mut AdwAboutDialog,
        designers: *mut *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_developer_name(
        self_: *mut AdwAboutDialog,
        developer_name: *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_developers(
        self_: *mut AdwAboutDialog,
        developers: *mut *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_documenters(
        self_: *mut AdwAboutDialog,
        documenters: *mut *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_issue_url(self_: *mut AdwAboutDialog, issue_url: *const c_char);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_license(self_: *mut AdwAboutDialog, license: *const c_char);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_license_type(
        self_: *mut AdwAboutDialog,
        license_type: gtk::GtkLicense,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_release_notes(
        self_: *mut AdwAboutDialog,
        release_notes: *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_release_notes_version(
        self_: *mut AdwAboutDialog,
        version: *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_support_url(self_: *mut AdwAboutDialog, support_url: *const c_char);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_translator_credits(
        self_: *mut AdwAboutDialog,
        translator_credits: *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_version(self_: *mut AdwAboutDialog, version: *const c_char);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_about_dialog_set_website(self_: *mut AdwAboutDialog, website: *const c_char);

    //=========================================================================
    // AdwAboutWindow
    //=========================================================================
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_type() -> GType;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    #[cfg(not(target_env = "msvc"))]
    #[cfg_attr(docsrs, doc(cfg(not(target_env = "msvc"))))]
    pub fn adw_about_window_new_from_appdata(
        resource_path: *const c_char,
        release_notes_version: *const c_char,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_add_acknowledgement_section(
        self_: *mut AdwAboutWindow,
        name: *const c_char,
        people: *mut *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_add_credit_section(
        self_: *mut AdwAboutWindow,
        name: *const c_char,
        people: *mut *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_add_legal_section(
        self_: *mut AdwAboutWindow,
        title: *const c_char,
        copyright: *const c_char,
        license_type: gtk::GtkLicense,
        license: *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_add_link(
        self_: *mut AdwAboutWindow,
        title: *const c_char,
        url: *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_application_icon(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_application_name(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_artists(self_: *mut AdwAboutWindow) -> *const *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_comments(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_copyright(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_debug_info(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_debug_info_filename(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_designers(self_: *mut AdwAboutWindow) -> *const *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_developer_name(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_developers(self_: *mut AdwAboutWindow) -> *const *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_documenters(self_: *mut AdwAboutWindow) -> *const *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_issue_url(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_license(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_license_type(self_: *mut AdwAboutWindow) -> gtk::GtkLicense;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_release_notes(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_release_notes_version(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_support_url(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_translator_credits(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_version(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_website(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_application_icon(
        self_: *mut AdwAboutWindow,
        application_icon: *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_application_name(
        self_: *mut AdwAboutWindow,
        application_name: *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_artists(self_: *mut AdwAboutWindow, artists: *mut *const c_char);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_comments(self_: *mut AdwAboutWindow, comments: *const c_char);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_copyright(self_: *mut AdwAboutWindow, copyright: *const c_char);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_debug_info(self_: *mut AdwAboutWindow, debug_info: *const c_char);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_debug_info_filename(
        self_: *mut AdwAboutWindow,
        filename: *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_designers(
        self_: *mut AdwAboutWindow,
        designers: *mut *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_developer_name(
        self_: *mut AdwAboutWindow,
        developer_name: *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_developers(
        self_: *mut AdwAboutWindow,
        developers: *mut *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_documenters(
        self_: *mut AdwAboutWindow,
        documenters: *mut *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_issue_url(self_: *mut AdwAboutWindow, issue_url: *const c_char);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_license(self_: *mut AdwAboutWindow, license: *const c_char);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_license_type(
        self_: *mut AdwAboutWindow,
        license_type: gtk::GtkLicense,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_release_notes(
        self_: *mut AdwAboutWindow,
        release_notes: *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_release_notes_version(
        self_: *mut AdwAboutWindow,
        version: *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_support_url(self_: *mut AdwAboutWindow, support_url: *const c_char);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_translator_credits(
        self_: *mut AdwAboutWindow,
        translator_credits: *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_version(self_: *mut AdwAboutWindow, version: *const c_char);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_website(self_: *mut AdwAboutWindow, website: *const c_char);

    //=========================================================================
    // AdwActionRow
    //=========================================================================
    pub fn adw_action_row_get_type() -> GType;
    pub fn adw_action_row_new() -> *mut gtk::GtkWidget;
    pub fn adw_action_row_activate(self_: *mut AdwActionRow);
    pub fn adw_action_row_add_prefix(self_: *mut AdwActionRow, widget: *mut gtk::GtkWidget);
    pub fn adw_action_row_add_suffix(self_: *mut AdwActionRow, widget: *mut gtk::GtkWidget);
    pub fn adw_action_row_get_activatable_widget(self_: *mut AdwActionRow) -> *mut gtk::GtkWidget;
    pub fn adw_action_row_get_icon_name(self_: *mut AdwActionRow) -> *const c_char;
    pub fn adw_action_row_get_subtitle(self_: *mut AdwActionRow) -> *const c_char;
    pub fn adw_action_row_get_subtitle_lines(self_: *mut AdwActionRow) -> c_int;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_action_row_get_subtitle_selectable(self_: *mut AdwActionRow) -> gboolean;
    pub fn adw_action_row_get_title_lines(self_: *mut AdwActionRow) -> c_int;
    pub fn adw_action_row_remove(self_: *mut AdwActionRow, widget: *mut gtk::GtkWidget);
    pub fn adw_action_row_set_activatable_widget(
        self_: *mut AdwActionRow,
        widget: *mut gtk::GtkWidget,
    );
    pub fn adw_action_row_set_icon_name(self_: *mut AdwActionRow, icon_name: *const c_char);
    pub fn adw_action_row_set_subtitle(self_: *mut AdwActionRow, subtitle: *const c_char);
    pub fn adw_action_row_set_subtitle_lines(self_: *mut AdwActionRow, subtitle_lines: c_int);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_action_row_set_subtitle_selectable(
        self_: *mut AdwActionRow,
        subtitle_selectable: gboolean,
    );
    pub fn adw_action_row_set_title_lines(self_: *mut AdwActionRow, title_lines: c_int);

    //=========================================================================
    // AdwAlertDialog
    //=========================================================================
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_get_type() -> GType;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_new(heading: *const c_char, body: *const c_char) -> *mut AdwDialog;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_add_response(
        self_: *mut AdwAlertDialog,
        id: *const c_char,
        label: *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_add_responses(self_: *mut AdwAlertDialog, first_id: *const c_char, ...);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_choose(
        self_: *mut AdwAlertDialog,
        parent: *mut gtk::GtkWidget,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_choose_finish(
        self_: *mut AdwAlertDialog,
        result: *mut gio::GAsyncResult,
    ) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_format_body(self_: *mut AdwAlertDialog, format: *const c_char, ...);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_format_body_markup(
        self_: *mut AdwAlertDialog,
        format: *const c_char,
        ...
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_format_heading(self_: *mut AdwAlertDialog, format: *const c_char, ...);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_format_heading_markup(
        self_: *mut AdwAlertDialog,
        format: *const c_char,
        ...
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_get_body(self_: *mut AdwAlertDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_get_body_use_markup(self_: *mut AdwAlertDialog) -> gboolean;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_get_close_response(self_: *mut AdwAlertDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_get_default_response(self_: *mut AdwAlertDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_get_extra_child(self_: *mut AdwAlertDialog) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_get_heading(self_: *mut AdwAlertDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_get_heading_use_markup(self_: *mut AdwAlertDialog) -> gboolean;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_get_prefer_wide_layout(self_: *mut AdwAlertDialog) -> gboolean;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_get_response_appearance(
        self_: *mut AdwAlertDialog,
        response: *const c_char,
    ) -> AdwResponseAppearance;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_get_response_enabled(
        self_: *mut AdwAlertDialog,
        response: *const c_char,
    ) -> gboolean;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_get_response_label(
        self_: *mut AdwAlertDialog,
        response: *const c_char,
    ) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_has_response(
        self_: *mut AdwAlertDialog,
        response: *const c_char,
    ) -> gboolean;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_remove_response(self_: *mut AdwAlertDialog, id: *const c_char);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_set_body(self_: *mut AdwAlertDialog, body: *const c_char);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_set_body_use_markup(self_: *mut AdwAlertDialog, use_markup: gboolean);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_set_close_response(self_: *mut AdwAlertDialog, response: *const c_char);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_set_default_response(
        self_: *mut AdwAlertDialog,
        response: *const c_char,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_set_extra_child(self_: *mut AdwAlertDialog, child: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_set_heading(self_: *mut AdwAlertDialog, heading: *const c_char);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_set_heading_use_markup(
        self_: *mut AdwAlertDialog,
        use_markup: gboolean,
    );
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_alert_dialog_set_prefer_wide_layout(
        self_: *mut AdwAlertDialog,
        prefer_wide_layout: gboolean,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_set_response_appearance(
        self_: *mut AdwAlertDialog,
        response: *const c_char,
        appearance: AdwResponseAppearance,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_set_response_enabled(
        self_: *mut AdwAlertDialog,
        response: *const c_char,
        enabled: gboolean,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_alert_dialog_set_response_label(
        self_: *mut AdwAlertDialog,
        response: *const c_char,
        label: *const c_char,
    );

    //=========================================================================
    // AdwAnimation
    //=========================================================================
    pub fn adw_animation_get_type() -> GType;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_animation_get_follow_enable_animations_setting(self_: *mut AdwAnimation)
        -> gboolean;
    pub fn adw_animation_get_state(self_: *mut AdwAnimation) -> AdwAnimationState;
    pub fn adw_animation_get_target(self_: *mut AdwAnimation) -> *mut AdwAnimationTarget;
    pub fn adw_animation_get_value(self_: *mut AdwAnimation) -> c_double;
    pub fn adw_animation_get_widget(self_: *mut AdwAnimation) -> *mut gtk::GtkWidget;
    pub fn adw_animation_pause(self_: *mut AdwAnimation);
    pub fn adw_animation_play(self_: *mut AdwAnimation);
    pub fn adw_animation_reset(self_: *mut AdwAnimation);
    pub fn adw_animation_resume(self_: *mut AdwAnimation);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_animation_set_follow_enable_animations_setting(
        self_: *mut AdwAnimation,
        setting: gboolean,
    );
    pub fn adw_animation_set_target(self_: *mut AdwAnimation, target: *mut AdwAnimationTarget);
    pub fn adw_animation_skip(self_: *mut AdwAnimation);

    //=========================================================================
    // AdwAnimationTarget
    //=========================================================================
    pub fn adw_animation_target_get_type() -> GType;

    //=========================================================================
    // AdwApplication
    //=========================================================================
    pub fn adw_application_get_type() -> GType;
    pub fn adw_application_new(
        application_id: *const c_char,
        flags: gio::GApplicationFlags,
    ) -> *mut AdwApplication;
    pub fn adw_application_get_style_manager(self_: *mut AdwApplication) -> *mut AdwStyleManager;

    //=========================================================================
    // AdwApplicationWindow
    //=========================================================================
    pub fn adw_application_window_get_type() -> GType;
    pub fn adw_application_window_new(app: *mut gtk::GtkApplication) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_application_window_add_breakpoint(
        self_: *mut AdwApplicationWindow,
        breakpoint: *mut AdwBreakpoint,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_application_window_get_adaptive_preview(
        self_: *mut AdwApplicationWindow,
    ) -> gboolean;
    pub fn adw_application_window_get_content(
        self_: *mut AdwApplicationWindow,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_application_window_get_current_breakpoint(
        self_: *mut AdwApplicationWindow,
    ) -> *mut AdwBreakpoint;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_application_window_get_dialogs(
        self_: *mut AdwApplicationWindow,
    ) -> *mut gio::GListModel;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_application_window_get_visible_dialog(
        self_: *mut AdwApplicationWindow,
    ) -> *mut AdwDialog;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_application_window_set_adaptive_preview(
        self_: *mut AdwApplicationWindow,
        adaptive_preview: gboolean,
    );
    pub fn adw_application_window_set_content(
        self_: *mut AdwApplicationWindow,
        content: *mut gtk::GtkWidget,
    );

    //=========================================================================
    // AdwAvatar
    //=========================================================================
    pub fn adw_avatar_get_type() -> GType;
    pub fn adw_avatar_new(
        size: c_int,
        text: *const c_char,
        show_initials: gboolean,
    ) -> *mut gtk::GtkWidget;
    pub fn adw_avatar_draw_to_texture(
        self_: *mut AdwAvatar,
        scale_factor: c_int,
    ) -> *mut gdk::GdkTexture;
    pub fn adw_avatar_get_custom_image(self_: *mut AdwAvatar) -> *mut gdk::GdkPaintable;
    pub fn adw_avatar_get_icon_name(self_: *mut AdwAvatar) -> *const c_char;
    pub fn adw_avatar_get_show_initials(self_: *mut AdwAvatar) -> gboolean;
    pub fn adw_avatar_get_size(self_: *mut AdwAvatar) -> c_int;
    pub fn adw_avatar_get_text(self_: *mut AdwAvatar) -> *const c_char;
    pub fn adw_avatar_set_custom_image(self_: *mut AdwAvatar, custom_image: *mut gdk::GdkPaintable);
    pub fn adw_avatar_set_icon_name(self_: *mut AdwAvatar, icon_name: *const c_char);
    pub fn adw_avatar_set_show_initials(self_: *mut AdwAvatar, show_initials: gboolean);
    pub fn adw_avatar_set_size(self_: *mut AdwAvatar, size: c_int);
    pub fn adw_avatar_set_text(self_: *mut AdwAvatar, text: *const c_char);

    //=========================================================================
    // AdwBanner
    //=========================================================================
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_get_type() -> GType;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_new(title: *const c_char) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_get_button_label(self_: *mut AdwBanner) -> *const c_char;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_banner_get_button_style(self_: *mut AdwBanner) -> AdwBannerButtonStyle;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_get_revealed(self_: *mut AdwBanner) -> gboolean;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_get_title(self_: *mut AdwBanner) -> *const c_char;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_get_use_markup(self_: *mut AdwBanner) -> gboolean;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_set_button_label(self_: *mut AdwBanner, label: *const c_char);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_banner_set_button_style(self_: *mut AdwBanner, style: AdwBannerButtonStyle);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_set_revealed(self_: *mut AdwBanner, revealed: gboolean);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_set_title(self_: *mut AdwBanner, title: *const c_char);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_set_use_markup(self_: *mut AdwBanner, use_markup: gboolean);

    //=========================================================================
    // AdwBin
    //=========================================================================
    pub fn adw_bin_get_type() -> GType;
    pub fn adw_bin_new() -> *mut gtk::GtkWidget;
    pub fn adw_bin_get_child(self_: *mut AdwBin) -> *mut gtk::GtkWidget;
    pub fn adw_bin_set_child(self_: *mut AdwBin, child: *mut gtk::GtkWidget);

    //=========================================================================
    // AdwBottomSheet
    //=========================================================================
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_get_type() -> GType;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_get_align(self_: *mut AdwBottomSheet) -> c_float;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_get_bottom_bar(self_: *mut AdwBottomSheet) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_get_bottom_bar_height(self_: *mut AdwBottomSheet) -> c_int;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_get_can_close(self_: *mut AdwBottomSheet) -> gboolean;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_get_can_open(self_: *mut AdwBottomSheet) -> gboolean;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_get_content(self_: *mut AdwBottomSheet) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_get_full_width(self_: *mut AdwBottomSheet) -> gboolean;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_get_modal(self_: *mut AdwBottomSheet) -> gboolean;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_get_open(self_: *mut AdwBottomSheet) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_bottom_sheet_get_reveal_bottom_bar(self_: *mut AdwBottomSheet) -> gboolean;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_get_sheet(self_: *mut AdwBottomSheet) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_get_sheet_height(self_: *mut AdwBottomSheet) -> c_int;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_get_show_drag_handle(self_: *mut AdwBottomSheet) -> gboolean;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_set_align(self_: *mut AdwBottomSheet, align: c_float);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_set_bottom_bar(
        self_: *mut AdwBottomSheet,
        bottom_bar: *mut gtk::GtkWidget,
    );
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_set_can_close(self_: *mut AdwBottomSheet, can_close: gboolean);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_set_can_open(self_: *mut AdwBottomSheet, can_open: gboolean);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_set_content(self_: *mut AdwBottomSheet, content: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_set_full_width(self_: *mut AdwBottomSheet, full_width: gboolean);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_set_modal(self_: *mut AdwBottomSheet, modal: gboolean);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_set_open(self_: *mut AdwBottomSheet, open: gboolean);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_bottom_sheet_set_reveal_bottom_bar(self_: *mut AdwBottomSheet, reveal: gboolean);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_set_sheet(self_: *mut AdwBottomSheet, sheet: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_bottom_sheet_set_show_drag_handle(
        self_: *mut AdwBottomSheet,
        show_drag_handle: gboolean,
    );

    //=========================================================================
    // AdwBreakpoint
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_new(condition: *mut AdwBreakpointCondition) -> *mut AdwBreakpoint;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_add_setter(
        self_: *mut AdwBreakpoint,
        object: *mut gobject::GObject,
        property: *const c_char,
        value: *const gobject::GValue,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_add_setters(
        self_: *mut AdwBreakpoint,
        first_object: *mut gobject::GObject,
        first_property: *const c_char,
        ...
    );
    //#[cfg(feature = "v1_4")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    //pub fn adw_breakpoint_add_setters_valist(self_: *mut AdwBreakpoint, first_object: *mut gobject::GObject, first_property: *const c_char, args: /*Unimplemented*/va_list);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_add_settersv(
        self_: *mut AdwBreakpoint,
        n_setters: c_int,
        objects: *mut *mut gobject::GObject,
        names: *mut *const c_char,
        values: *mut *const gobject::GValue,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_get_condition(self_: *mut AdwBreakpoint) -> *mut AdwBreakpointCondition;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_set_condition(
        self_: *mut AdwBreakpoint,
        condition: *mut AdwBreakpointCondition,
    );

    //=========================================================================
    // AdwBreakpointBin
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_bin_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_bin_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_bin_add_breakpoint(
        self_: *mut AdwBreakpointBin,
        breakpoint: *mut AdwBreakpoint,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_bin_get_child(self_: *mut AdwBreakpointBin) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_bin_get_current_breakpoint(
        self_: *mut AdwBreakpointBin,
    ) -> *mut AdwBreakpoint;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_breakpoint_bin_remove_breakpoint(
        self_: *mut AdwBreakpointBin,
        breakpoint: *mut AdwBreakpoint,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_breakpoint_bin_set_child(self_: *mut AdwBreakpointBin, child: *mut gtk::GtkWidget);

    //=========================================================================
    // AdwButtonContent
    //=========================================================================
    pub fn adw_button_content_get_type() -> GType;
    pub fn adw_button_content_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_button_content_get_can_shrink(self_: *mut AdwButtonContent) -> gboolean;
    pub fn adw_button_content_get_icon_name(self_: *mut AdwButtonContent) -> *const c_char;
    pub fn adw_button_content_get_label(self_: *mut AdwButtonContent) -> *const c_char;
    pub fn adw_button_content_get_use_underline(self_: *mut AdwButtonContent) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_button_content_set_can_shrink(self_: *mut AdwButtonContent, can_shrink: gboolean);
    pub fn adw_button_content_set_icon_name(self_: *mut AdwButtonContent, icon_name: *const c_char);
    pub fn adw_button_content_set_label(self_: *mut AdwButtonContent, label: *const c_char);
    pub fn adw_button_content_set_use_underline(
        self_: *mut AdwButtonContent,
        use_underline: gboolean,
    );

    //=========================================================================
    // AdwButtonRow
    //=========================================================================
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_button_row_get_type() -> GType;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_button_row_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_button_row_get_end_icon_name(self_: *mut AdwButtonRow) -> *const c_char;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_button_row_get_start_icon_name(self_: *mut AdwButtonRow) -> *const c_char;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_button_row_set_end_icon_name(self_: *mut AdwButtonRow, icon_name: *const c_char);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_button_row_set_start_icon_name(self_: *mut AdwButtonRow, icon_name: *const c_char);

    //=========================================================================
    // AdwCallbackAnimationTarget
    //=========================================================================
    pub fn adw_callback_animation_target_get_type() -> GType;
    pub fn adw_callback_animation_target_new(
        callback: AdwAnimationTargetFunc,
        user_data: gpointer,
        destroy: glib::GDestroyNotify,
    ) -> *mut AdwAnimationTarget;

    //=========================================================================
    // AdwCarousel
    //=========================================================================
    pub fn adw_carousel_get_type() -> GType;
    pub fn adw_carousel_new() -> *mut gtk::GtkWidget;
    pub fn adw_carousel_append(self_: *mut AdwCarousel, child: *mut gtk::GtkWidget);
    pub fn adw_carousel_get_allow_long_swipes(self_: *mut AdwCarousel) -> gboolean;
    pub fn adw_carousel_get_allow_mouse_drag(self_: *mut AdwCarousel) -> gboolean;
    pub fn adw_carousel_get_allow_scroll_wheel(self_: *mut AdwCarousel) -> gboolean;
    pub fn adw_carousel_get_interactive(self_: *mut AdwCarousel) -> gboolean;
    pub fn adw_carousel_get_n_pages(self_: *mut AdwCarousel) -> c_uint;
    pub fn adw_carousel_get_nth_page(self_: *mut AdwCarousel, n: c_uint) -> *mut gtk::GtkWidget;
    pub fn adw_carousel_get_position(self_: *mut AdwCarousel) -> c_double;
    pub fn adw_carousel_get_reveal_duration(self_: *mut AdwCarousel) -> c_uint;
    pub fn adw_carousel_get_scroll_params(self_: *mut AdwCarousel) -> *mut AdwSpringParams;
    pub fn adw_carousel_get_spacing(self_: *mut AdwCarousel) -> c_uint;
    pub fn adw_carousel_insert(
        self_: *mut AdwCarousel,
        child: *mut gtk::GtkWidget,
        position: c_int,
    );
    pub fn adw_carousel_prepend(self_: *mut AdwCarousel, child: *mut gtk::GtkWidget);
    pub fn adw_carousel_remove(self_: *mut AdwCarousel, child: *mut gtk::GtkWidget);
    pub fn adw_carousel_reorder(
        self_: *mut AdwCarousel,
        child: *mut gtk::GtkWidget,
        position: c_int,
    );
    pub fn adw_carousel_scroll_to(
        self_: *mut AdwCarousel,
        widget: *mut gtk::GtkWidget,
        animate: gboolean,
    );
    pub fn adw_carousel_set_allow_long_swipes(self_: *mut AdwCarousel, allow_long_swipes: gboolean);
    pub fn adw_carousel_set_allow_mouse_drag(self_: *mut AdwCarousel, allow_mouse_drag: gboolean);
    pub fn adw_carousel_set_allow_scroll_wheel(
        self_: *mut AdwCarousel,
        allow_scroll_wheel: gboolean,
    );
    pub fn adw_carousel_set_interactive(self_: *mut AdwCarousel, interactive: gboolean);
    pub fn adw_carousel_set_reveal_duration(self_: *mut AdwCarousel, reveal_duration: c_uint);
    pub fn adw_carousel_set_scroll_params(self_: *mut AdwCarousel, params: *mut AdwSpringParams);
    pub fn adw_carousel_set_spacing(self_: *mut AdwCarousel, spacing: c_uint);

    //=========================================================================
    // AdwCarouselIndicatorDots
    //=========================================================================
    pub fn adw_carousel_indicator_dots_get_type() -> GType;
    pub fn adw_carousel_indicator_dots_new() -> *mut gtk::GtkWidget;
    pub fn adw_carousel_indicator_dots_get_carousel(
        self_: *mut AdwCarouselIndicatorDots,
    ) -> *mut AdwCarousel;
    pub fn adw_carousel_indicator_dots_set_carousel(
        self_: *mut AdwCarouselIndicatorDots,
        carousel: *mut AdwCarousel,
    );

    //=========================================================================
    // AdwCarouselIndicatorLines
    //=========================================================================
    pub fn adw_carousel_indicator_lines_get_type() -> GType;
    pub fn adw_carousel_indicator_lines_new() -> *mut gtk::GtkWidget;
    pub fn adw_carousel_indicator_lines_get_carousel(
        self_: *mut AdwCarouselIndicatorLines,
    ) -> *mut AdwCarousel;
    pub fn adw_carousel_indicator_lines_set_carousel(
        self_: *mut AdwCarouselIndicatorLines,
        carousel: *mut AdwCarousel,
    );

    //=========================================================================
    // AdwClamp
    //=========================================================================
    pub fn adw_clamp_get_type() -> GType;
    pub fn adw_clamp_new() -> *mut gtk::GtkWidget;
    pub fn adw_clamp_get_child(self_: *mut AdwClamp) -> *mut gtk::GtkWidget;
    pub fn adw_clamp_get_maximum_size(self_: *mut AdwClamp) -> c_int;
    pub fn adw_clamp_get_tightening_threshold(self_: *mut AdwClamp) -> c_int;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_clamp_get_unit(self_: *mut AdwClamp) -> AdwLengthUnit;
    pub fn adw_clamp_set_child(self_: *mut AdwClamp, child: *mut gtk::GtkWidget);
    pub fn adw_clamp_set_maximum_size(self_: *mut AdwClamp, maximum_size: c_int);
    pub fn adw_clamp_set_tightening_threshold(self_: *mut AdwClamp, tightening_threshold: c_int);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_clamp_set_unit(self_: *mut AdwClamp, unit: AdwLengthUnit);

    //=========================================================================
    // AdwClampLayout
    //=========================================================================
    pub fn adw_clamp_layout_get_type() -> GType;
    pub fn adw_clamp_layout_new() -> *mut gtk::GtkLayoutManager;
    pub fn adw_clamp_layout_get_maximum_size(self_: *mut AdwClampLayout) -> c_int;
    pub fn adw_clamp_layout_get_tightening_threshold(self_: *mut AdwClampLayout) -> c_int;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_clamp_layout_get_unit(self_: *mut AdwClampLayout) -> AdwLengthUnit;
    pub fn adw_clamp_layout_set_maximum_size(self_: *mut AdwClampLayout, maximum_size: c_int);
    pub fn adw_clamp_layout_set_tightening_threshold(
        self_: *mut AdwClampLayout,
        tightening_threshold: c_int,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_clamp_layout_set_unit(self_: *mut AdwClampLayout, unit: AdwLengthUnit);

    //=========================================================================
    // AdwClampScrollable
    //=========================================================================
    pub fn adw_clamp_scrollable_get_type() -> GType;
    pub fn adw_clamp_scrollable_new() -> *mut gtk::GtkWidget;
    pub fn adw_clamp_scrollable_get_child(self_: *mut AdwClampScrollable) -> *mut gtk::GtkWidget;
    pub fn adw_clamp_scrollable_get_maximum_size(self_: *mut AdwClampScrollable) -> c_int;
    pub fn adw_clamp_scrollable_get_tightening_threshold(self_: *mut AdwClampScrollable) -> c_int;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_clamp_scrollable_get_unit(self_: *mut AdwClampScrollable) -> AdwLengthUnit;
    pub fn adw_clamp_scrollable_set_child(
        self_: *mut AdwClampScrollable,
        child: *mut gtk::GtkWidget,
    );
    pub fn adw_clamp_scrollable_set_maximum_size(
        self_: *mut AdwClampScrollable,
        maximum_size: c_int,
    );
    pub fn adw_clamp_scrollable_set_tightening_threshold(
        self_: *mut AdwClampScrollable,
        tightening_threshold: c_int,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_clamp_scrollable_set_unit(self_: *mut AdwClampScrollable, unit: AdwLengthUnit);

    //=========================================================================
    // AdwComboRow
    //=========================================================================
    pub fn adw_combo_row_get_type() -> GType;
    pub fn adw_combo_row_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_combo_row_get_enable_search(self_: *mut AdwComboRow) -> gboolean;
    pub fn adw_combo_row_get_expression(self_: *mut AdwComboRow) -> *mut gtk::GtkExpression;
    pub fn adw_combo_row_get_factory(self_: *mut AdwComboRow) -> *mut gtk::GtkListItemFactory;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_combo_row_get_header_factory(
        self_: *mut AdwComboRow,
    ) -> *mut gtk::GtkListItemFactory;
    pub fn adw_combo_row_get_list_factory(self_: *mut AdwComboRow) -> *mut gtk::GtkListItemFactory;
    pub fn adw_combo_row_get_model(self_: *mut AdwComboRow) -> *mut gio::GListModel;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_combo_row_get_search_match_mode(
        self_: *mut AdwComboRow,
    ) -> gtk::GtkStringFilterMatchMode;
    pub fn adw_combo_row_get_selected(self_: *mut AdwComboRow) -> c_uint;
    pub fn adw_combo_row_get_selected_item(self_: *mut AdwComboRow) -> *mut gobject::GObject;
    pub fn adw_combo_row_get_use_subtitle(self_: *mut AdwComboRow) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_combo_row_set_enable_search(self_: *mut AdwComboRow, enable_search: gboolean);
    pub fn adw_combo_row_set_expression(
        self_: *mut AdwComboRow,
        expression: *mut gtk::GtkExpression,
    );
    pub fn adw_combo_row_set_factory(
        self_: *mut AdwComboRow,
        factory: *mut gtk::GtkListItemFactory,
    );
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_combo_row_set_header_factory(
        self_: *mut AdwComboRow,
        factory: *mut gtk::GtkListItemFactory,
    );
    pub fn adw_combo_row_set_list_factory(
        self_: *mut AdwComboRow,
        factory: *mut gtk::GtkListItemFactory,
    );
    pub fn adw_combo_row_set_model(self_: *mut AdwComboRow, model: *mut gio::GListModel);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_combo_row_set_search_match_mode(
        self_: *mut AdwComboRow,
        search_match_mode: gtk::GtkStringFilterMatchMode,
    );
    pub fn adw_combo_row_set_selected(self_: *mut AdwComboRow, position: c_uint);
    pub fn adw_combo_row_set_use_subtitle(self_: *mut AdwComboRow, use_subtitle: gboolean);

    //=========================================================================
    // AdwDialog
    //=========================================================================
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_get_type() -> GType;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_new() -> *mut AdwDialog;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_add_breakpoint(self_: *mut AdwDialog, breakpoint: *mut AdwBreakpoint);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_close(self_: *mut AdwDialog) -> gboolean;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_force_close(self_: *mut AdwDialog);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_get_can_close(self_: *mut AdwDialog) -> gboolean;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_get_child(self_: *mut AdwDialog) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_get_content_height(self_: *mut AdwDialog) -> c_int;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_get_content_width(self_: *mut AdwDialog) -> c_int;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_get_current_breakpoint(self_: *mut AdwDialog) -> *mut AdwBreakpoint;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_get_default_widget(self_: *mut AdwDialog) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_get_focus(self_: *mut AdwDialog) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_get_follows_content_size(self_: *mut AdwDialog) -> gboolean;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_get_presentation_mode(self_: *mut AdwDialog) -> AdwDialogPresentationMode;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_get_title(self_: *mut AdwDialog) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_present(self_: *mut AdwDialog, parent: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_set_can_close(self_: *mut AdwDialog, can_close: gboolean);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_set_child(self_: *mut AdwDialog, child: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_set_content_height(self_: *mut AdwDialog, content_height: c_int);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_set_content_width(self_: *mut AdwDialog, content_width: c_int);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_set_default_widget(
        self_: *mut AdwDialog,
        default_widget: *mut gtk::GtkWidget,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_set_focus(self_: *mut AdwDialog, focus: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_set_follows_content_size(
        self_: *mut AdwDialog,
        follows_content_size: gboolean,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_set_presentation_mode(
        self_: *mut AdwDialog,
        presentation_mode: AdwDialogPresentationMode,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_dialog_set_title(self_: *mut AdwDialog, title: *const c_char);

    //=========================================================================
    // AdwEntryRow
    //=========================================================================
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_type() -> GType;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_add_prefix(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_add_suffix(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_activates_default(self_: *mut AdwEntryRow) -> gboolean;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_attributes(self_: *mut AdwEntryRow) -> *mut pango::PangoAttrList;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_enable_emoji_completion(self_: *mut AdwEntryRow) -> gboolean;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_input_hints(self_: *mut AdwEntryRow) -> gtk::GtkInputHints;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_input_purpose(self_: *mut AdwEntryRow) -> gtk::GtkInputPurpose;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_entry_row_get_max_length(self_: *mut AdwEntryRow) -> c_int;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_show_apply_button(self_: *mut AdwEntryRow) -> gboolean;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_entry_row_get_text_length(self_: *mut AdwEntryRow) -> c_uint;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_entry_row_grab_focus_without_selecting(self_: *mut AdwEntryRow) -> gboolean;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_remove(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_set_activates_default(self_: *mut AdwEntryRow, activates: gboolean);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_set_attributes(
        self_: *mut AdwEntryRow,
        attributes: *mut pango::PangoAttrList,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_set_enable_emoji_completion(
        self_: *mut AdwEntryRow,
        enable_emoji_completion: gboolean,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_set_input_hints(self_: *mut AdwEntryRow, hints: gtk::GtkInputHints);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_set_input_purpose(self_: *mut AdwEntryRow, purpose: gtk::GtkInputPurpose);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_entry_row_set_max_length(self_: *mut AdwEntryRow, max_length: c_int);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_set_show_apply_button(
        self_: *mut AdwEntryRow,
        show_apply_button: gboolean,
    );

    //=========================================================================
    // AdwEnumListItem
    //=========================================================================
    pub fn adw_enum_list_item_get_type() -> GType;
    pub fn adw_enum_list_item_get_name(self_: *mut AdwEnumListItem) -> *const c_char;
    pub fn adw_enum_list_item_get_nick(self_: *mut AdwEnumListItem) -> *const c_char;
    pub fn adw_enum_list_item_get_value(self_: *mut AdwEnumListItem) -> c_int;

    //=========================================================================
    // AdwEnumListModel
    //=========================================================================
    pub fn adw_enum_list_model_get_type() -> GType;
    pub fn adw_enum_list_model_new(enum_type: GType) -> *mut AdwEnumListModel;
    pub fn adw_enum_list_model_find_position(self_: *mut AdwEnumListModel, value: c_int) -> c_uint;
    pub fn adw_enum_list_model_get_enum_type(self_: *mut AdwEnumListModel) -> GType;

    //=========================================================================
    // AdwExpanderRow
    //=========================================================================
    pub fn adw_expander_row_get_type() -> GType;
    pub fn adw_expander_row_new() -> *mut gtk::GtkWidget;
    pub fn adw_expander_row_add_action(self_: *mut AdwExpanderRow, widget: *mut gtk::GtkWidget);
    pub fn adw_expander_row_add_prefix(self_: *mut AdwExpanderRow, widget: *mut gtk::GtkWidget);
    pub fn adw_expander_row_add_row(self_: *mut AdwExpanderRow, child: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_expander_row_add_suffix(self_: *mut AdwExpanderRow, widget: *mut gtk::GtkWidget);
    pub fn adw_expander_row_get_enable_expansion(self_: *mut AdwExpanderRow) -> gboolean;
    pub fn adw_expander_row_get_expanded(self_: *mut AdwExpanderRow) -> gboolean;
    pub fn adw_expander_row_get_icon_name(self_: *mut AdwExpanderRow) -> *const c_char;
    pub fn adw_expander_row_get_show_enable_switch(self_: *mut AdwExpanderRow) -> gboolean;
    pub fn adw_expander_row_get_subtitle(self_: *mut AdwExpanderRow) -> *const c_char;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_expander_row_get_subtitle_lines(self_: *mut AdwExpanderRow) -> c_int;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_expander_row_get_title_lines(self_: *mut AdwExpanderRow) -> c_int;
    pub fn adw_expander_row_remove(self_: *mut AdwExpanderRow, child: *mut gtk::GtkWidget);
    pub fn adw_expander_row_set_enable_expansion(
        self_: *mut AdwExpanderRow,
        enable_expansion: gboolean,
    );
    pub fn adw_expander_row_set_expanded(self_: *mut AdwExpanderRow, expanded: gboolean);
    pub fn adw_expander_row_set_icon_name(self_: *mut AdwExpanderRow, icon_name: *const c_char);
    pub fn adw_expander_row_set_show_enable_switch(
        self_: *mut AdwExpanderRow,
        show_enable_switch: gboolean,
    );
    pub fn adw_expander_row_set_subtitle(self_: *mut AdwExpanderRow, subtitle: *const c_char);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_expander_row_set_subtitle_lines(self_: *mut AdwExpanderRow, subtitle_lines: c_int);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_expander_row_set_title_lines(self_: *mut AdwExpanderRow, title_lines: c_int);

    //=========================================================================
    // AdwFlap
    //=========================================================================
    pub fn adw_flap_get_type() -> GType;
    pub fn adw_flap_new() -> *mut gtk::GtkWidget;
    pub fn adw_flap_get_content(self_: *mut AdwFlap) -> *mut gtk::GtkWidget;
    pub fn adw_flap_get_flap(self_: *mut AdwFlap) -> *mut gtk::GtkWidget;
    pub fn adw_flap_get_flap_position(self_: *mut AdwFlap) -> gtk::GtkPackType;
    pub fn adw_flap_get_fold_duration(self_: *mut AdwFlap) -> c_uint;
    pub fn adw_flap_get_fold_policy(self_: *mut AdwFlap) -> AdwFlapFoldPolicy;
    pub fn adw_flap_get_fold_threshold_policy(self_: *mut AdwFlap) -> AdwFoldThresholdPolicy;
    pub fn adw_flap_get_folded(self_: *mut AdwFlap) -> gboolean;
    pub fn adw_flap_get_locked(self_: *mut AdwFlap) -> gboolean;
    pub fn adw_flap_get_modal(self_: *mut AdwFlap) -> gboolean;
    pub fn adw_flap_get_reveal_flap(self_: *mut AdwFlap) -> gboolean;
    pub fn adw_flap_get_reveal_params(self_: *mut AdwFlap) -> *mut AdwSpringParams;
    pub fn adw_flap_get_reveal_progress(self_: *mut AdwFlap) -> c_double;
    pub fn adw_flap_get_separator(self_: *mut AdwFlap) -> *mut gtk::GtkWidget;
    pub fn adw_flap_get_swipe_to_close(self_: *mut AdwFlap) -> gboolean;
    pub fn adw_flap_get_swipe_to_open(self_: *mut AdwFlap) -> gboolean;
    pub fn adw_flap_get_transition_type(self_: *mut AdwFlap) -> AdwFlapTransitionType;
    pub fn adw_flap_set_content(self_: *mut AdwFlap, content: *mut gtk::GtkWidget);
    pub fn adw_flap_set_flap(self_: *mut AdwFlap, flap: *mut gtk::GtkWidget);
    pub fn adw_flap_set_flap_position(self_: *mut AdwFlap, position: gtk::GtkPackType);
    pub fn adw_flap_set_fold_duration(self_: *mut AdwFlap, duration: c_uint);
    pub fn adw_flap_set_fold_policy(self_: *mut AdwFlap, policy: AdwFlapFoldPolicy);
    pub fn adw_flap_set_fold_threshold_policy(self_: *mut AdwFlap, policy: AdwFoldThresholdPolicy);
    pub fn adw_flap_set_locked(self_: *mut AdwFlap, locked: gboolean);
    pub fn adw_flap_set_modal(self_: *mut AdwFlap, modal: gboolean);
    pub fn adw_flap_set_reveal_flap(self_: *mut AdwFlap, reveal_flap: gboolean);
    pub fn adw_flap_set_reveal_params(self_: *mut AdwFlap, params: *mut AdwSpringParams);
    pub fn adw_flap_set_separator(self_: *mut AdwFlap, separator: *mut gtk::GtkWidget);
    pub fn adw_flap_set_swipe_to_close(self_: *mut AdwFlap, swipe_to_close: gboolean);
    pub fn adw_flap_set_swipe_to_open(self_: *mut AdwFlap, swipe_to_open: gboolean);
    pub fn adw_flap_set_transition_type(
        self_: *mut AdwFlap,
        transition_type: AdwFlapTransitionType,
    );

    //=========================================================================
    // AdwHeaderBar
    //=========================================================================
    pub fn adw_header_bar_get_type() -> GType;
    pub fn adw_header_bar_new() -> *mut gtk::GtkWidget;
    pub fn adw_header_bar_get_centering_policy(self_: *mut AdwHeaderBar) -> AdwCenteringPolicy;
    pub fn adw_header_bar_get_decoration_layout(self_: *mut AdwHeaderBar) -> *const c_char;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_header_bar_get_show_back_button(self_: *mut AdwHeaderBar) -> gboolean;
    pub fn adw_header_bar_get_show_end_title_buttons(self_: *mut AdwHeaderBar) -> gboolean;
    pub fn adw_header_bar_get_show_start_title_buttons(self_: *mut AdwHeaderBar) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_header_bar_get_show_title(self_: *mut AdwHeaderBar) -> gboolean;
    pub fn adw_header_bar_get_title_widget(self_: *mut AdwHeaderBar) -> *mut gtk::GtkWidget;
    pub fn adw_header_bar_pack_end(self_: *mut AdwHeaderBar, child: *mut gtk::GtkWidget);
    pub fn adw_header_bar_pack_start(self_: *mut AdwHeaderBar, child: *mut gtk::GtkWidget);
    pub fn adw_header_bar_remove(self_: *mut AdwHeaderBar, child: *mut gtk::GtkWidget);
    pub fn adw_header_bar_set_centering_policy(
        self_: *mut AdwHeaderBar,
        centering_policy: AdwCenteringPolicy,
    );
    pub fn adw_header_bar_set_decoration_layout(self_: *mut AdwHeaderBar, layout: *const c_char);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_header_bar_set_show_back_button(
        self_: *mut AdwHeaderBar,
        show_back_button: gboolean,
    );
    pub fn adw_header_bar_set_show_end_title_buttons(self_: *mut AdwHeaderBar, setting: gboolean);
    pub fn adw_header_bar_set_show_start_title_buttons(self_: *mut AdwHeaderBar, setting: gboolean);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_header_bar_set_show_title(self_: *mut AdwHeaderBar, show_title: gboolean);
    pub fn adw_header_bar_set_title_widget(
        self_: *mut AdwHeaderBar,
        title_widget: *mut gtk::GtkWidget,
    );

    //=========================================================================
    // AdwInlineViewSwitcher
    //=========================================================================
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_inline_view_switcher_get_type() -> GType;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_inline_view_switcher_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_inline_view_switcher_get_can_shrink(self_: *mut AdwInlineViewSwitcher) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_inline_view_switcher_get_display_mode(
        self_: *mut AdwInlineViewSwitcher,
    ) -> AdwInlineViewSwitcherDisplayMode;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_inline_view_switcher_get_homogeneous(self_: *mut AdwInlineViewSwitcher) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_inline_view_switcher_get_stack(
        self_: *mut AdwInlineViewSwitcher,
    ) -> *mut AdwViewStack;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_inline_view_switcher_set_can_shrink(
        self_: *mut AdwInlineViewSwitcher,
        can_shrink: gboolean,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_inline_view_switcher_set_display_mode(
        self_: *mut AdwInlineViewSwitcher,
        mode: AdwInlineViewSwitcherDisplayMode,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_inline_view_switcher_set_homogeneous(
        self_: *mut AdwInlineViewSwitcher,
        homogeneous: gboolean,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_inline_view_switcher_set_stack(
        self_: *mut AdwInlineViewSwitcher,
        stack: *mut AdwViewStack,
    );

    //=========================================================================
    // AdwLayout
    //=========================================================================
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_layout_get_type() -> GType;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_layout_new(content: *mut gtk::GtkWidget) -> *mut AdwLayout;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_layout_get_content(self_: *mut AdwLayout) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_layout_get_name(self_: *mut AdwLayout) -> *const c_char;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_layout_set_name(self_: *mut AdwLayout, name: *const c_char);

    //=========================================================================
    // AdwLayoutSlot
    //=========================================================================
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_layout_slot_get_type() -> GType;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_layout_slot_new(id: *const c_char) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_layout_slot_get_slot_id(self_: *mut AdwLayoutSlot) -> *const c_char;

    //=========================================================================
    // AdwLeaflet
    //=========================================================================
    pub fn adw_leaflet_get_type() -> GType;
    pub fn adw_leaflet_new() -> *mut gtk::GtkWidget;
    pub fn adw_leaflet_append(
        self_: *mut AdwLeaflet,
        child: *mut gtk::GtkWidget,
    ) -> *mut AdwLeafletPage;
    pub fn adw_leaflet_get_adjacent_child(
        self_: *mut AdwLeaflet,
        direction: AdwNavigationDirection,
    ) -> *mut gtk::GtkWidget;
    pub fn adw_leaflet_get_can_navigate_back(self_: *mut AdwLeaflet) -> gboolean;
    pub fn adw_leaflet_get_can_navigate_forward(self_: *mut AdwLeaflet) -> gboolean;
    pub fn adw_leaflet_get_can_unfold(self_: *mut AdwLeaflet) -> gboolean;
    pub fn adw_leaflet_get_child_by_name(
        self_: *mut AdwLeaflet,
        name: *const c_char,
    ) -> *mut gtk::GtkWidget;
    pub fn adw_leaflet_get_child_transition_params(self_: *mut AdwLeaflet) -> *mut AdwSpringParams;
    pub fn adw_leaflet_get_child_transition_running(self_: *mut AdwLeaflet) -> gboolean;
    pub fn adw_leaflet_get_fold_threshold_policy(self_: *mut AdwLeaflet) -> AdwFoldThresholdPolicy;
    pub fn adw_leaflet_get_folded(self_: *mut AdwLeaflet) -> gboolean;
    pub fn adw_leaflet_get_homogeneous(self_: *mut AdwLeaflet) -> gboolean;
    pub fn adw_leaflet_get_mode_transition_duration(self_: *mut AdwLeaflet) -> c_uint;
    pub fn adw_leaflet_get_page(
        self_: *mut AdwLeaflet,
        child: *mut gtk::GtkWidget,
    ) -> *mut AdwLeafletPage;
    pub fn adw_leaflet_get_pages(self_: *mut AdwLeaflet) -> *mut gtk::GtkSelectionModel;
    pub fn adw_leaflet_get_transition_type(self_: *mut AdwLeaflet) -> AdwLeafletTransitionType;
    pub fn adw_leaflet_get_visible_child(self_: *mut AdwLeaflet) -> *mut gtk::GtkWidget;
    pub fn adw_leaflet_get_visible_child_name(self_: *mut AdwLeaflet) -> *const c_char;
    pub fn adw_leaflet_insert_child_after(
        self_: *mut AdwLeaflet,
        child: *mut gtk::GtkWidget,
        sibling: *mut gtk::GtkWidget,
    ) -> *mut AdwLeafletPage;
    pub fn adw_leaflet_navigate(
        self_: *mut AdwLeaflet,
        direction: AdwNavigationDirection,
    ) -> gboolean;
    pub fn adw_leaflet_prepend(
        self_: *mut AdwLeaflet,
        child: *mut gtk::GtkWidget,
    ) -> *mut AdwLeafletPage;
    pub fn adw_leaflet_remove(self_: *mut AdwLeaflet, child: *mut gtk::GtkWidget);
    pub fn adw_leaflet_reorder_child_after(
        self_: *mut AdwLeaflet,
        child: *mut gtk::GtkWidget,
        sibling: *mut gtk::GtkWidget,
    );
    pub fn adw_leaflet_set_can_navigate_back(self_: *mut AdwLeaflet, can_navigate_back: gboolean);
    pub fn adw_leaflet_set_can_navigate_forward(
        self_: *mut AdwLeaflet,
        can_navigate_forward: gboolean,
    );
    pub fn adw_leaflet_set_can_unfold(self_: *mut AdwLeaflet, can_unfold: gboolean);
    pub fn adw_leaflet_set_child_transition_params(
        self_: *mut AdwLeaflet,
        params: *mut AdwSpringParams,
    );
    pub fn adw_leaflet_set_fold_threshold_policy(
        self_: *mut AdwLeaflet,
        policy: AdwFoldThresholdPolicy,
    );
    pub fn adw_leaflet_set_homogeneous(self_: *mut AdwLeaflet, homogeneous: gboolean);
    pub fn adw_leaflet_set_mode_transition_duration(self_: *mut AdwLeaflet, duration: c_uint);
    pub fn adw_leaflet_set_transition_type(
        self_: *mut AdwLeaflet,
        transition: AdwLeafletTransitionType,
    );
    pub fn adw_leaflet_set_visible_child(
        self_: *mut AdwLeaflet,
        visible_child: *mut gtk::GtkWidget,
    );
    pub fn adw_leaflet_set_visible_child_name(self_: *mut AdwLeaflet, name: *const c_char);

    //=========================================================================
    // AdwLeafletPage
    //=========================================================================
    pub fn adw_leaflet_page_get_type() -> GType;
    pub fn adw_leaflet_page_get_child(self_: *mut AdwLeafletPage) -> *mut gtk::GtkWidget;
    pub fn adw_leaflet_page_get_name(self_: *mut AdwLeafletPage) -> *const c_char;
    pub fn adw_leaflet_page_get_navigatable(self_: *mut AdwLeafletPage) -> gboolean;
    pub fn adw_leaflet_page_set_name(self_: *mut AdwLeafletPage, name: *const c_char);
    pub fn adw_leaflet_page_set_navigatable(self_: *mut AdwLeafletPage, navigatable: gboolean);

    //=========================================================================
    // AdwMessageDialog
    //=========================================================================
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_type() -> GType;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_new(
        parent: *mut gtk::GtkWindow,
        heading: *const c_char,
        body: *const c_char,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_add_response(
        self_: *mut AdwMessageDialog,
        id: *const c_char,
        label: *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_add_responses(
        self_: *mut AdwMessageDialog,
        first_id: *const c_char,
        ...
    );
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_message_dialog_choose(
        self_: *mut AdwMessageDialog,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_message_dialog_choose_finish(
        self_: *mut AdwMessageDialog,
        result: *mut gio::GAsyncResult,
    ) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_format_body(self_: *mut AdwMessageDialog, format: *const c_char, ...);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_format_body_markup(
        self_: *mut AdwMessageDialog,
        format: *const c_char,
        ...
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_format_heading(
        self_: *mut AdwMessageDialog,
        format: *const c_char,
        ...
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_format_heading_markup(
        self_: *mut AdwMessageDialog,
        format: *const c_char,
        ...
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_body(self_: *mut AdwMessageDialog) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_body_use_markup(self_: *mut AdwMessageDialog) -> gboolean;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_close_response(self_: *mut AdwMessageDialog) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_default_response(self_: *mut AdwMessageDialog) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_extra_child(self_: *mut AdwMessageDialog) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_heading(self_: *mut AdwMessageDialog) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_heading_use_markup(self_: *mut AdwMessageDialog) -> gboolean;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_response_appearance(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
    ) -> AdwResponseAppearance;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_response_enabled(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
    ) -> gboolean;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_response_label(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
    ) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_has_response(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
    ) -> gboolean;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_message_dialog_remove_response(self_: *mut AdwMessageDialog, id: *const c_char);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_response(self_: *mut AdwMessageDialog, response: *const c_char);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_body(self_: *mut AdwMessageDialog, body: *const c_char);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_body_use_markup(
        self_: *mut AdwMessageDialog,
        use_markup: gboolean,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_close_response(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_default_response(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_extra_child(
        self_: *mut AdwMessageDialog,
        child: *mut gtk::GtkWidget,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_heading(self_: *mut AdwMessageDialog, heading: *const c_char);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_heading_use_markup(
        self_: *mut AdwMessageDialog,
        use_markup: gboolean,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_response_appearance(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
        appearance: AdwResponseAppearance,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_response_enabled(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
        enabled: gboolean,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_response_label(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
        label: *const c_char,
    );

    //=========================================================================
    // AdwMultiLayoutView
    //=========================================================================
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_multi_layout_view_get_type() -> GType;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_multi_layout_view_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_multi_layout_view_add_layout(self_: *mut AdwMultiLayoutView, layout: *mut AdwLayout);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_multi_layout_view_get_child(
        self_: *mut AdwMultiLayoutView,
        id: *const c_char,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_multi_layout_view_get_layout(self_: *mut AdwMultiLayoutView) -> *mut AdwLayout;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_multi_layout_view_get_layout_by_name(
        self_: *mut AdwMultiLayoutView,
        name: *const c_char,
    ) -> *mut AdwLayout;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_multi_layout_view_get_layout_name(self_: *mut AdwMultiLayoutView) -> *const c_char;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_multi_layout_view_remove_layout(
        self_: *mut AdwMultiLayoutView,
        layout: *mut AdwLayout,
    );
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_multi_layout_view_set_child(
        self_: *mut AdwMultiLayoutView,
        id: *const c_char,
        child: *mut gtk::GtkWidget,
    );
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_multi_layout_view_set_layout(self_: *mut AdwMultiLayoutView, layout: *mut AdwLayout);
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_multi_layout_view_set_layout_name(
        self_: *mut AdwMultiLayoutView,
        name: *const c_char,
    );

    //=========================================================================
    // AdwNavigationPage
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_page_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_page_new(
        child: *mut gtk::GtkWidget,
        title: *const c_char,
    ) -> *mut AdwNavigationPage;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_page_new_with_tag(
        child: *mut gtk::GtkWidget,
        title: *const c_char,
        tag: *const c_char,
    ) -> *mut AdwNavigationPage;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_page_get_can_pop(self_: *mut AdwNavigationPage) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_page_get_child(self_: *mut AdwNavigationPage) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_page_get_tag(self_: *mut AdwNavigationPage) -> *const c_char;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_page_get_title(self_: *mut AdwNavigationPage) -> *const c_char;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_page_set_can_pop(self_: *mut AdwNavigationPage, can_pop: gboolean);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_page_set_child(self_: *mut AdwNavigationPage, child: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_page_set_tag(self_: *mut AdwNavigationPage, tag: *const c_char);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_page_set_title(self_: *mut AdwNavigationPage, title: *const c_char);

    //=========================================================================
    // AdwNavigationSplitView
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_get_collapsed(self_: *mut AdwNavigationSplitView) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_get_content(
        self_: *mut AdwNavigationSplitView,
    ) -> *mut AdwNavigationPage;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_get_max_sidebar_width(
        self_: *mut AdwNavigationSplitView,
    ) -> c_double;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_get_min_sidebar_width(
        self_: *mut AdwNavigationSplitView,
    ) -> c_double;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_get_show_content(
        self_: *mut AdwNavigationSplitView,
    ) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_get_sidebar(
        self_: *mut AdwNavigationSplitView,
    ) -> *mut AdwNavigationPage;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_navigation_split_view_get_sidebar_position(
        self_: *mut AdwNavigationSplitView,
    ) -> gtk::GtkPackType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_get_sidebar_width_fraction(
        self_: *mut AdwNavigationSplitView,
    ) -> c_double;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_get_sidebar_width_unit(
        self_: *mut AdwNavigationSplitView,
    ) -> AdwLengthUnit;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_set_collapsed(
        self_: *mut AdwNavigationSplitView,
        collapsed: gboolean,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_set_content(
        self_: *mut AdwNavigationSplitView,
        content: *mut AdwNavigationPage,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_set_max_sidebar_width(
        self_: *mut AdwNavigationSplitView,
        width: c_double,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_set_min_sidebar_width(
        self_: *mut AdwNavigationSplitView,
        width: c_double,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_set_show_content(
        self_: *mut AdwNavigationSplitView,
        show_content: gboolean,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_set_sidebar(
        self_: *mut AdwNavigationSplitView,
        sidebar: *mut AdwNavigationPage,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_navigation_split_view_set_sidebar_position(
        self_: *mut AdwNavigationSplitView,
        position: gtk::GtkPackType,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_set_sidebar_width_fraction(
        self_: *mut AdwNavigationSplitView,
        fraction: c_double,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_split_view_set_sidebar_width_unit(
        self_: *mut AdwNavigationSplitView,
        unit: AdwLengthUnit,
    );

    //=========================================================================
    // AdwNavigationView
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_add(self_: *mut AdwNavigationView, page: *mut AdwNavigationPage);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_find_page(
        self_: *mut AdwNavigationView,
        tag: *const c_char,
    ) -> *mut AdwNavigationPage;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_get_animate_transitions(self_: *mut AdwNavigationView) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_navigation_view_get_hhomogeneous(self_: *mut AdwNavigationView) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_get_navigation_stack(
        self_: *mut AdwNavigationView,
    ) -> *mut gio::GListModel;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_get_pop_on_escape(self_: *mut AdwNavigationView) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_get_previous_page(
        self_: *mut AdwNavigationView,
        page: *mut AdwNavigationPage,
    ) -> *mut AdwNavigationPage;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_navigation_view_get_vhomogeneous(self_: *mut AdwNavigationView) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_get_visible_page(
        self_: *mut AdwNavigationView,
    ) -> *mut AdwNavigationPage;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_navigation_view_get_visible_page_tag(self_: *mut AdwNavigationView)
        -> *const c_char;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_pop(self_: *mut AdwNavigationView) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_pop_to_page(
        self_: *mut AdwNavigationView,
        page: *mut AdwNavigationPage,
    ) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_pop_to_tag(
        self_: *mut AdwNavigationView,
        tag: *const c_char,
    ) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_push(self_: *mut AdwNavigationView, page: *mut AdwNavigationPage);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_push_by_tag(self_: *mut AdwNavigationView, tag: *const c_char);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_remove(self_: *mut AdwNavigationView, page: *mut AdwNavigationPage);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_replace(
        self_: *mut AdwNavigationView,
        pages: *mut *mut AdwNavigationPage,
        n_pages: c_int,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_replace_with_tags(
        self_: *mut AdwNavigationView,
        tags: *const *const c_char,
        n_tags: c_int,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_set_animate_transitions(
        self_: *mut AdwNavigationView,
        animate_transitions: gboolean,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_navigation_view_set_hhomogeneous(
        self_: *mut AdwNavigationView,
        hhomogeneous: gboolean,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_navigation_view_set_pop_on_escape(
        self_: *mut AdwNavigationView,
        pop_on_escape: gboolean,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_navigation_view_set_vhomogeneous(
        self_: *mut AdwNavigationView,
        vhomogeneous: gboolean,
    );

    //=========================================================================
    // AdwOverlaySplitView
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_get_collapsed(self_: *mut AdwOverlaySplitView) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_get_content(
        self_: *mut AdwOverlaySplitView,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_get_enable_hide_gesture(
        self_: *mut AdwOverlaySplitView,
    ) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_get_enable_show_gesture(
        self_: *mut AdwOverlaySplitView,
    ) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_get_max_sidebar_width(
        self_: *mut AdwOverlaySplitView,
    ) -> c_double;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_get_min_sidebar_width(
        self_: *mut AdwOverlaySplitView,
    ) -> c_double;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_get_pin_sidebar(self_: *mut AdwOverlaySplitView) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_get_show_sidebar(self_: *mut AdwOverlaySplitView) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_get_sidebar(
        self_: *mut AdwOverlaySplitView,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_get_sidebar_position(
        self_: *mut AdwOverlaySplitView,
    ) -> gtk::GtkPackType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_get_sidebar_width_fraction(
        self_: *mut AdwOverlaySplitView,
    ) -> c_double;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_get_sidebar_width_unit(
        self_: *mut AdwOverlaySplitView,
    ) -> AdwLengthUnit;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_set_collapsed(
        self_: *mut AdwOverlaySplitView,
        collapsed: gboolean,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_set_content(
        self_: *mut AdwOverlaySplitView,
        content: *mut gtk::GtkWidget,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_set_enable_hide_gesture(
        self_: *mut AdwOverlaySplitView,
        enable_hide_gesture: gboolean,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_set_enable_show_gesture(
        self_: *mut AdwOverlaySplitView,
        enable_show_gesture: gboolean,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_set_max_sidebar_width(
        self_: *mut AdwOverlaySplitView,
        width: c_double,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_set_min_sidebar_width(
        self_: *mut AdwOverlaySplitView,
        width: c_double,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_set_pin_sidebar(
        self_: *mut AdwOverlaySplitView,
        pin_sidebar: gboolean,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_set_show_sidebar(
        self_: *mut AdwOverlaySplitView,
        show_sidebar: gboolean,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_set_sidebar(
        self_: *mut AdwOverlaySplitView,
        sidebar: *mut gtk::GtkWidget,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_set_sidebar_position(
        self_: *mut AdwOverlaySplitView,
        position: gtk::GtkPackType,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_set_sidebar_width_fraction(
        self_: *mut AdwOverlaySplitView,
        fraction: c_double,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_overlay_split_view_set_sidebar_width_unit(
        self_: *mut AdwOverlaySplitView,
        unit: AdwLengthUnit,
    );

    //=========================================================================
    // AdwPasswordEntryRow
    //=========================================================================
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_password_entry_row_get_type() -> GType;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_password_entry_row_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // AdwPreferencesDialog
    //=========================================================================
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_preferences_dialog_get_type() -> GType;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_preferences_dialog_new() -> *mut AdwDialog;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_preferences_dialog_add(
        self_: *mut AdwPreferencesDialog,
        page: *mut AdwPreferencesPage,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_preferences_dialog_add_toast(self_: *mut AdwPreferencesDialog, toast: *mut AdwToast);
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_preferences_dialog_get_search_enabled(self_: *mut AdwPreferencesDialog) -> gboolean;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_preferences_dialog_get_visible_page(
        self_: *mut AdwPreferencesDialog,
    ) -> *mut AdwPreferencesPage;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_preferences_dialog_get_visible_page_name(
        self_: *mut AdwPreferencesDialog,
    ) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_preferences_dialog_pop_subpage(self_: *mut AdwPreferencesDialog) -> gboolean;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_preferences_dialog_push_subpage(
        self_: *mut AdwPreferencesDialog,
        page: *mut AdwNavigationPage,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_preferences_dialog_remove(
        self_: *mut AdwPreferencesDialog,
        page: *mut AdwPreferencesPage,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_preferences_dialog_set_search_enabled(
        self_: *mut AdwPreferencesDialog,
        search_enabled: gboolean,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_preferences_dialog_set_visible_page(
        self_: *mut AdwPreferencesDialog,
        page: *mut AdwPreferencesPage,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_preferences_dialog_set_visible_page_name(
        self_: *mut AdwPreferencesDialog,
        name: *const c_char,
    );

    //=========================================================================
    // AdwPreferencesGroup
    //=========================================================================
    pub fn adw_preferences_group_get_type() -> GType;
    pub fn adw_preferences_group_new() -> *mut gtk::GtkWidget;
    pub fn adw_preferences_group_add(self_: *mut AdwPreferencesGroup, child: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_preferences_group_bind_model(
        self_: *mut AdwPreferencesGroup,
        model: *mut gio::GListModel,
        create_row_func: gtk::GtkListBoxCreateWidgetFunc,
        user_data: gpointer,
        user_data_free_func: glib::GDestroyNotify,
    );
    pub fn adw_preferences_group_get_description(self_: *mut AdwPreferencesGroup) -> *const c_char;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn adw_preferences_group_get_header_suffix(
        self_: *mut AdwPreferencesGroup,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_preferences_group_get_row(
        self_: *mut AdwPreferencesGroup,
        index: c_uint,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_preferences_group_get_separate_rows(self_: *mut AdwPreferencesGroup) -> gboolean;
    pub fn adw_preferences_group_get_title(self_: *mut AdwPreferencesGroup) -> *const c_char;
    pub fn adw_preferences_group_remove(
        self_: *mut AdwPreferencesGroup,
        child: *mut gtk::GtkWidget,
    );
    pub fn adw_preferences_group_set_description(
        self_: *mut AdwPreferencesGroup,
        description: *const c_char,
    );
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn adw_preferences_group_set_header_suffix(
        self_: *mut AdwPreferencesGroup,
        suffix: *mut gtk::GtkWidget,
    );
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_preferences_group_set_separate_rows(
        self_: *mut AdwPreferencesGroup,
        separate_rows: gboolean,
    );
    pub fn adw_preferences_group_set_title(self_: *mut AdwPreferencesGroup, title: *const c_char);

    //=========================================================================
    // AdwPreferencesPage
    //=========================================================================
    pub fn adw_preferences_page_get_type() -> GType;
    pub fn adw_preferences_page_new() -> *mut gtk::GtkWidget;
    pub fn adw_preferences_page_add(
        self_: *mut AdwPreferencesPage,
        group: *mut AdwPreferencesGroup,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_preferences_page_get_banner(self_: *mut AdwPreferencesPage) -> *mut AdwBanner;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_preferences_page_get_description(self_: *mut AdwPreferencesPage) -> *const c_char;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_preferences_page_get_description_centered(
        self_: *mut AdwPreferencesPage,
    ) -> gboolean;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_preferences_page_get_group(
        self_: *mut AdwPreferencesPage,
        index: c_uint,
    ) -> *mut AdwPreferencesGroup;
    pub fn adw_preferences_page_get_icon_name(self_: *mut AdwPreferencesPage) -> *const c_char;
    pub fn adw_preferences_page_get_name(self_: *mut AdwPreferencesPage) -> *const c_char;
    pub fn adw_preferences_page_get_title(self_: *mut AdwPreferencesPage) -> *const c_char;
    pub fn adw_preferences_page_get_use_underline(self_: *mut AdwPreferencesPage) -> gboolean;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_preferences_page_insert(
        self_: *mut AdwPreferencesPage,
        group: *mut AdwPreferencesGroup,
        index: c_int,
    );
    pub fn adw_preferences_page_remove(
        self_: *mut AdwPreferencesPage,
        group: *mut AdwPreferencesGroup,
    );
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_preferences_page_scroll_to_top(self_: *mut AdwPreferencesPage);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_preferences_page_set_banner(self_: *mut AdwPreferencesPage, banner: *mut AdwBanner);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_preferences_page_set_description(
        self_: *mut AdwPreferencesPage,
        description: *const c_char,
    );
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_preferences_page_set_description_centered(
        self_: *mut AdwPreferencesPage,
        centered: gboolean,
    );
    pub fn adw_preferences_page_set_icon_name(
        self_: *mut AdwPreferencesPage,
        icon_name: *const c_char,
    );
    pub fn adw_preferences_page_set_name(self_: *mut AdwPreferencesPage, name: *const c_char);
    pub fn adw_preferences_page_set_title(self_: *mut AdwPreferencesPage, title: *const c_char);
    pub fn adw_preferences_page_set_use_underline(
        self_: *mut AdwPreferencesPage,
        use_underline: gboolean,
    );

    //=========================================================================
    // AdwPreferencesRow
    //=========================================================================
    pub fn adw_preferences_row_get_type() -> GType;
    pub fn adw_preferences_row_new() -> *mut gtk::GtkWidget;
    pub fn adw_preferences_row_get_title(self_: *mut AdwPreferencesRow) -> *const c_char;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn adw_preferences_row_get_title_selectable(self_: *mut AdwPreferencesRow) -> gboolean;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_preferences_row_get_use_markup(self_: *mut AdwPreferencesRow) -> gboolean;
    pub fn adw_preferences_row_get_use_underline(self_: *mut AdwPreferencesRow) -> gboolean;
    pub fn adw_preferences_row_set_title(self_: *mut AdwPreferencesRow, title: *const c_char);
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn adw_preferences_row_set_title_selectable(
        self_: *mut AdwPreferencesRow,
        title_selectable: gboolean,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_preferences_row_set_use_markup(self_: *mut AdwPreferencesRow, use_markup: gboolean);
    pub fn adw_preferences_row_set_use_underline(
        self_: *mut AdwPreferencesRow,
        use_underline: gboolean,
    );

    //=========================================================================
    // AdwPreferencesWindow
    //=========================================================================
    pub fn adw_preferences_window_get_type() -> GType;
    pub fn adw_preferences_window_new() -> *mut gtk::GtkWidget;
    pub fn adw_preferences_window_add(
        self_: *mut AdwPreferencesWindow,
        page: *mut AdwPreferencesPage,
    );
    pub fn adw_preferences_window_add_toast(self_: *mut AdwPreferencesWindow, toast: *mut AdwToast);
    pub fn adw_preferences_window_close_subpage(self_: *mut AdwPreferencesWindow);
    pub fn adw_preferences_window_get_can_navigate_back(
        self_: *mut AdwPreferencesWindow,
    ) -> gboolean;
    pub fn adw_preferences_window_get_search_enabled(self_: *mut AdwPreferencesWindow) -> gboolean;
    pub fn adw_preferences_window_get_visible_page(
        self_: *mut AdwPreferencesWindow,
    ) -> *mut AdwPreferencesPage;
    pub fn adw_preferences_window_get_visible_page_name(
        self_: *mut AdwPreferencesWindow,
    ) -> *const c_char;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_preferences_window_pop_subpage(self_: *mut AdwPreferencesWindow) -> gboolean;
    pub fn adw_preferences_window_present_subpage(
        self_: *mut AdwPreferencesWindow,
        subpage: *mut gtk::GtkWidget,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_preferences_window_push_subpage(
        self_: *mut AdwPreferencesWindow,
        page: *mut AdwNavigationPage,
    );
    pub fn adw_preferences_window_remove(
        self_: *mut AdwPreferencesWindow,
        page: *mut AdwPreferencesPage,
    );
    pub fn adw_preferences_window_set_can_navigate_back(
        self_: *mut AdwPreferencesWindow,
        can_navigate_back: gboolean,
    );
    pub fn adw_preferences_window_set_search_enabled(
        self_: *mut AdwPreferencesWindow,
        search_enabled: gboolean,
    );
    pub fn adw_preferences_window_set_visible_page(
        self_: *mut AdwPreferencesWindow,
        page: *mut AdwPreferencesPage,
    );
    pub fn adw_preferences_window_set_visible_page_name(
        self_: *mut AdwPreferencesWindow,
        name: *const c_char,
    );

    //=========================================================================
    // AdwPropertyAnimationTarget
    //=========================================================================
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_property_animation_target_get_type() -> GType;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_property_animation_target_new(
        object: *mut gobject::GObject,
        property_name: *const c_char,
    ) -> *mut AdwAnimationTarget;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_property_animation_target_new_for_pspec(
        object: *mut gobject::GObject,
        pspec: *mut gobject::GParamSpec,
    ) -> *mut AdwAnimationTarget;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_property_animation_target_get_object(
        self_: *mut AdwPropertyAnimationTarget,
    ) -> *mut gobject::GObject;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_property_animation_target_get_pspec(
        self_: *mut AdwPropertyAnimationTarget,
    ) -> *mut gobject::GParamSpec;

    //=========================================================================
    // AdwShortcutLabel
    //=========================================================================
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcut_label_get_type() -> GType;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcut_label_new(accelerator: *const c_char) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcut_label_get_accelerator(self_: *mut AdwShortcutLabel) -> *const c_char;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcut_label_get_disabled_text(self_: *mut AdwShortcutLabel) -> *const c_char;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcut_label_set_accelerator(
        self_: *mut AdwShortcutLabel,
        accelerator: *const c_char,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcut_label_set_disabled_text(
        self_: *mut AdwShortcutLabel,
        disabled_text: *const c_char,
    );

    //=========================================================================
    // AdwShortcutsDialog
    //=========================================================================
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_dialog_get_type() -> GType;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_dialog_new() -> *mut AdwDialog;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_dialog_add(
        self_: *mut AdwShortcutsDialog,
        section: *mut AdwShortcutsSection,
    );

    //=========================================================================
    // AdwShortcutsItem
    //=========================================================================
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_item_get_type() -> GType;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_item_new(
        title: *const c_char,
        accelerator: *const c_char,
    ) -> *mut AdwShortcutsItem;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_item_new_from_action(
        title: *const c_char,
        action_name: *const c_char,
    ) -> *mut AdwShortcutsItem;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_item_get_accelerator(self_: *mut AdwShortcutsItem) -> *const c_char;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_item_get_action_name(self_: *mut AdwShortcutsItem) -> *const c_char;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_item_get_direction(self_: *mut AdwShortcutsItem) -> gtk::GtkTextDirection;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_item_get_subtitle(self_: *mut AdwShortcutsItem) -> *const c_char;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_item_get_title(self_: *mut AdwShortcutsItem) -> *const c_char;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_item_set_accelerator(
        self_: *mut AdwShortcutsItem,
        accelerator: *const c_char,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_item_set_action_name(
        self_: *mut AdwShortcutsItem,
        action_name: *const c_char,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_item_set_direction(
        self_: *mut AdwShortcutsItem,
        direction: gtk::GtkTextDirection,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_item_set_subtitle(self_: *mut AdwShortcutsItem, subtitle: *const c_char);
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_item_set_title(self_: *mut AdwShortcutsItem, title: *const c_char);

    //=========================================================================
    // AdwShortcutsSection
    //=========================================================================
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_section_get_type() -> GType;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_section_new(title: *const c_char) -> *mut AdwShortcutsSection;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_section_add(self_: *mut AdwShortcutsSection, item: *mut AdwShortcutsItem);
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_section_get_title(self_: *mut AdwShortcutsSection) -> *const c_char;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_shortcuts_section_set_title(self_: *mut AdwShortcutsSection, title: *const c_char);

    //=========================================================================
    // AdwSpinRow
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_new(
        adjustment: *mut gtk::GtkAdjustment,
        climb_rate: c_double,
        digits: c_uint,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_new_with_range(
        min: c_double,
        max: c_double,
        step: c_double,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_configure(
        self_: *mut AdwSpinRow,
        adjustment: *mut gtk::GtkAdjustment,
        climb_rate: c_double,
        digits: c_uint,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_get_adjustment(self_: *mut AdwSpinRow) -> *mut gtk::GtkAdjustment;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_get_climb_rate(self_: *mut AdwSpinRow) -> c_double;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_get_digits(self_: *mut AdwSpinRow) -> c_uint;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_get_numeric(self_: *mut AdwSpinRow) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_get_snap_to_ticks(self_: *mut AdwSpinRow) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_get_update_policy(self_: *mut AdwSpinRow)
        -> gtk::GtkSpinButtonUpdatePolicy;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_get_value(self_: *mut AdwSpinRow) -> c_double;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_get_wrap(self_: *mut AdwSpinRow) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_set_adjustment(self_: *mut AdwSpinRow, adjustment: *mut gtk::GtkAdjustment);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_set_climb_rate(self_: *mut AdwSpinRow, climb_rate: c_double);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_set_digits(self_: *mut AdwSpinRow, digits: c_uint);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_set_numeric(self_: *mut AdwSpinRow, numeric: gboolean);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_set_range(self_: *mut AdwSpinRow, min: c_double, max: c_double);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_set_snap_to_ticks(self_: *mut AdwSpinRow, snap_to_ticks: gboolean);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_set_update_policy(
        self_: *mut AdwSpinRow,
        policy: gtk::GtkSpinButtonUpdatePolicy,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_set_value(self_: *mut AdwSpinRow, value: c_double);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_set_wrap(self_: *mut AdwSpinRow, wrap: gboolean);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_spin_row_update(self_: *mut AdwSpinRow);

    //=========================================================================
    // AdwSpinner
    //=========================================================================
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_spinner_get_type() -> GType;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_spinner_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // AdwSpinnerPaintable
    //=========================================================================
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_spinner_paintable_get_type() -> GType;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_spinner_paintable_new(widget: *mut gtk::GtkWidget) -> *mut AdwSpinnerPaintable;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_spinner_paintable_get_widget(self_: *mut AdwSpinnerPaintable)
        -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_spinner_paintable_set_widget(
        self_: *mut AdwSpinnerPaintable,
        widget: *mut gtk::GtkWidget,
    );

    //=========================================================================
    // AdwSplitButton
    //=========================================================================
    pub fn adw_split_button_get_type() -> GType;
    pub fn adw_split_button_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_split_button_get_can_shrink(self_: *mut AdwSplitButton) -> gboolean;
    pub fn adw_split_button_get_child(self_: *mut AdwSplitButton) -> *mut gtk::GtkWidget;
    pub fn adw_split_button_get_direction(self_: *mut AdwSplitButton) -> gtk::GtkArrowType;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_split_button_get_dropdown_tooltip(self_: *mut AdwSplitButton) -> *const c_char;
    pub fn adw_split_button_get_icon_name(self_: *mut AdwSplitButton) -> *const c_char;
    pub fn adw_split_button_get_label(self_: *mut AdwSplitButton) -> *const c_char;
    pub fn adw_split_button_get_menu_model(self_: *mut AdwSplitButton) -> *mut gio::GMenuModel;
    pub fn adw_split_button_get_popover(self_: *mut AdwSplitButton) -> *mut gtk::GtkPopover;
    pub fn adw_split_button_get_use_underline(self_: *mut AdwSplitButton) -> gboolean;
    pub fn adw_split_button_popdown(self_: *mut AdwSplitButton);
    pub fn adw_split_button_popup(self_: *mut AdwSplitButton);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_split_button_set_can_shrink(self_: *mut AdwSplitButton, can_shrink: gboolean);
    pub fn adw_split_button_set_child(self_: *mut AdwSplitButton, child: *mut gtk::GtkWidget);
    pub fn adw_split_button_set_direction(self_: *mut AdwSplitButton, direction: gtk::GtkArrowType);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_split_button_set_dropdown_tooltip(
        self_: *mut AdwSplitButton,
        tooltip: *const c_char,
    );
    pub fn adw_split_button_set_icon_name(self_: *mut AdwSplitButton, icon_name: *const c_char);
    pub fn adw_split_button_set_label(self_: *mut AdwSplitButton, label: *const c_char);
    pub fn adw_split_button_set_menu_model(
        self_: *mut AdwSplitButton,
        menu_model: *mut gio::GMenuModel,
    );
    pub fn adw_split_button_set_popover(self_: *mut AdwSplitButton, popover: *mut gtk::GtkPopover);
    pub fn adw_split_button_set_use_underline(self_: *mut AdwSplitButton, use_underline: gboolean);

    //=========================================================================
    // AdwSpringAnimation
    //=========================================================================
    pub fn adw_spring_animation_get_type() -> GType;
    pub fn adw_spring_animation_new(
        widget: *mut gtk::GtkWidget,
        from: c_double,
        to: c_double,
        spring_params: *mut AdwSpringParams,
        target: *mut AdwAnimationTarget,
    ) -> *mut AdwAnimation;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_spring_animation_calculate_value(
        self_: *mut AdwSpringAnimation,
        time: c_uint,
    ) -> c_double;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_spring_animation_calculate_velocity(
        self_: *mut AdwSpringAnimation,
        time: c_uint,
    ) -> c_double;
    pub fn adw_spring_animation_get_clamp(self_: *mut AdwSpringAnimation) -> gboolean;
    pub fn adw_spring_animation_get_epsilon(self_: *mut AdwSpringAnimation) -> c_double;
    pub fn adw_spring_animation_get_estimated_duration(self_: *mut AdwSpringAnimation) -> c_uint;
    pub fn adw_spring_animation_get_initial_velocity(self_: *mut AdwSpringAnimation) -> c_double;
    pub fn adw_spring_animation_get_spring_params(
        self_: *mut AdwSpringAnimation,
    ) -> *mut AdwSpringParams;
    pub fn adw_spring_animation_get_value_from(self_: *mut AdwSpringAnimation) -> c_double;
    pub fn adw_spring_animation_get_value_to(self_: *mut AdwSpringAnimation) -> c_double;
    pub fn adw_spring_animation_get_velocity(self_: *mut AdwSpringAnimation) -> c_double;
    pub fn adw_spring_animation_set_clamp(self_: *mut AdwSpringAnimation, clamp: gboolean);
    pub fn adw_spring_animation_set_epsilon(self_: *mut AdwSpringAnimation, epsilon: c_double);
    pub fn adw_spring_animation_set_initial_velocity(
        self_: *mut AdwSpringAnimation,
        velocity: c_double,
    );
    pub fn adw_spring_animation_set_spring_params(
        self_: *mut AdwSpringAnimation,
        spring_params: *mut AdwSpringParams,
    );
    pub fn adw_spring_animation_set_value_from(self_: *mut AdwSpringAnimation, value: c_double);
    pub fn adw_spring_animation_set_value_to(self_: *mut AdwSpringAnimation, value: c_double);

    //=========================================================================
    // AdwSqueezer
    //=========================================================================
    pub fn adw_squeezer_get_type() -> GType;
    pub fn adw_squeezer_new() -> *mut gtk::GtkWidget;
    pub fn adw_squeezer_add(
        self_: *mut AdwSqueezer,
        child: *mut gtk::GtkWidget,
    ) -> *mut AdwSqueezerPage;
    pub fn adw_squeezer_get_allow_none(self_: *mut AdwSqueezer) -> gboolean;
    pub fn adw_squeezer_get_homogeneous(self_: *mut AdwSqueezer) -> gboolean;
    pub fn adw_squeezer_get_interpolate_size(self_: *mut AdwSqueezer) -> gboolean;
    pub fn adw_squeezer_get_page(
        self_: *mut AdwSqueezer,
        child: *mut gtk::GtkWidget,
    ) -> *mut AdwSqueezerPage;
    pub fn adw_squeezer_get_pages(self_: *mut AdwSqueezer) -> *mut gtk::GtkSelectionModel;
    pub fn adw_squeezer_get_switch_threshold_policy(
        self_: *mut AdwSqueezer,
    ) -> AdwFoldThresholdPolicy;
    pub fn adw_squeezer_get_transition_duration(self_: *mut AdwSqueezer) -> c_uint;
    pub fn adw_squeezer_get_transition_running(self_: *mut AdwSqueezer) -> gboolean;
    pub fn adw_squeezer_get_transition_type(self_: *mut AdwSqueezer) -> AdwSqueezerTransitionType;
    pub fn adw_squeezer_get_visible_child(self_: *mut AdwSqueezer) -> *mut gtk::GtkWidget;
    pub fn adw_squeezer_get_xalign(self_: *mut AdwSqueezer) -> c_float;
    pub fn adw_squeezer_get_yalign(self_: *mut AdwSqueezer) -> c_float;
    pub fn adw_squeezer_remove(self_: *mut AdwSqueezer, child: *mut gtk::GtkWidget);
    pub fn adw_squeezer_set_allow_none(self_: *mut AdwSqueezer, allow_none: gboolean);
    pub fn adw_squeezer_set_homogeneous(self_: *mut AdwSqueezer, homogeneous: gboolean);
    pub fn adw_squeezer_set_interpolate_size(self_: *mut AdwSqueezer, interpolate_size: gboolean);
    pub fn adw_squeezer_set_switch_threshold_policy(
        self_: *mut AdwSqueezer,
        policy: AdwFoldThresholdPolicy,
    );
    pub fn adw_squeezer_set_transition_duration(self_: *mut AdwSqueezer, duration: c_uint);
    pub fn adw_squeezer_set_transition_type(
        self_: *mut AdwSqueezer,
        transition: AdwSqueezerTransitionType,
    );
    pub fn adw_squeezer_set_xalign(self_: *mut AdwSqueezer, xalign: c_float);
    pub fn adw_squeezer_set_yalign(self_: *mut AdwSqueezer, yalign: c_float);

    //=========================================================================
    // AdwSqueezerPage
    //=========================================================================
    pub fn adw_squeezer_page_get_type() -> GType;
    pub fn adw_squeezer_page_get_child(self_: *mut AdwSqueezerPage) -> *mut gtk::GtkWidget;
    pub fn adw_squeezer_page_get_enabled(self_: *mut AdwSqueezerPage) -> gboolean;
    pub fn adw_squeezer_page_set_enabled(self_: *mut AdwSqueezerPage, enabled: gboolean);

    //=========================================================================
    // AdwStatusPage
    //=========================================================================
    pub fn adw_status_page_get_type() -> GType;
    pub fn adw_status_page_new() -> *mut gtk::GtkWidget;
    pub fn adw_status_page_get_child(self_: *mut AdwStatusPage) -> *mut gtk::GtkWidget;
    pub fn adw_status_page_get_description(self_: *mut AdwStatusPage) -> *const c_char;
    pub fn adw_status_page_get_icon_name(self_: *mut AdwStatusPage) -> *const c_char;
    pub fn adw_status_page_get_paintable(self_: *mut AdwStatusPage) -> *mut gdk::GdkPaintable;
    pub fn adw_status_page_get_title(self_: *mut AdwStatusPage) -> *const c_char;
    pub fn adw_status_page_set_child(self_: *mut AdwStatusPage, child: *mut gtk::GtkWidget);
    pub fn adw_status_page_set_description(self_: *mut AdwStatusPage, description: *const c_char);
    pub fn adw_status_page_set_icon_name(self_: *mut AdwStatusPage, icon_name: *const c_char);
    pub fn adw_status_page_set_paintable(
        self_: *mut AdwStatusPage,
        paintable: *mut gdk::GdkPaintable,
    );
    pub fn adw_status_page_set_title(self_: *mut AdwStatusPage, title: *const c_char);

    //=========================================================================
    // AdwStyleManager
    //=========================================================================
    pub fn adw_style_manager_get_type() -> GType;
    pub fn adw_style_manager_get_default() -> *mut AdwStyleManager;
    pub fn adw_style_manager_get_for_display(display: *mut gdk::GdkDisplay)
        -> *mut AdwStyleManager;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_style_manager_get_accent_color(self_: *mut AdwStyleManager) -> AdwAccentColor;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_style_manager_get_accent_color_rgba(
        self_: *mut AdwStyleManager,
    ) -> *mut gdk::GdkRGBA;
    pub fn adw_style_manager_get_color_scheme(self_: *mut AdwStyleManager) -> AdwColorScheme;
    pub fn adw_style_manager_get_dark(self_: *mut AdwStyleManager) -> gboolean;
    pub fn adw_style_manager_get_display(self_: *mut AdwStyleManager) -> *mut gdk::GdkDisplay;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_style_manager_get_document_font_name(self_: *mut AdwStyleManager) -> *const c_char;
    pub fn adw_style_manager_get_high_contrast(self_: *mut AdwStyleManager) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_style_manager_get_monospace_font_name(self_: *mut AdwStyleManager) -> *const c_char;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_style_manager_get_system_supports_accent_colors(
        self_: *mut AdwStyleManager,
    ) -> gboolean;
    pub fn adw_style_manager_get_system_supports_color_schemes(
        self_: *mut AdwStyleManager,
    ) -> gboolean;
    pub fn adw_style_manager_set_color_scheme(
        self_: *mut AdwStyleManager,
        color_scheme: AdwColorScheme,
    );

    //=========================================================================
    // AdwSwipeTracker
    //=========================================================================
    pub fn adw_swipe_tracker_get_type() -> GType;
    pub fn adw_swipe_tracker_new(swipeable: *mut AdwSwipeable) -> *mut AdwSwipeTracker;
    pub fn adw_swipe_tracker_get_allow_long_swipes(self_: *mut AdwSwipeTracker) -> gboolean;
    pub fn adw_swipe_tracker_get_allow_mouse_drag(self_: *mut AdwSwipeTracker) -> gboolean;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_swipe_tracker_get_allow_window_handle(self_: *mut AdwSwipeTracker) -> gboolean;
    pub fn adw_swipe_tracker_get_enabled(self_: *mut AdwSwipeTracker) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_swipe_tracker_get_lower_overshoot(self_: *mut AdwSwipeTracker) -> gboolean;
    pub fn adw_swipe_tracker_get_reversed(self_: *mut AdwSwipeTracker) -> gboolean;
    pub fn adw_swipe_tracker_get_swipeable(self_: *mut AdwSwipeTracker) -> *mut AdwSwipeable;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_swipe_tracker_get_upper_overshoot(self_: *mut AdwSwipeTracker) -> gboolean;
    pub fn adw_swipe_tracker_set_allow_long_swipes(
        self_: *mut AdwSwipeTracker,
        allow_long_swipes: gboolean,
    );
    pub fn adw_swipe_tracker_set_allow_mouse_drag(
        self_: *mut AdwSwipeTracker,
        allow_mouse_drag: gboolean,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_swipe_tracker_set_allow_window_handle(
        self_: *mut AdwSwipeTracker,
        allow_window_handle: gboolean,
    );
    pub fn adw_swipe_tracker_set_enabled(self_: *mut AdwSwipeTracker, enabled: gboolean);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_swipe_tracker_set_lower_overshoot(self_: *mut AdwSwipeTracker, overshoot: gboolean);
    pub fn adw_swipe_tracker_set_reversed(self_: *mut AdwSwipeTracker, reversed: gboolean);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_swipe_tracker_set_upper_overshoot(self_: *mut AdwSwipeTracker, overshoot: gboolean);
    pub fn adw_swipe_tracker_shift_position(self_: *mut AdwSwipeTracker, delta: c_double);

    //=========================================================================
    // AdwSwitchRow
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_switch_row_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_switch_row_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_switch_row_get_active(self_: *mut AdwSwitchRow) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_switch_row_set_active(self_: *mut AdwSwitchRow, is_active: gboolean);

    //=========================================================================
    // AdwTabBar
    //=========================================================================
    pub fn adw_tab_bar_get_type() -> GType;
    pub fn adw_tab_bar_new() -> *mut AdwTabBar;
    pub fn adw_tab_bar_get_autohide(self_: *mut AdwTabBar) -> gboolean;
    pub fn adw_tab_bar_get_end_action_widget(self_: *mut AdwTabBar) -> *mut gtk::GtkWidget;
    pub fn adw_tab_bar_get_expand_tabs(self_: *mut AdwTabBar) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_tab_bar_get_extra_drag_preferred_action(self_: *mut AdwTabBar)
        -> gdk::GdkDragAction;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_bar_get_extra_drag_preload(self_: *mut AdwTabBar) -> gboolean;
    pub fn adw_tab_bar_get_inverted(self_: *mut AdwTabBar) -> gboolean;
    pub fn adw_tab_bar_get_is_overflowing(self_: *mut AdwTabBar) -> gboolean;
    pub fn adw_tab_bar_get_start_action_widget(self_: *mut AdwTabBar) -> *mut gtk::GtkWidget;
    pub fn adw_tab_bar_get_tabs_revealed(self_: *mut AdwTabBar) -> gboolean;
    pub fn adw_tab_bar_get_view(self_: *mut AdwTabBar) -> *mut AdwTabView;
    pub fn adw_tab_bar_set_autohide(self_: *mut AdwTabBar, autohide: gboolean);
    pub fn adw_tab_bar_set_end_action_widget(self_: *mut AdwTabBar, widget: *mut gtk::GtkWidget);
    pub fn adw_tab_bar_set_expand_tabs(self_: *mut AdwTabBar, expand_tabs: gboolean);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_bar_set_extra_drag_preload(self_: *mut AdwTabBar, preload: gboolean);
    pub fn adw_tab_bar_set_inverted(self_: *mut AdwTabBar, inverted: gboolean);
    pub fn adw_tab_bar_set_start_action_widget(self_: *mut AdwTabBar, widget: *mut gtk::GtkWidget);
    pub fn adw_tab_bar_set_view(self_: *mut AdwTabBar, view: *mut AdwTabView);
    pub fn adw_tab_bar_setup_extra_drop_target(
        self_: *mut AdwTabBar,
        actions: gdk::GdkDragAction,
        types: *mut GType,
        n_types: size_t,
    );

    //=========================================================================
    // AdwTabButton
    //=========================================================================
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_button_get_type() -> GType;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_button_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_button_get_view(self_: *mut AdwTabButton) -> *mut AdwTabView;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_button_set_view(self_: *mut AdwTabButton, view: *mut AdwTabView);

    //=========================================================================
    // AdwTabOverview
    //=========================================================================
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_type() -> GType;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_child(self_: *mut AdwTabOverview) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_enable_new_tab(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_enable_search(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_tab_overview_get_extra_drag_preferred_action(
        self_: *mut AdwTabOverview,
    ) -> gdk::GdkDragAction;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_extra_drag_preload(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_inverted(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_open(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_search_active(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_secondary_menu(self_: *mut AdwTabOverview) -> *mut gio::GMenuModel;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_show_end_title_buttons(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_show_start_title_buttons(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_view(self_: *mut AdwTabOverview) -> *mut AdwTabView;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_child(self_: *mut AdwTabOverview, child: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_enable_new_tab(
        self_: *mut AdwTabOverview,
        enable_new_tab: gboolean,
    );
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_enable_search(self_: *mut AdwTabOverview, enable_search: gboolean);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_extra_drag_preload(self_: *mut AdwTabOverview, preload: gboolean);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_inverted(self_: *mut AdwTabOverview, inverted: gboolean);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_open(self_: *mut AdwTabOverview, open: gboolean);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_secondary_menu(
        self_: *mut AdwTabOverview,
        secondary_menu: *mut gio::GMenuModel,
    );
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_show_end_title_buttons(
        self_: *mut AdwTabOverview,
        show_end_title_buttons: gboolean,
    );
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_show_start_title_buttons(
        self_: *mut AdwTabOverview,
        show_start_title_buttons: gboolean,
    );
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_view(self_: *mut AdwTabOverview, view: *mut AdwTabView);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_setup_extra_drop_target(
        self_: *mut AdwTabOverview,
        actions: gdk::GdkDragAction,
        types: *mut GType,
        n_types: size_t,
    );

    //=========================================================================
    // AdwTabPage
    //=========================================================================
    pub fn adw_tab_page_get_type() -> GType;
    pub fn adw_tab_page_get_child(self_: *mut AdwTabPage) -> *mut gtk::GtkWidget;
    pub fn adw_tab_page_get_icon(self_: *mut AdwTabPage) -> *mut gio::GIcon;
    pub fn adw_tab_page_get_indicator_activatable(self_: *mut AdwTabPage) -> gboolean;
    pub fn adw_tab_page_get_indicator_icon(self_: *mut AdwTabPage) -> *mut gio::GIcon;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_tab_page_get_indicator_tooltip(self_: *mut AdwTabPage) -> *const c_char;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_page_get_keyword(self_: *mut AdwTabPage) -> *const c_char;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_page_get_live_thumbnail(self_: *mut AdwTabPage) -> gboolean;
    pub fn adw_tab_page_get_loading(self_: *mut AdwTabPage) -> gboolean;
    pub fn adw_tab_page_get_needs_attention(self_: *mut AdwTabPage) -> gboolean;
    pub fn adw_tab_page_get_parent(self_: *mut AdwTabPage) -> *mut AdwTabPage;
    pub fn adw_tab_page_get_pinned(self_: *mut AdwTabPage) -> gboolean;
    pub fn adw_tab_page_get_selected(self_: *mut AdwTabPage) -> gboolean;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_page_get_thumbnail_xalign(self_: *mut AdwTabPage) -> c_float;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_page_get_thumbnail_yalign(self_: *mut AdwTabPage) -> c_float;
    pub fn adw_tab_page_get_title(self_: *mut AdwTabPage) -> *const c_char;
    pub fn adw_tab_page_get_tooltip(self_: *mut AdwTabPage) -> *const c_char;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_page_invalidate_thumbnail(self_: *mut AdwTabPage);
    pub fn adw_tab_page_set_icon(self_: *mut AdwTabPage, icon: *mut gio::GIcon);
    pub fn adw_tab_page_set_indicator_activatable(self_: *mut AdwTabPage, activatable: gboolean);
    pub fn adw_tab_page_set_indicator_icon(self_: *mut AdwTabPage, indicator_icon: *mut gio::GIcon);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_tab_page_set_indicator_tooltip(self_: *mut AdwTabPage, tooltip: *const c_char);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_page_set_keyword(self_: *mut AdwTabPage, keyword: *const c_char);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_page_set_live_thumbnail(self_: *mut AdwTabPage, live_thumbnail: gboolean);
    pub fn adw_tab_page_set_loading(self_: *mut AdwTabPage, loading: gboolean);
    pub fn adw_tab_page_set_needs_attention(self_: *mut AdwTabPage, needs_attention: gboolean);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_page_set_thumbnail_xalign(self_: *mut AdwTabPage, xalign: c_float);
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_page_set_thumbnail_yalign(self_: *mut AdwTabPage, yalign: c_float);
    pub fn adw_tab_page_set_title(self_: *mut AdwTabPage, title: *const c_char);
    pub fn adw_tab_page_set_tooltip(self_: *mut AdwTabPage, tooltip: *const c_char);

    //=========================================================================
    // AdwTabView
    //=========================================================================
    pub fn adw_tab_view_get_type() -> GType;
    pub fn adw_tab_view_new() -> *mut AdwTabView;
    pub fn adw_tab_view_add_page(
        self_: *mut AdwTabView,
        child: *mut gtk::GtkWidget,
        parent: *mut AdwTabPage,
    ) -> *mut AdwTabPage;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_tab_view_add_shortcuts(self_: *mut AdwTabView, shortcuts: AdwTabViewShortcuts);
    pub fn adw_tab_view_append(
        self_: *mut AdwTabView,
        child: *mut gtk::GtkWidget,
    ) -> *mut AdwTabPage;
    pub fn adw_tab_view_append_pinned(
        self_: *mut AdwTabView,
        child: *mut gtk::GtkWidget,
    ) -> *mut AdwTabPage;
    pub fn adw_tab_view_close_other_pages(self_: *mut AdwTabView, page: *mut AdwTabPage);
    pub fn adw_tab_view_close_page(self_: *mut AdwTabView, page: *mut AdwTabPage);
    pub fn adw_tab_view_close_page_finish(
        self_: *mut AdwTabView,
        page: *mut AdwTabPage,
        confirm: gboolean,
    );
    pub fn adw_tab_view_close_pages_after(self_: *mut AdwTabView, page: *mut AdwTabPage);
    pub fn adw_tab_view_close_pages_before(self_: *mut AdwTabView, page: *mut AdwTabPage);
    pub fn adw_tab_view_get_default_icon(self_: *mut AdwTabView) -> *mut gio::GIcon;
    pub fn adw_tab_view_get_is_transferring_page(self_: *mut AdwTabView) -> gboolean;
    pub fn adw_tab_view_get_menu_model(self_: *mut AdwTabView) -> *mut gio::GMenuModel;
    pub fn adw_tab_view_get_n_pages(self_: *mut AdwTabView) -> c_int;
    pub fn adw_tab_view_get_n_pinned_pages(self_: *mut AdwTabView) -> c_int;
    pub fn adw_tab_view_get_nth_page(self_: *mut AdwTabView, position: c_int) -> *mut AdwTabPage;
    pub fn adw_tab_view_get_page(
        self_: *mut AdwTabView,
        child: *mut gtk::GtkWidget,
    ) -> *mut AdwTabPage;
    pub fn adw_tab_view_get_page_position(self_: *mut AdwTabView, page: *mut AdwTabPage) -> c_int;
    pub fn adw_tab_view_get_pages(self_: *mut AdwTabView) -> *mut gtk::GtkSelectionModel;
    pub fn adw_tab_view_get_selected_page(self_: *mut AdwTabView) -> *mut AdwTabPage;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_tab_view_get_shortcuts(self_: *mut AdwTabView) -> AdwTabViewShortcuts;
    pub fn adw_tab_view_insert(
        self_: *mut AdwTabView,
        child: *mut gtk::GtkWidget,
        position: c_int,
    ) -> *mut AdwTabPage;
    pub fn adw_tab_view_insert_pinned(
        self_: *mut AdwTabView,
        child: *mut gtk::GtkWidget,
        position: c_int,
    ) -> *mut AdwTabPage;
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_view_invalidate_thumbnails(self_: *mut AdwTabView);
    pub fn adw_tab_view_prepend(
        self_: *mut AdwTabView,
        child: *mut gtk::GtkWidget,
    ) -> *mut AdwTabPage;
    pub fn adw_tab_view_prepend_pinned(
        self_: *mut AdwTabView,
        child: *mut gtk::GtkWidget,
    ) -> *mut AdwTabPage;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_tab_view_remove_shortcuts(self_: *mut AdwTabView, shortcuts: AdwTabViewShortcuts);
    pub fn adw_tab_view_reorder_backward(self_: *mut AdwTabView, page: *mut AdwTabPage)
        -> gboolean;
    pub fn adw_tab_view_reorder_first(self_: *mut AdwTabView, page: *mut AdwTabPage) -> gboolean;
    pub fn adw_tab_view_reorder_forward(self_: *mut AdwTabView, page: *mut AdwTabPage) -> gboolean;
    pub fn adw_tab_view_reorder_last(self_: *mut AdwTabView, page: *mut AdwTabPage) -> gboolean;
    pub fn adw_tab_view_reorder_page(
        self_: *mut AdwTabView,
        page: *mut AdwTabPage,
        position: c_int,
    ) -> gboolean;
    pub fn adw_tab_view_select_next_page(self_: *mut AdwTabView) -> gboolean;
    pub fn adw_tab_view_select_previous_page(self_: *mut AdwTabView) -> gboolean;
    pub fn adw_tab_view_set_default_icon(self_: *mut AdwTabView, default_icon: *mut gio::GIcon);
    pub fn adw_tab_view_set_menu_model(self_: *mut AdwTabView, menu_model: *mut gio::GMenuModel);
    pub fn adw_tab_view_set_page_pinned(
        self_: *mut AdwTabView,
        page: *mut AdwTabPage,
        pinned: gboolean,
    );
    pub fn adw_tab_view_set_selected_page(self_: *mut AdwTabView, selected_page: *mut AdwTabPage);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_tab_view_set_shortcuts(self_: *mut AdwTabView, shortcuts: AdwTabViewShortcuts);
    pub fn adw_tab_view_transfer_page(
        self_: *mut AdwTabView,
        page: *mut AdwTabPage,
        other_view: *mut AdwTabView,
        position: c_int,
    );

    //=========================================================================
    // AdwTimedAnimation
    //=========================================================================
    pub fn adw_timed_animation_get_type() -> GType;
    pub fn adw_timed_animation_new(
        widget: *mut gtk::GtkWidget,
        from: c_double,
        to: c_double,
        duration: c_uint,
        target: *mut AdwAnimationTarget,
    ) -> *mut AdwAnimation;
    pub fn adw_timed_animation_get_alternate(self_: *mut AdwTimedAnimation) -> gboolean;
    pub fn adw_timed_animation_get_duration(self_: *mut AdwTimedAnimation) -> c_uint;
    pub fn adw_timed_animation_get_easing(self_: *mut AdwTimedAnimation) -> AdwEasing;
    pub fn adw_timed_animation_get_repeat_count(self_: *mut AdwTimedAnimation) -> c_uint;
    pub fn adw_timed_animation_get_reverse(self_: *mut AdwTimedAnimation) -> gboolean;
    pub fn adw_timed_animation_get_value_from(self_: *mut AdwTimedAnimation) -> c_double;
    pub fn adw_timed_animation_get_value_to(self_: *mut AdwTimedAnimation) -> c_double;
    pub fn adw_timed_animation_set_alternate(self_: *mut AdwTimedAnimation, alternate: gboolean);
    pub fn adw_timed_animation_set_duration(self_: *mut AdwTimedAnimation, duration: c_uint);
    pub fn adw_timed_animation_set_easing(self_: *mut AdwTimedAnimation, easing: AdwEasing);
    pub fn adw_timed_animation_set_repeat_count(
        self_: *mut AdwTimedAnimation,
        repeat_count: c_uint,
    );
    pub fn adw_timed_animation_set_reverse(self_: *mut AdwTimedAnimation, reverse: gboolean);
    pub fn adw_timed_animation_set_value_from(self_: *mut AdwTimedAnimation, value: c_double);
    pub fn adw_timed_animation_set_value_to(self_: *mut AdwTimedAnimation, value: c_double);

    //=========================================================================
    // AdwToast
    //=========================================================================
    pub fn adw_toast_get_type() -> GType;
    pub fn adw_toast_new(title: *const c_char) -> *mut AdwToast;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_toast_new_format(format: *const c_char, ...) -> *mut AdwToast;
    pub fn adw_toast_dismiss(self_: *mut AdwToast);
    pub fn adw_toast_get_action_name(self_: *mut AdwToast) -> *const c_char;
    pub fn adw_toast_get_action_target_value(self_: *mut AdwToast) -> *mut glib::GVariant;
    pub fn adw_toast_get_button_label(self_: *mut AdwToast) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_toast_get_custom_title(self_: *mut AdwToast) -> *mut gtk::GtkWidget;
    pub fn adw_toast_get_priority(self_: *mut AdwToast) -> AdwToastPriority;
    pub fn adw_toast_get_timeout(self_: *mut AdwToast) -> c_uint;
    pub fn adw_toast_get_title(self_: *mut AdwToast) -> *const c_char;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toast_get_use_markup(self_: *mut AdwToast) -> gboolean;
    pub fn adw_toast_set_action_name(self_: *mut AdwToast, action_name: *const c_char);
    pub fn adw_toast_set_action_target(self_: *mut AdwToast, format_string: *const c_char, ...);
    pub fn adw_toast_set_action_target_value(
        self_: *mut AdwToast,
        action_target: *mut glib::GVariant,
    );
    pub fn adw_toast_set_button_label(self_: *mut AdwToast, button_label: *const c_char);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_toast_set_custom_title(self_: *mut AdwToast, widget: *mut gtk::GtkWidget);
    pub fn adw_toast_set_detailed_action_name(
        self_: *mut AdwToast,
        detailed_action_name: *const c_char,
    );
    pub fn adw_toast_set_priority(self_: *mut AdwToast, priority: AdwToastPriority);
    pub fn adw_toast_set_timeout(self_: *mut AdwToast, timeout: c_uint);
    pub fn adw_toast_set_title(self_: *mut AdwToast, title: *const c_char);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toast_set_use_markup(self_: *mut AdwToast, use_markup: gboolean);

    //=========================================================================
    // AdwToastOverlay
    //=========================================================================
    pub fn adw_toast_overlay_get_type() -> GType;
    pub fn adw_toast_overlay_new() -> *mut gtk::GtkWidget;
    pub fn adw_toast_overlay_add_toast(self_: *mut AdwToastOverlay, toast: *mut AdwToast);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toast_overlay_dismiss_all(self_: *mut AdwToastOverlay);
    pub fn adw_toast_overlay_get_child(self_: *mut AdwToastOverlay) -> *mut gtk::GtkWidget;
    pub fn adw_toast_overlay_set_child(self_: *mut AdwToastOverlay, child: *mut gtk::GtkWidget);

    //=========================================================================
    // AdwToggle
    //=========================================================================
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_get_type() -> GType;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_new() -> *mut AdwToggle;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_get_child(self_: *mut AdwToggle) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_get_enabled(self_: *mut AdwToggle) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_get_icon_name(self_: *mut AdwToggle) -> *const c_char;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_get_index(self_: *mut AdwToggle) -> c_uint;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_get_label(self_: *mut AdwToggle) -> *const c_char;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_get_name(self_: *mut AdwToggle) -> *const c_char;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_get_tooltip(self_: *mut AdwToggle) -> *const c_char;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_get_use_underline(self_: *mut AdwToggle) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_set_child(self_: *mut AdwToggle, child: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_set_enabled(self_: *mut AdwToggle, enabled: gboolean);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_set_icon_name(self_: *mut AdwToggle, icon_name: *const c_char);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_set_label(self_: *mut AdwToggle, label: *const c_char);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_set_name(self_: *mut AdwToggle, name: *const c_char);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_set_tooltip(self_: *mut AdwToggle, tooltip: *const c_char);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_set_use_underline(self_: *mut AdwToggle, use_underline: gboolean);

    //=========================================================================
    // AdwToggleGroup
    //=========================================================================
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_get_type() -> GType;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_add(self_: *mut AdwToggleGroup, toggle: *mut AdwToggle);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_get_active(self_: *mut AdwToggleGroup) -> c_uint;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_get_active_name(self_: *mut AdwToggleGroup) -> *const c_char;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_get_can_shrink(self_: *mut AdwToggleGroup) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_get_homogeneous(self_: *mut AdwToggleGroup) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_get_n_toggles(self_: *mut AdwToggleGroup) -> c_uint;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_get_toggle(self_: *mut AdwToggleGroup, index: c_uint)
        -> *mut AdwToggle;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_get_toggle_by_name(
        self_: *mut AdwToggleGroup,
        name: *const c_char,
    ) -> *mut AdwToggle;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_get_toggles(self_: *mut AdwToggleGroup) -> *mut gtk::GtkSelectionModel;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_remove(self_: *mut AdwToggleGroup, toggle: *mut AdwToggle);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_remove_all(self_: *mut AdwToggleGroup);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_set_active(self_: *mut AdwToggleGroup, active: c_uint);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_set_active_name(self_: *mut AdwToggleGroup, name: *const c_char);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_set_can_shrink(self_: *mut AdwToggleGroup, can_shrink: gboolean);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_toggle_group_set_homogeneous(self_: *mut AdwToggleGroup, homogeneous: gboolean);

    //=========================================================================
    // AdwToolbarView
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_add_bottom_bar(self_: *mut AdwToolbarView, widget: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_add_top_bar(self_: *mut AdwToolbarView, widget: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_get_bottom_bar_height(self_: *mut AdwToolbarView) -> c_int;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_get_bottom_bar_style(self_: *mut AdwToolbarView) -> AdwToolbarStyle;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_get_content(self_: *mut AdwToolbarView) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_get_extend_content_to_bottom_edge(
        self_: *mut AdwToolbarView,
    ) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_get_extend_content_to_top_edge(self_: *mut AdwToolbarView) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_get_reveal_bottom_bars(self_: *mut AdwToolbarView) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_get_reveal_top_bars(self_: *mut AdwToolbarView) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_get_top_bar_height(self_: *mut AdwToolbarView) -> c_int;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_get_top_bar_style(self_: *mut AdwToolbarView) -> AdwToolbarStyle;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_remove(self_: *mut AdwToolbarView, widget: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_set_bottom_bar_style(
        self_: *mut AdwToolbarView,
        style: AdwToolbarStyle,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_set_content(self_: *mut AdwToolbarView, content: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_set_extend_content_to_bottom_edge(
        self_: *mut AdwToolbarView,
        extend: gboolean,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_set_extend_content_to_top_edge(
        self_: *mut AdwToolbarView,
        extend: gboolean,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_set_reveal_bottom_bars(self_: *mut AdwToolbarView, reveal: gboolean);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_set_reveal_top_bars(self_: *mut AdwToolbarView, reveal: gboolean);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_toolbar_view_set_top_bar_style(self_: *mut AdwToolbarView, style: AdwToolbarStyle);

    //=========================================================================
    // AdwViewStack
    //=========================================================================
    pub fn adw_view_stack_get_type() -> GType;
    pub fn adw_view_stack_new() -> *mut gtk::GtkWidget;
    pub fn adw_view_stack_add(
        self_: *mut AdwViewStack,
        child: *mut gtk::GtkWidget,
    ) -> *mut AdwViewStackPage;
    pub fn adw_view_stack_add_named(
        self_: *mut AdwViewStack,
        child: *mut gtk::GtkWidget,
        name: *const c_char,
    ) -> *mut AdwViewStackPage;
    pub fn adw_view_stack_add_titled(
        self_: *mut AdwViewStack,
        child: *mut gtk::GtkWidget,
        name: *const c_char,
        title: *const c_char,
    ) -> *mut AdwViewStackPage;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_view_stack_add_titled_with_icon(
        self_: *mut AdwViewStack,
        child: *mut gtk::GtkWidget,
        name: *const c_char,
        title: *const c_char,
        icon_name: *const c_char,
    ) -> *mut AdwViewStackPage;
    pub fn adw_view_stack_get_child_by_name(
        self_: *mut AdwViewStack,
        name: *const c_char,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_view_stack_get_enable_transitions(self_: *mut AdwViewStack) -> gboolean;
    pub fn adw_view_stack_get_hhomogeneous(self_: *mut AdwViewStack) -> gboolean;
    pub fn adw_view_stack_get_page(
        self_: *mut AdwViewStack,
        child: *mut gtk::GtkWidget,
    ) -> *mut AdwViewStackPage;
    pub fn adw_view_stack_get_pages(self_: *mut AdwViewStack) -> *mut gtk::GtkSelectionModel;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_view_stack_get_transition_duration(self_: *mut AdwViewStack) -> c_uint;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_view_stack_get_transition_running(self_: *mut AdwViewStack) -> gboolean;
    pub fn adw_view_stack_get_vhomogeneous(self_: *mut AdwViewStack) -> gboolean;
    pub fn adw_view_stack_get_visible_child(self_: *mut AdwViewStack) -> *mut gtk::GtkWidget;
    pub fn adw_view_stack_get_visible_child_name(self_: *mut AdwViewStack) -> *const c_char;
    pub fn adw_view_stack_remove(self_: *mut AdwViewStack, child: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_view_stack_set_enable_transitions(
        self_: *mut AdwViewStack,
        enable_transitions: gboolean,
    );
    pub fn adw_view_stack_set_hhomogeneous(self_: *mut AdwViewStack, hhomogeneous: gboolean);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_view_stack_set_transition_duration(self_: *mut AdwViewStack, duration: c_uint);
    pub fn adw_view_stack_set_vhomogeneous(self_: *mut AdwViewStack, vhomogeneous: gboolean);
    pub fn adw_view_stack_set_visible_child(self_: *mut AdwViewStack, child: *mut gtk::GtkWidget);
    pub fn adw_view_stack_set_visible_child_name(self_: *mut AdwViewStack, name: *const c_char);

    //=========================================================================
    // AdwViewStackPage
    //=========================================================================
    pub fn adw_view_stack_page_get_type() -> GType;
    pub fn adw_view_stack_page_get_badge_number(self_: *mut AdwViewStackPage) -> c_uint;
    pub fn adw_view_stack_page_get_child(self_: *mut AdwViewStackPage) -> *mut gtk::GtkWidget;
    pub fn adw_view_stack_page_get_icon_name(self_: *mut AdwViewStackPage) -> *const c_char;
    pub fn adw_view_stack_page_get_name(self_: *mut AdwViewStackPage) -> *const c_char;
    pub fn adw_view_stack_page_get_needs_attention(self_: *mut AdwViewStackPage) -> gboolean;
    pub fn adw_view_stack_page_get_title(self_: *mut AdwViewStackPage) -> *const c_char;
    pub fn adw_view_stack_page_get_use_underline(self_: *mut AdwViewStackPage) -> gboolean;
    pub fn adw_view_stack_page_get_visible(self_: *mut AdwViewStackPage) -> gboolean;
    pub fn adw_view_stack_page_set_badge_number(self_: *mut AdwViewStackPage, badge_number: c_uint);
    pub fn adw_view_stack_page_set_icon_name(
        self_: *mut AdwViewStackPage,
        icon_name: *const c_char,
    );
    pub fn adw_view_stack_page_set_name(self_: *mut AdwViewStackPage, name: *const c_char);
    pub fn adw_view_stack_page_set_needs_attention(
        self_: *mut AdwViewStackPage,
        needs_attention: gboolean,
    );
    pub fn adw_view_stack_page_set_title(self_: *mut AdwViewStackPage, title: *const c_char);
    pub fn adw_view_stack_page_set_use_underline(
        self_: *mut AdwViewStackPage,
        use_underline: gboolean,
    );
    pub fn adw_view_stack_page_set_visible(self_: *mut AdwViewStackPage, visible: gboolean);

    //=========================================================================
    // AdwViewStackPages
    //=========================================================================
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_view_stack_pages_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_view_stack_pages_get_selected_page(
        self_: *mut AdwViewStackPages,
    ) -> *mut AdwViewStackPage;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_view_stack_pages_set_selected_page(
        self_: *mut AdwViewStackPages,
        page: *mut AdwViewStackPage,
    );

    //=========================================================================
    // AdwViewSwitcher
    //=========================================================================
    pub fn adw_view_switcher_get_type() -> GType;
    pub fn adw_view_switcher_new() -> *mut gtk::GtkWidget;
    pub fn adw_view_switcher_get_policy(self_: *mut AdwViewSwitcher) -> AdwViewSwitcherPolicy;
    pub fn adw_view_switcher_get_stack(self_: *mut AdwViewSwitcher) -> *mut AdwViewStack;
    pub fn adw_view_switcher_set_policy(self_: *mut AdwViewSwitcher, policy: AdwViewSwitcherPolicy);
    pub fn adw_view_switcher_set_stack(self_: *mut AdwViewSwitcher, stack: *mut AdwViewStack);

    //=========================================================================
    // AdwViewSwitcherBar
    //=========================================================================
    pub fn adw_view_switcher_bar_get_type() -> GType;
    pub fn adw_view_switcher_bar_new() -> *mut gtk::GtkWidget;
    pub fn adw_view_switcher_bar_get_reveal(self_: *mut AdwViewSwitcherBar) -> gboolean;
    pub fn adw_view_switcher_bar_get_stack(self_: *mut AdwViewSwitcherBar) -> *mut AdwViewStack;
    pub fn adw_view_switcher_bar_set_reveal(self_: *mut AdwViewSwitcherBar, reveal: gboolean);
    pub fn adw_view_switcher_bar_set_stack(
        self_: *mut AdwViewSwitcherBar,
        stack: *mut AdwViewStack,
    );

    //=========================================================================
    // AdwViewSwitcherTitle
    //=========================================================================
    pub fn adw_view_switcher_title_get_type() -> GType;
    pub fn adw_view_switcher_title_new() -> *mut gtk::GtkWidget;
    pub fn adw_view_switcher_title_get_stack(self_: *mut AdwViewSwitcherTitle)
        -> *mut AdwViewStack;
    pub fn adw_view_switcher_title_get_subtitle(self_: *mut AdwViewSwitcherTitle) -> *const c_char;
    pub fn adw_view_switcher_title_get_title(self_: *mut AdwViewSwitcherTitle) -> *const c_char;
    pub fn adw_view_switcher_title_get_title_visible(self_: *mut AdwViewSwitcherTitle) -> gboolean;
    pub fn adw_view_switcher_title_get_view_switcher_enabled(
        self_: *mut AdwViewSwitcherTitle,
    ) -> gboolean;
    pub fn adw_view_switcher_title_set_stack(
        self_: *mut AdwViewSwitcherTitle,
        stack: *mut AdwViewStack,
    );
    pub fn adw_view_switcher_title_set_subtitle(
        self_: *mut AdwViewSwitcherTitle,
        subtitle: *const c_char,
    );
    pub fn adw_view_switcher_title_set_title(
        self_: *mut AdwViewSwitcherTitle,
        title: *const c_char,
    );
    pub fn adw_view_switcher_title_set_view_switcher_enabled(
        self_: *mut AdwViewSwitcherTitle,
        enabled: gboolean,
    );

    //=========================================================================
    // AdwWindow
    //=========================================================================
    pub fn adw_window_get_type() -> GType;
    pub fn adw_window_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_window_add_breakpoint(self_: *mut AdwWindow, breakpoint: *mut AdwBreakpoint);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_window_get_adaptive_preview(self_: *mut AdwWindow) -> gboolean;
    pub fn adw_window_get_content(self_: *mut AdwWindow) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_window_get_current_breakpoint(self_: *mut AdwWindow) -> *mut AdwBreakpoint;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_window_get_dialogs(self_: *mut AdwWindow) -> *mut gio::GListModel;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_window_get_visible_dialog(self_: *mut AdwWindow) -> *mut AdwDialog;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_window_set_adaptive_preview(self_: *mut AdwWindow, adaptive_preview: gboolean);
    pub fn adw_window_set_content(self_: *mut AdwWindow, content: *mut gtk::GtkWidget);

    //=========================================================================
    // AdwWindowTitle
    //=========================================================================
    pub fn adw_window_title_get_type() -> GType;
    pub fn adw_window_title_new(
        title: *const c_char,
        subtitle: *const c_char,
    ) -> *mut gtk::GtkWidget;
    pub fn adw_window_title_get_subtitle(self_: *mut AdwWindowTitle) -> *const c_char;
    pub fn adw_window_title_get_title(self_: *mut AdwWindowTitle) -> *const c_char;
    pub fn adw_window_title_set_subtitle(self_: *mut AdwWindowTitle, subtitle: *const c_char);
    pub fn adw_window_title_set_title(self_: *mut AdwWindowTitle, title: *const c_char);

    //=========================================================================
    // AdwWrapBox
    //=========================================================================
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_type() -> GType;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_append(self_: *mut AdwWrapBox, child: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_align(self_: *mut AdwWrapBox) -> c_float;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_child_spacing(self_: *mut AdwWrapBox) -> c_int;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_child_spacing_unit(self_: *mut AdwWrapBox) -> AdwLengthUnit;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_justify(self_: *mut AdwWrapBox) -> AdwJustifyMode;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_justify_last_line(self_: *mut AdwWrapBox) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_line_homogeneous(self_: *mut AdwWrapBox) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_line_spacing(self_: *mut AdwWrapBox) -> c_int;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_line_spacing_unit(self_: *mut AdwWrapBox) -> AdwLengthUnit;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_natural_line_length(self_: *mut AdwWrapBox) -> c_int;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_natural_line_length_unit(self_: *mut AdwWrapBox) -> AdwLengthUnit;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_pack_direction(self_: *mut AdwWrapBox) -> AdwPackDirection;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_wrap_policy(self_: *mut AdwWrapBox) -> AdwWrapPolicy;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_get_wrap_reverse(self_: *mut AdwWrapBox) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_insert_child_after(
        self_: *mut AdwWrapBox,
        child: *mut gtk::GtkWidget,
        sibling: *mut gtk::GtkWidget,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_prepend(self_: *mut AdwWrapBox, child: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_remove(self_: *mut AdwWrapBox, child: *mut gtk::GtkWidget);
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn adw_wrap_box_remove_all(self_: *mut AdwWrapBox);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_reorder_child_after(
        self_: *mut AdwWrapBox,
        child: *mut gtk::GtkWidget,
        sibling: *mut gtk::GtkWidget,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_set_align(self_: *mut AdwWrapBox, align: c_float);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_set_child_spacing(self_: *mut AdwWrapBox, child_spacing: c_int);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_set_child_spacing_unit(self_: *mut AdwWrapBox, unit: AdwLengthUnit);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_set_justify(self_: *mut AdwWrapBox, justify: AdwJustifyMode);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_set_justify_last_line(self_: *mut AdwWrapBox, justify_last_line: gboolean);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_set_line_homogeneous(self_: *mut AdwWrapBox, homogeneous: gboolean);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_set_line_spacing(self_: *mut AdwWrapBox, line_spacing: c_int);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_set_line_spacing_unit(self_: *mut AdwWrapBox, unit: AdwLengthUnit);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_set_natural_line_length(self_: *mut AdwWrapBox, natural_line_length: c_int);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_set_natural_line_length_unit(self_: *mut AdwWrapBox, unit: AdwLengthUnit);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_set_pack_direction(
        self_: *mut AdwWrapBox,
        pack_direction: AdwPackDirection,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_set_wrap_policy(self_: *mut AdwWrapBox, wrap_policy: AdwWrapPolicy);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_box_set_wrap_reverse(self_: *mut AdwWrapBox, wrap_reverse: gboolean);

    //=========================================================================
    // AdwWrapLayout
    //=========================================================================
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_type() -> GType;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_new() -> *mut gtk::GtkLayoutManager;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_align(self_: *mut AdwWrapLayout) -> c_float;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_child_spacing(self_: *mut AdwWrapLayout) -> c_int;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_child_spacing_unit(self_: *mut AdwWrapLayout) -> AdwLengthUnit;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_justify(self_: *mut AdwWrapLayout) -> AdwJustifyMode;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_justify_last_line(self_: *mut AdwWrapLayout) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_line_homogeneous(self_: *mut AdwWrapLayout) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_line_spacing(self_: *mut AdwWrapLayout) -> c_int;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_line_spacing_unit(self_: *mut AdwWrapLayout) -> AdwLengthUnit;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_natural_line_length(self_: *mut AdwWrapLayout) -> c_int;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_natural_line_length_unit(self_: *mut AdwWrapLayout)
        -> AdwLengthUnit;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_pack_direction(self_: *mut AdwWrapLayout) -> AdwPackDirection;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_wrap_policy(self_: *mut AdwWrapLayout) -> AdwWrapPolicy;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_get_wrap_reverse(self_: *mut AdwWrapLayout) -> gboolean;
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_set_align(self_: *mut AdwWrapLayout, align: c_float);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_set_child_spacing(self_: *mut AdwWrapLayout, child_spacing: c_int);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_set_child_spacing_unit(self_: *mut AdwWrapLayout, unit: AdwLengthUnit);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_set_justify(self_: *mut AdwWrapLayout, justify: AdwJustifyMode);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_set_justify_last_line(
        self_: *mut AdwWrapLayout,
        justify_last_line: gboolean,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_set_line_homogeneous(self_: *mut AdwWrapLayout, homogeneous: gboolean);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_set_line_spacing(self_: *mut AdwWrapLayout, line_spacing: c_int);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_set_line_spacing_unit(self_: *mut AdwWrapLayout, unit: AdwLengthUnit);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_set_natural_line_length(
        self_: *mut AdwWrapLayout,
        natural_line_length: c_int,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_set_natural_line_length_unit(
        self_: *mut AdwWrapLayout,
        unit: AdwLengthUnit,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_set_pack_direction(
        self_: *mut AdwWrapLayout,
        pack_direction: AdwPackDirection,
    );
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_set_wrap_policy(self_: *mut AdwWrapLayout, wrap_policy: AdwWrapPolicy);
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    pub fn adw_wrap_layout_set_wrap_reverse(self_: *mut AdwWrapLayout, wrap_reverse: gboolean);

    //=========================================================================
    // AdwSwipeable
    //=========================================================================
    pub fn adw_swipeable_get_type() -> GType;
    pub fn adw_swipeable_get_cancel_progress(self_: *mut AdwSwipeable) -> c_double;
    pub fn adw_swipeable_get_distance(self_: *mut AdwSwipeable) -> c_double;
    pub fn adw_swipeable_get_progress(self_: *mut AdwSwipeable) -> c_double;
    pub fn adw_swipeable_get_snap_points(
        self_: *mut AdwSwipeable,
        n_snap_points: *mut c_int,
    ) -> *mut c_double;
    pub fn adw_swipeable_get_swipe_area(
        self_: *mut AdwSwipeable,
        navigation_direction: AdwNavigationDirection,
        is_drag: gboolean,
        rect: *mut gdk::GdkRectangle,
    );

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn adw_get_enable_animations(widget: *mut gtk::GtkWidget) -> gboolean;
    pub fn adw_get_major_version() -> c_uint;
    pub fn adw_get_micro_version() -> c_uint;
    pub fn adw_get_minor_version() -> c_uint;
    pub fn adw_init();
    pub fn adw_is_initialized() -> gboolean;
    pub fn adw_lerp(a: c_double, b: c_double, t: c_double) -> c_double;
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    pub fn adw_rgba_to_standalone(
        rgba: *const gdk::GdkRGBA,
        dark: gboolean,
        standalone_rgba: *mut gdk::GdkRGBA,
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_show_about_dialog(
        parent: *mut gtk::GtkWidget,
        first_property_name: *const c_char,
        ...
    );
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn adw_show_about_dialog_from_appdata(
        parent: *mut gtk::GtkWidget,
        resource_path: *const c_char,
        release_notes_version: *const c_char,
        first_property_name: *const c_char,
        ...
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn adw_show_about_window(
        parent: *mut gtk::GtkWindow,
        first_property_name: *const c_char,
        ...
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn adw_show_about_window_from_appdata(
        parent: *mut gtk::GtkWindow,
        resource_path: *const c_char,
        release_notes_version: *const c_char,
        first_property_name: *const c_char,
        ...
    );

}
