// Generated by gir (https://github.com/gtk-rs/gir @ 425f84d5af7f)
// from
// from gir-files (https://github.com/gtk-rs/gir-files.git @ 4eaad6a722bf)
// 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(feature = "dox", feature(doc_cfg))]

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

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

// Enums
pub type 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 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 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;

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 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 AdwNavigationDirection = c_int;
pub const ADW_NAVIGATION_DIRECTION_BACK: AdwNavigationDirection = 0;
pub const ADW_NAVIGATION_DIRECTION_FORWARD: AdwNavigationDirection = 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 AdwViewSwitcherPolicy = c_int;
pub const ADW_VIEW_SWITCHER_POLICY_NARROW: AdwViewSwitcherPolicy = 0;
pub const ADW_VIEW_SWITCHER_POLICY_WIDE: AdwViewSwitcherPolicy = 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 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()
    }
}

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

pub type AdwAnimationClass = *mut _AdwAnimationClass;

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

pub type AdwAnimationTargetClass = *mut _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 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()
    }
}

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

pub type AdwCallbackAnimationTargetClass = *mut _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 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 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 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 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)]
pub struct _AdwPropertyAnimationTargetClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type AdwPropertyAnimationTargetClass = *mut _AdwPropertyAnimationTargetClass;

#[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)]
pub struct _AdwSpringAnimationClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type AdwSpringAnimationClass = *mut _AdwSpringAnimationClass;

#[repr(C)]
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 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)]
pub struct _AdwTimedAnimationClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type AdwTimedAnimationClass = *mut _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 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 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()
    }
}

// Classes
#[repr(C)]
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 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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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 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)]
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)]
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)]
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)]
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)]
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)]
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)]
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 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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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)]
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()
    }
}

// Interfaces
#[repr(C)]
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}")
    }
}

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

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

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

    //=========================================================================
    // AdwColorScheme
    //=========================================================================
    pub fn adw_color_scheme_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;

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

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

    //=========================================================================
    // AdwResponseAppearance
    //=========================================================================
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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;

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

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

    //=========================================================================
    // 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);

    //=========================================================================
    // AdwAboutWindow
    //=========================================================================
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_type() -> GType;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_new() -> *mut gtk::GtkWidget;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_add_link(
        self_: *mut AdwAboutWindow,
        title: *const c_char,
        url: *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_application_icon(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_application_name(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_artists(self_: *mut AdwAboutWindow) -> *const *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_comments(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_copyright(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_debug_info(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_debug_info_filename(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_designers(self_: *mut AdwAboutWindow) -> *const *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_developer_name(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_developers(self_: *mut AdwAboutWindow) -> *const *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_documenters(self_: *mut AdwAboutWindow) -> *const *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_issue_url(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_license(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_license_type(self_: *mut AdwAboutWindow) -> gtk::GtkLicense;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_release_notes(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_release_notes_version(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_support_url(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_translator_credits(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_version(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_get_website(self_: *mut AdwAboutWindow) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_application_icon(
        self_: *mut AdwAboutWindow,
        application_icon: *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_application_name(
        self_: *mut AdwAboutWindow,
        application_name: *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_artists(self_: *mut AdwAboutWindow, artists: *mut *const c_char);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_comments(self_: *mut AdwAboutWindow, comments: *const c_char);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_copyright(self_: *mut AdwAboutWindow, copyright: *const c_char);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_debug_info(self_: *mut AdwAboutWindow, debug_info: *const c_char);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_debug_info_filename(
        self_: *mut AdwAboutWindow,
        filename: *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_designers(
        self_: *mut AdwAboutWindow,
        designers: *mut *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_developer_name(
        self_: *mut AdwAboutWindow,
        developer_name: *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_developers(
        self_: *mut AdwAboutWindow,
        developers: *mut *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_documenters(
        self_: *mut AdwAboutWindow,
        documenters: *mut *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_issue_url(self_: *mut AdwAboutWindow, issue_url: *const c_char);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_license(self_: *mut AdwAboutWindow, license: *const c_char);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_license_type(
        self_: *mut AdwAboutWindow,
        license_type: gtk::GtkLicense,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_release_notes(
        self_: *mut AdwAboutWindow,
        release_notes: *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_release_notes_version(
        self_: *mut AdwAboutWindow,
        version: *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_support_url(self_: *mut AdwAboutWindow, support_url: *const c_char);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_translator_credits(
        self_: *mut AdwAboutWindow,
        translator_credits: *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_about_window_set_version(self_: *mut AdwAboutWindow, version: *const c_char);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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);

    //=========================================================================
    // AdwAnimation
    //=========================================================================
    pub fn adw_animation_get_type() -> GType;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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;
    pub fn adw_application_window_get_content(
        self_: *mut AdwApplicationWindow,
    ) -> *mut gtk::GtkWidget;
    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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_get_type() -> GType;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_new(title: *const c_char) -> *mut gtk::GtkWidget;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_get_button_label(self_: *mut AdwBanner) -> *const c_char;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_get_revealed(self_: *mut AdwBanner) -> gboolean;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_get_title(self_: *mut AdwBanner) -> *const c_char;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_get_use_markup(self_: *mut AdwBanner) -> gboolean;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_set_button_label(self_: *mut AdwBanner, label: *const c_char);
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_set_revealed(self_: *mut AdwBanner, revealed: gboolean);
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_banner_set_title(self_: *mut AdwBanner, title: *const c_char);
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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);

    //=========================================================================
    // AdwButtonContent
    //=========================================================================
    pub fn adw_button_content_get_type() -> GType;
    pub fn adw_button_content_new() -> *mut gtk::GtkWidget;
    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;
    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,
    );

    //=========================================================================
    // 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;
    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);

    //=========================================================================
    // 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;
    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,
    );

    //=========================================================================
    // 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;
    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,
    );

    //=========================================================================
    // AdwComboRow
    //=========================================================================
    pub fn adw_combo_row_get_type() -> GType;
    pub fn adw_combo_row_new() -> *mut gtk::GtkWidget;
    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;
    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;
    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;
    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,
    );
    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);
    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);

    //=========================================================================
    // AdwEntryRow
    //=========================================================================
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_type() -> GType;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_new() -> *mut gtk::GtkWidget;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_add_prefix(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_add_suffix(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_activates_default(self_: *mut AdwEntryRow) -> gboolean;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_attributes(self_: *mut AdwEntryRow) -> *mut pango::PangoAttrList;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_enable_emoji_completion(self_: *mut AdwEntryRow) -> gboolean;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_input_hints(self_: *mut AdwEntryRow) -> gtk::GtkInputHints;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_input_purpose(self_: *mut AdwEntryRow) -> gtk::GtkInputPurpose;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_get_show_apply_button(self_: *mut AdwEntryRow) -> gboolean;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_entry_row_grab_focus_without_selecting(self_: *mut AdwEntryRow) -> gboolean;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_remove(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_set_activates_default(self_: *mut AdwEntryRow, activates: gboolean);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_set_attributes(
        self_: *mut AdwEntryRow,
        attributes: *mut pango::PangoAttrList,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_set_enable_emoji_completion(
        self_: *mut AdwEntryRow,
        enable_emoji_completion: gboolean,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_set_input_hints(self_: *mut AdwEntryRow, hints: gtk::GtkInputHints);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_entry_row_set_input_purpose(self_: *mut AdwEntryRow, purpose: gtk::GtkInputPurpose);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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);
    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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_expander_row_get_subtitle_lines(self_: *mut AdwExpanderRow) -> gboolean;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_expander_row_get_title_lines(self_: *mut AdwExpanderRow) -> gboolean;
    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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_expander_row_set_subtitle_lines(self_: *mut AdwExpanderRow, subtitle_lines: c_int);
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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;
    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;
    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);
    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);
    pub fn adw_header_bar_set_title_widget(
        self_: *mut AdwHeaderBar,
        title_widget: *mut gtk::GtkWidget,
    );

    //=========================================================================
    // 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_type() -> GType;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_add_response(
        self_: *mut AdwMessageDialog,
        id: *const c_char,
        label: *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_add_responses(
        self_: *mut AdwMessageDialog,
        first_id: *const c_char,
        ...
    );
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_message_dialog_choose_finish(
        self_: *mut AdwMessageDialog,
        result: *mut gio::GAsyncResult,
    ) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_format_body(self_: *mut AdwMessageDialog, format: *const c_char, ...);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_format_body_markup(
        self_: *mut AdwMessageDialog,
        format: *const c_char,
        ...
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_format_heading(
        self_: *mut AdwMessageDialog,
        format: *const c_char,
        ...
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_format_heading_markup(
        self_: *mut AdwMessageDialog,
        format: *const c_char,
        ...
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_body(self_: *mut AdwMessageDialog) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_body_use_markup(self_: *mut AdwMessageDialog) -> gboolean;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_close_response(self_: *mut AdwMessageDialog) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_default_response(self_: *mut AdwMessageDialog) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_extra_child(self_: *mut AdwMessageDialog) -> *mut gtk::GtkWidget;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_heading(self_: *mut AdwMessageDialog) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_heading_use_markup(self_: *mut AdwMessageDialog) -> gboolean;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_response_appearance(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
    ) -> AdwResponseAppearance;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_response_enabled(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
    ) -> gboolean;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_get_response_label(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
    ) -> *const c_char;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_has_response(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
    ) -> gboolean;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_response(self_: *mut AdwMessageDialog, response: *const c_char);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_body(self_: *mut AdwMessageDialog, body: *const c_char);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_body_use_markup(
        self_: *mut AdwMessageDialog,
        use_markup: gboolean,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_close_response(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_default_response(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_extra_child(
        self_: *mut AdwMessageDialog,
        child: *mut gtk::GtkWidget,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_heading(self_: *mut AdwMessageDialog, heading: *const c_char);
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_heading_use_markup(
        self_: *mut AdwMessageDialog,
        use_markup: gboolean,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_response_appearance(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
        appearance: AdwResponseAppearance,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_response_enabled(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
        enabled: gboolean,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_message_dialog_set_response_label(
        self_: *mut AdwMessageDialog,
        response: *const c_char,
        label: *const c_char,
    );

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

    //=========================================================================
    // 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);
    pub fn adw_preferences_group_get_description(self_: *mut AdwPreferencesGroup) -> *const c_char;
    #[cfg(any(feature = "v1_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
    pub fn adw_preferences_group_get_header_suffix(
        self_: *mut AdwPreferencesGroup,
    ) -> *mut gtk::GtkWidget;
    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(any(feature = "v1_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
    pub fn adw_preferences_group_set_header_suffix(
        self_: *mut AdwPreferencesGroup,
        suffix: *mut gtk::GtkWidget,
    );
    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,
    );
    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;
    pub fn adw_preferences_page_remove(
        self_: *mut AdwPreferencesPage,
        group: *mut AdwPreferencesGroup,
    );
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_preferences_page_scroll_to_top(self_: *mut AdwPreferencesPage);
    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(any(feature = "v1_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
    pub fn adw_preferences_row_get_title_selectable(self_: *mut AdwPreferencesRow) -> gboolean;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
    pub fn adw_preferences_row_set_title_selectable(
        self_: *mut AdwPreferencesRow,
        title_selectable: gboolean,
    );
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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;
    pub fn adw_preferences_window_present_subpage(
        self_: *mut AdwPreferencesWindow,
        subpage: *mut gtk::GtkWidget,
    );
    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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_property_animation_target_get_type() -> GType;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_property_animation_target_new(
        object: *mut gobject::GObject,
        property_name: *const c_char,
    ) -> *mut AdwAnimationTarget;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_property_animation_target_get_object(
        self_: *mut AdwPropertyAnimationTarget,
    ) -> *mut gobject::GObject;
    #[cfg(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_property_animation_target_get_pspec(
        self_: *mut AdwPropertyAnimationTarget,
    ) -> *mut gobject::GParamSpec;

    //=========================================================================
    // AdwSplitButton
    //=========================================================================
    pub fn adw_split_button_get_type() -> GType;
    pub fn adw_split_button_new() -> *mut gtk::GtkWidget;
    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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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);
    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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_spring_animation_calculate_value(
        self_: *mut AdwSpringAnimation,
        time: c_uint,
    ) -> c_double;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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;
    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;
    pub fn adw_style_manager_get_high_contrast(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;
    pub fn adw_swipe_tracker_get_enabled(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;
    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,
    );
    pub fn adw_swipe_tracker_set_enabled(self_: *mut AdwSwipeTracker, enabled: gboolean);
    pub fn adw_swipe_tracker_set_reversed(self_: *mut AdwSwipeTracker, reversed: gboolean);
    pub fn adw_swipe_tracker_shift_position(self_: *mut AdwSwipeTracker, delta: c_double);

    //=========================================================================
    // 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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_button_get_type() -> GType;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_button_new() -> *mut gtk::GtkWidget;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_button_get_view(self_: *mut AdwTabButton) -> *mut AdwTabView;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_button_set_view(self_: *mut AdwTabButton, view: *mut AdwTabView);

    //=========================================================================
    // AdwTabOverview
    //=========================================================================
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_type() -> GType;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_new() -> *mut gtk::GtkWidget;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_child(self_: *mut AdwTabOverview) -> *mut gtk::GtkWidget;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_enable_new_tab(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_enable_search(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_extra_drag_preload(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_inverted(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_open(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_search_active(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_secondary_menu(self_: *mut AdwTabOverview) -> *mut gio::GMenuModel;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_show_end_title_buttons(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_show_start_title_buttons(self_: *mut AdwTabOverview) -> gboolean;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_get_view(self_: *mut AdwTabOverview) -> *mut AdwTabView;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_child(self_: *mut AdwTabOverview, child: *mut gtk::GtkWidget);
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_enable_new_tab(
        self_: *mut AdwTabOverview,
        enable_new_tab: gboolean,
    );
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_enable_search(self_: *mut AdwTabOverview, enable_search: gboolean);
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_extra_drag_preload(self_: *mut AdwTabOverview, preload: gboolean);
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_inverted(self_: *mut AdwTabOverview, inverted: gboolean);
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_open(self_: *mut AdwTabOverview, open: gboolean);
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_secondary_menu(
        self_: *mut AdwTabOverview,
        secondary_menu: *mut gio::GMenuModel,
    );
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_show_end_title_buttons(
        self_: *mut AdwTabOverview,
        show_end_title_buttons: gboolean,
    );
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_show_start_title_buttons(
        self_: *mut AdwTabOverview,
        show_start_title_buttons: gboolean,
    );
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_overview_set_view(self_: *mut AdwTabOverview, view: *mut AdwTabView);
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_tab_page_get_indicator_tooltip(self_: *mut AdwTabPage) -> *const c_char;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_page_get_keyword(self_: *mut AdwTabPage) -> *const c_char;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_page_get_thumbnail_xalign(self_: *mut AdwTabPage) -> c_float;
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
    pub fn adw_tab_page_set_indicator_tooltip(self_: *mut AdwTabPage, tooltip: *const c_char);
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_page_set_keyword(self_: *mut AdwTabPage, keyword: *const c_char);
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
    pub fn adw_tab_page_set_thumbnail_xalign(self_: *mut AdwTabPage, xalign: c_float);
    #[cfg(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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;
    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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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);

    //=========================================================================
    // 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);
    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);

    //=========================================================================
    // 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(any(feature = "v1_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", 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;
    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;
    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);
    pub fn adw_view_stack_set_hhomogeneous(self_: *mut AdwViewStack, hhomogeneous: gboolean);
    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);

    //=========================================================================
    // 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;
    pub fn adw_window_get_content(self_: *mut AdwWindow) -> *mut gtk::GtkWidget;
    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);

    //=========================================================================
    // 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;
    pub fn adw_show_about_window(
        parent: *mut gtk::GtkWindow,
        first_property_name: *const c_char,
        ...
    );

}
