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

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

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

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

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

// Enums
pub type BisAlbumTransitionType = c_int;
pub const BIS_ALBUM_TRANSITION_TYPE_OVER: BisAlbumTransitionType = 0;
pub const BIS_ALBUM_TRANSITION_TYPE_UNDER: BisAlbumTransitionType = 1;
pub const BIS_ALBUM_TRANSITION_TYPE_SLIDE: BisAlbumTransitionType = 2;

pub type BisAnimationState = c_int;
pub const BIS_ANIMATION_IDLE: BisAnimationState = 0;
pub const BIS_ANIMATION_PAUSED: BisAnimationState = 1;
pub const BIS_ANIMATION_PLAYING: BisAnimationState = 2;
pub const BIS_ANIMATION_FINISHED: BisAnimationState = 3;

pub type BisEasing = c_int;
pub const BIS_LINEAR: BisEasing = 0;
pub const BIS_EASE_IN_QUAD: BisEasing = 1;
pub const BIS_EASE_OUT_QUAD: BisEasing = 2;
pub const BIS_EASE_IN_OUT_QUAD: BisEasing = 3;
pub const BIS_EASE_IN_CUBIC: BisEasing = 4;
pub const BIS_EASE_OUT_CUBIC: BisEasing = 5;
pub const BIS_EASE_IN_OUT_CUBIC: BisEasing = 6;
pub const BIS_EASE_IN_QUART: BisEasing = 7;
pub const BIS_EASE_OUT_QUART: BisEasing = 8;
pub const BIS_EASE_IN_OUT_QUART: BisEasing = 9;
pub const BIS_EASE_IN_QUINT: BisEasing = 10;
pub const BIS_EASE_OUT_QUINT: BisEasing = 11;
pub const BIS_EASE_IN_OUT_QUINT: BisEasing = 12;
pub const BIS_EASE_IN_SINE: BisEasing = 13;
pub const BIS_EASE_OUT_SINE: BisEasing = 14;
pub const BIS_EASE_IN_OUT_SINE: BisEasing = 15;
pub const BIS_EASE_IN_EXPO: BisEasing = 16;
pub const BIS_EASE_OUT_EXPO: BisEasing = 17;
pub const BIS_EASE_IN_OUT_EXPO: BisEasing = 18;
pub const BIS_EASE_IN_CIRC: BisEasing = 19;
pub const BIS_EASE_OUT_CIRC: BisEasing = 20;
pub const BIS_EASE_IN_OUT_CIRC: BisEasing = 21;
pub const BIS_EASE_IN_ELASTIC: BisEasing = 22;
pub const BIS_EASE_OUT_ELASTIC: BisEasing = 23;
pub const BIS_EASE_IN_OUT_ELASTIC: BisEasing = 24;
pub const BIS_EASE_IN_BACK: BisEasing = 25;
pub const BIS_EASE_OUT_BACK: BisEasing = 26;
pub const BIS_EASE_IN_OUT_BACK: BisEasing = 27;
pub const BIS_EASE_IN_BOUNCE: BisEasing = 28;
pub const BIS_EASE_OUT_BOUNCE: BisEasing = 29;
pub const BIS_EASE_IN_OUT_BOUNCE: BisEasing = 30;

pub type BisFoldThresholdPolicy = c_int;
pub const BIS_FOLD_THRESHOLD_POLICY_MINIMUM: BisFoldThresholdPolicy = 0;
pub const BIS_FOLD_THRESHOLD_POLICY_NATURAL: BisFoldThresholdPolicy = 1;

pub type BisHuggerTransitionType = c_int;
pub const BIS_HUGGER_TRANSITION_TYPE_NONE: BisHuggerTransitionType = 0;
pub const BIS_HUGGER_TRANSITION_TYPE_CROSSFADE: BisHuggerTransitionType = 1;

pub type BisLapelFoldPolicy = c_int;
pub const BIS_LAPEL_FOLD_POLICY_NEVER: BisLapelFoldPolicy = 0;
pub const BIS_LAPEL_FOLD_POLICY_ALWAYS: BisLapelFoldPolicy = 1;
pub const BIS_LAPEL_FOLD_POLICY_AUTO: BisLapelFoldPolicy = 2;

pub type BisLapelTransitionType = c_int;
pub const BIS_LAPEL_TRANSITION_TYPE_OVER: BisLapelTransitionType = 0;
pub const BIS_LAPEL_TRANSITION_TYPE_UNDER: BisLapelTransitionType = 1;
pub const BIS_LAPEL_TRANSITION_TYPE_SLIDE: BisLapelTransitionType = 2;

pub type BisNavigationDirection = c_int;
pub const BIS_NAVIGATION_DIRECTION_BACK: BisNavigationDirection = 0;
pub const BIS_NAVIGATION_DIRECTION_FORWARD: BisNavigationDirection = 1;

// Constants
pub const BIS_DURATION_INFINITE: c_uint = 4294967295;
pub const BIS_MAJOR_VERSION: c_int = 1;
pub const BIS_MICRO_VERSION: c_int = 0;
pub const BIS_MINOR_VERSION: c_int = 0;
pub const BIS_VERSION_S: &[u8] = b"1.0.0\0";

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

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

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

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

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

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

pub type BisAnimationClass = _BisAnimationClass;

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

pub type BisAnimationTargetClass = _BisAnimationTargetClass;

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

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

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

pub type BisCallbackAnimationTargetClass = _BisCallbackAnimationTargetClass;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub type BisPropertyAnimationTargetClass = _BisPropertyAnimationTargetClass;

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

pub type BisSpringAnimationClass = _BisSpringAnimationClass;

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

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

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

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

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

impl ::std::fmt::Debug for BisSwipeableInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("BisSwipeableInterface @ {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()
    }
}

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

pub type BisTimedAnimationClass = _BisTimedAnimationClass;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    //=========================================================================
    // BisAlbumTransitionType
    //=========================================================================
    pub fn bis_album_transition_type_get_type() -> GType;

    //=========================================================================
    // BisAnimationState
    //=========================================================================
    pub fn bis_animation_state_get_type() -> GType;

    //=========================================================================
    // BisEasing
    //=========================================================================
    pub fn bis_easing_get_type() -> GType;
    pub fn bis_easing_ease(self_: BisEasing, value: c_double) -> c_double;

    //=========================================================================
    // BisFoldThresholdPolicy
    //=========================================================================
    pub fn bis_fold_threshold_policy_get_type() -> GType;

    //=========================================================================
    // BisHuggerTransitionType
    //=========================================================================
    pub fn bis_hugger_transition_type_get_type() -> GType;

    //=========================================================================
    // BisLapelFoldPolicy
    //=========================================================================
    pub fn bis_lapel_fold_policy_get_type() -> GType;

    //=========================================================================
    // BisLapelTransitionType
    //=========================================================================
    pub fn bis_lapel_transition_type_get_type() -> GType;

    //=========================================================================
    // BisNavigationDirection
    //=========================================================================
    pub fn bis_navigation_direction_get_type() -> GType;

    //=========================================================================
    // BisSpringParams
    //=========================================================================
    pub fn bis_spring_params_get_type() -> GType;
    pub fn bis_spring_params_new(
        damping_ratio: c_double,
        mass: c_double,
        stiffness: c_double,
    ) -> *mut BisSpringParams;
    pub fn bis_spring_params_new_full(
        damping: c_double,
        mass: c_double,
        stiffness: c_double,
    ) -> *mut BisSpringParams;
    pub fn bis_spring_params_get_damping(self_: *mut BisSpringParams) -> c_double;
    pub fn bis_spring_params_get_damping_ratio(self_: *mut BisSpringParams) -> c_double;
    pub fn bis_spring_params_get_mass(self_: *mut BisSpringParams) -> c_double;
    pub fn bis_spring_params_get_stiffness(self_: *mut BisSpringParams) -> c_double;
    pub fn bis_spring_params_ref(self_: *mut BisSpringParams) -> *mut BisSpringParams;
    pub fn bis_spring_params_unref(self_: *mut BisSpringParams);

    //=========================================================================
    // BisAlbum
    //=========================================================================
    pub fn bis_album_get_type() -> GType;
    pub fn bis_album_new() -> *mut gtk::GtkWidget;
    pub fn bis_album_append(self_: *mut BisAlbum, child: *mut gtk::GtkWidget) -> *mut BisAlbumPage;
    pub fn bis_album_get_adjacent_child(
        self_: *mut BisAlbum,
        direction: BisNavigationDirection,
    ) -> *mut gtk::GtkWidget;
    pub fn bis_album_get_can_navigate_back(self_: *mut BisAlbum) -> gboolean;
    pub fn bis_album_get_can_navigate_forward(self_: *mut BisAlbum) -> gboolean;
    pub fn bis_album_get_can_unfold(self_: *mut BisAlbum) -> gboolean;
    pub fn bis_album_get_child_by_name(
        self_: *mut BisAlbum,
        name: *const c_char,
    ) -> *mut gtk::GtkWidget;
    pub fn bis_album_get_child_transition_params(self_: *mut BisAlbum) -> *mut BisSpringParams;
    pub fn bis_album_get_child_transition_running(self_: *mut BisAlbum) -> gboolean;
    pub fn bis_album_get_fold_threshold_policy(self_: *mut BisAlbum) -> BisFoldThresholdPolicy;
    pub fn bis_album_get_folded(self_: *mut BisAlbum) -> gboolean;
    pub fn bis_album_get_homogeneous(self_: *mut BisAlbum) -> gboolean;
    pub fn bis_album_get_mode_transition_duration(self_: *mut BisAlbum) -> c_uint;
    pub fn bis_album_get_page(
        self_: *mut BisAlbum,
        child: *mut gtk::GtkWidget,
    ) -> *mut BisAlbumPage;
    pub fn bis_album_get_pages(self_: *mut BisAlbum) -> *mut gtk::GtkSelectionModel;
    pub fn bis_album_get_transition_type(self_: *mut BisAlbum) -> BisAlbumTransitionType;
    pub fn bis_album_get_visible_child(self_: *mut BisAlbum) -> *mut gtk::GtkWidget;
    pub fn bis_album_get_visible_child_name(self_: *mut BisAlbum) -> *const c_char;
    pub fn bis_album_insert_child_after(
        self_: *mut BisAlbum,
        child: *mut gtk::GtkWidget,
        sibling: *mut gtk::GtkWidget,
    ) -> *mut BisAlbumPage;
    pub fn bis_album_navigate(self_: *mut BisAlbum, direction: BisNavigationDirection) -> gboolean;
    pub fn bis_album_prepend(self_: *mut BisAlbum, child: *mut gtk::GtkWidget)
        -> *mut BisAlbumPage;
    pub fn bis_album_remove(self_: *mut BisAlbum, child: *mut gtk::GtkWidget);
    pub fn bis_album_reorder_child_after(
        self_: *mut BisAlbum,
        child: *mut gtk::GtkWidget,
        sibling: *mut gtk::GtkWidget,
    );
    pub fn bis_album_set_can_navigate_back(self_: *mut BisAlbum, can_navigate_back: gboolean);
    pub fn bis_album_set_can_navigate_forward(self_: *mut BisAlbum, can_navigate_forward: gboolean);
    pub fn bis_album_set_can_unfold(self_: *mut BisAlbum, can_unfold: gboolean);
    pub fn bis_album_set_child_transition_params(
        self_: *mut BisAlbum,
        params: *mut BisSpringParams,
    );
    pub fn bis_album_set_fold_threshold_policy(
        self_: *mut BisAlbum,
        policy: BisFoldThresholdPolicy,
    );
    pub fn bis_album_set_homogeneous(self_: *mut BisAlbum, homogeneous: gboolean);
    pub fn bis_album_set_mode_transition_duration(self_: *mut BisAlbum, duration: c_uint);
    pub fn bis_album_set_transition_type(self_: *mut BisAlbum, transition: BisAlbumTransitionType);
    pub fn bis_album_set_visible_child(self_: *mut BisAlbum, visible_child: *mut gtk::GtkWidget);
    pub fn bis_album_set_visible_child_name(self_: *mut BisAlbum, name: *const c_char);

    //=========================================================================
    // BisAlbumPage
    //=========================================================================
    pub fn bis_album_page_get_type() -> GType;
    pub fn bis_album_page_get_child(self_: *mut BisAlbumPage) -> *mut gtk::GtkWidget;
    pub fn bis_album_page_get_name(self_: *mut BisAlbumPage) -> *const c_char;
    pub fn bis_album_page_get_navigatable(self_: *mut BisAlbumPage) -> gboolean;
    pub fn bis_album_page_set_name(self_: *mut BisAlbumPage, name: *const c_char);
    pub fn bis_album_page_set_navigatable(self_: *mut BisAlbumPage, navigatable: gboolean);

    //=========================================================================
    // BisAnimation
    //=========================================================================
    pub fn bis_animation_get_type() -> GType;
    pub fn bis_animation_get_state(self_: *mut BisAnimation) -> BisAnimationState;
    pub fn bis_animation_get_target(self_: *mut BisAnimation) -> *mut BisAnimationTarget;
    pub fn bis_animation_get_value(self_: *mut BisAnimation) -> c_double;
    pub fn bis_animation_get_widget(self_: *mut BisAnimation) -> *mut gtk::GtkWidget;
    pub fn bis_animation_pause(self_: *mut BisAnimation);
    pub fn bis_animation_play(self_: *mut BisAnimation);
    pub fn bis_animation_reset(self_: *mut BisAnimation);
    pub fn bis_animation_resume(self_: *mut BisAnimation);
    pub fn bis_animation_set_target(self_: *mut BisAnimation, target: *mut BisAnimationTarget);
    pub fn bis_animation_skip(self_: *mut BisAnimation);

    //=========================================================================
    // BisAnimationTarget
    //=========================================================================
    pub fn bis_animation_target_get_type() -> GType;

    //=========================================================================
    // BisBin
    //=========================================================================
    pub fn bis_bin_get_type() -> GType;
    pub fn bis_bin_new() -> *mut gtk::GtkWidget;
    pub fn bis_bin_get_child(self_: *mut BisBin) -> *mut gtk::GtkWidget;
    pub fn bis_bin_set_child(self_: *mut BisBin, child: *mut gtk::GtkWidget);

    //=========================================================================
    // BisCallbackAnimationTarget
    //=========================================================================
    pub fn bis_callback_animation_target_get_type() -> GType;
    pub fn bis_callback_animation_target_new(
        callback: BisAnimationTargetFunc,
        user_data: gpointer,
        destroy: glib::GDestroyNotify,
    ) -> *mut BisAnimationTarget;

    //=========================================================================
    // BisCarousel
    //=========================================================================
    pub fn bis_carousel_get_type() -> GType;
    pub fn bis_carousel_new() -> *mut gtk::GtkWidget;
    pub fn bis_carousel_append(self_: *mut BisCarousel, child: *mut gtk::GtkWidget);
    pub fn bis_carousel_get_allow_long_swipes(self_: *mut BisCarousel) -> gboolean;
    pub fn bis_carousel_get_allow_mouse_drag(self_: *mut BisCarousel) -> gboolean;
    pub fn bis_carousel_get_allow_scroll_wheel(self_: *mut BisCarousel) -> gboolean;
    pub fn bis_carousel_get_interactive(self_: *mut BisCarousel) -> gboolean;
    pub fn bis_carousel_get_n_pages(self_: *mut BisCarousel) -> c_uint;
    pub fn bis_carousel_get_nth_page(self_: *mut BisCarousel, n: c_uint) -> *mut gtk::GtkWidget;
    pub fn bis_carousel_get_position(self_: *mut BisCarousel) -> c_double;
    pub fn bis_carousel_get_reveal_duration(self_: *mut BisCarousel) -> c_uint;
    pub fn bis_carousel_get_scroll_params(self_: *mut BisCarousel) -> *mut BisSpringParams;
    pub fn bis_carousel_get_spacing(self_: *mut BisCarousel) -> c_uint;
    pub fn bis_carousel_insert(
        self_: *mut BisCarousel,
        child: *mut gtk::GtkWidget,
        position: c_int,
    );
    pub fn bis_carousel_prepend(self_: *mut BisCarousel, child: *mut gtk::GtkWidget);
    pub fn bis_carousel_remove(self_: *mut BisCarousel, child: *mut gtk::GtkWidget);
    pub fn bis_carousel_reorder(
        self_: *mut BisCarousel,
        child: *mut gtk::GtkWidget,
        position: c_int,
    );
    pub fn bis_carousel_scroll_to(
        self_: *mut BisCarousel,
        widget: *mut gtk::GtkWidget,
        animate: gboolean,
    );
    pub fn bis_carousel_set_allow_long_swipes(self_: *mut BisCarousel, allow_long_swipes: gboolean);
    pub fn bis_carousel_set_allow_mouse_drag(self_: *mut BisCarousel, allow_mouse_drag: gboolean);
    pub fn bis_carousel_set_allow_scroll_wheel(
        self_: *mut BisCarousel,
        allow_scroll_wheel: gboolean,
    );
    pub fn bis_carousel_set_interactive(self_: *mut BisCarousel, interactive: gboolean);
    pub fn bis_carousel_set_reveal_duration(self_: *mut BisCarousel, reveal_duration: c_uint);
    pub fn bis_carousel_set_scroll_params(self_: *mut BisCarousel, params: *mut BisSpringParams);
    pub fn bis_carousel_set_spacing(self_: *mut BisCarousel, spacing: c_uint);

    //=========================================================================
    // BisCarouselIndicatorDots
    //=========================================================================
    pub fn bis_carousel_indicator_dots_get_type() -> GType;
    pub fn bis_carousel_indicator_dots_new() -> *mut gtk::GtkWidget;
    pub fn bis_carousel_indicator_dots_get_carousel(
        self_: *mut BisCarouselIndicatorDots,
    ) -> *mut BisCarousel;
    pub fn bis_carousel_indicator_dots_set_carousel(
        self_: *mut BisCarouselIndicatorDots,
        carousel: *mut BisCarousel,
    );

    //=========================================================================
    // BisCarouselIndicatorLines
    //=========================================================================
    pub fn bis_carousel_indicator_lines_get_type() -> GType;
    pub fn bis_carousel_indicator_lines_new() -> *mut gtk::GtkWidget;
    pub fn bis_carousel_indicator_lines_get_carousel(
        self_: *mut BisCarouselIndicatorLines,
    ) -> *mut BisCarousel;
    pub fn bis_carousel_indicator_lines_set_carousel(
        self_: *mut BisCarouselIndicatorLines,
        carousel: *mut BisCarousel,
    );

    //=========================================================================
    // BisEnumListItem
    //=========================================================================
    pub fn bis_enum_list_item_get_type() -> GType;
    pub fn bis_enum_list_item_get_name(self_: *mut BisEnumListItem) -> *const c_char;
    pub fn bis_enum_list_item_get_nick(self_: *mut BisEnumListItem) -> *const c_char;
    pub fn bis_enum_list_item_get_value(self_: *mut BisEnumListItem) -> c_int;

    //=========================================================================
    // BisEnumListModel
    //=========================================================================
    pub fn bis_enum_list_model_get_type() -> GType;
    pub fn bis_enum_list_model_new(enum_type: GType) -> *mut BisEnumListModel;
    pub fn bis_enum_list_model_find_position(self_: *mut BisEnumListModel, value: c_int) -> c_uint;
    pub fn bis_enum_list_model_get_enum_type(self_: *mut BisEnumListModel) -> GType;

    //=========================================================================
    // BisHugger
    //=========================================================================
    pub fn bis_hugger_get_type() -> GType;
    pub fn bis_hugger_new() -> *mut gtk::GtkWidget;
    pub fn bis_hugger_add(self_: *mut BisHugger, child: *mut gtk::GtkWidget) -> *mut BisHuggerPage;
    pub fn bis_hugger_get_allow_none(self_: *mut BisHugger) -> gboolean;
    pub fn bis_hugger_get_homogeneous(self_: *mut BisHugger) -> gboolean;
    pub fn bis_hugger_get_interpolate_size(self_: *mut BisHugger) -> gboolean;
    pub fn bis_hugger_get_page(
        self_: *mut BisHugger,
        child: *mut gtk::GtkWidget,
    ) -> *mut BisHuggerPage;
    pub fn bis_hugger_get_pages(self_: *mut BisHugger) -> *mut gtk::GtkSelectionModel;
    pub fn bis_hugger_get_switch_threshold_policy(self_: *mut BisHugger) -> BisFoldThresholdPolicy;
    pub fn bis_hugger_get_transition_duration(self_: *mut BisHugger) -> c_uint;
    pub fn bis_hugger_get_transition_running(self_: *mut BisHugger) -> gboolean;
    pub fn bis_hugger_get_transition_type(self_: *mut BisHugger) -> BisHuggerTransitionType;
    pub fn bis_hugger_get_visible_child(self_: *mut BisHugger) -> *mut gtk::GtkWidget;
    pub fn bis_hugger_get_xalign(self_: *mut BisHugger) -> c_float;
    pub fn bis_hugger_get_yalign(self_: *mut BisHugger) -> c_float;
    pub fn bis_hugger_remove(self_: *mut BisHugger, child: *mut gtk::GtkWidget);
    pub fn bis_hugger_set_allow_none(self_: *mut BisHugger, allow_none: gboolean);
    pub fn bis_hugger_set_homogeneous(self_: *mut BisHugger, homogeneous: gboolean);
    pub fn bis_hugger_set_interpolate_size(self_: *mut BisHugger, interpolate_size: gboolean);
    pub fn bis_hugger_set_switch_threshold_policy(
        self_: *mut BisHugger,
        policy: BisFoldThresholdPolicy,
    );
    pub fn bis_hugger_set_transition_duration(self_: *mut BisHugger, duration: c_uint);
    pub fn bis_hugger_set_transition_type(
        self_: *mut BisHugger,
        transition: BisHuggerTransitionType,
    );
    pub fn bis_hugger_set_xalign(self_: *mut BisHugger, xalign: c_float);
    pub fn bis_hugger_set_yalign(self_: *mut BisHugger, yalign: c_float);

    //=========================================================================
    // BisHuggerPage
    //=========================================================================
    pub fn bis_hugger_page_get_type() -> GType;
    pub fn bis_hugger_page_get_child(self_: *mut BisHuggerPage) -> *mut gtk::GtkWidget;
    pub fn bis_hugger_page_get_enabled(self_: *mut BisHuggerPage) -> gboolean;
    pub fn bis_hugger_page_set_enabled(self_: *mut BisHuggerPage, enabled: gboolean);

    //=========================================================================
    // BisLapel
    //=========================================================================
    pub fn bis_lapel_get_type() -> GType;
    pub fn bis_lapel_new() -> *mut gtk::GtkWidget;
    pub fn bis_lapel_get_content(self_: *mut BisLapel) -> *mut gtk::GtkWidget;
    pub fn bis_lapel_get_fold_duration(self_: *mut BisLapel) -> c_uint;
    pub fn bis_lapel_get_fold_policy(self_: *mut BisLapel) -> BisLapelFoldPolicy;
    pub fn bis_lapel_get_fold_threshold_policy(self_: *mut BisLapel) -> BisFoldThresholdPolicy;
    pub fn bis_lapel_get_folded(self_: *mut BisLapel) -> gboolean;
    pub fn bis_lapel_get_lapel(self_: *mut BisLapel) -> *mut gtk::GtkWidget;
    pub fn bis_lapel_get_lapel_position(self_: *mut BisLapel) -> gtk::GtkPackType;
    pub fn bis_lapel_get_locked(self_: *mut BisLapel) -> gboolean;
    pub fn bis_lapel_get_modal(self_: *mut BisLapel) -> gboolean;
    pub fn bis_lapel_get_reveal_lapel(self_: *mut BisLapel) -> gboolean;
    pub fn bis_lapel_get_reveal_params(self_: *mut BisLapel) -> *mut BisSpringParams;
    pub fn bis_lapel_get_reveal_progress(self_: *mut BisLapel) -> c_double;
    pub fn bis_lapel_get_separator(self_: *mut BisLapel) -> *mut gtk::GtkWidget;
    pub fn bis_lapel_get_swipe_to_close(self_: *mut BisLapel) -> gboolean;
    pub fn bis_lapel_get_swipe_to_open(self_: *mut BisLapel) -> gboolean;
    pub fn bis_lapel_get_transition_type(self_: *mut BisLapel) -> BisLapelTransitionType;
    pub fn bis_lapel_set_content(self_: *mut BisLapel, content: *mut gtk::GtkWidget);
    pub fn bis_lapel_set_fold_duration(self_: *mut BisLapel, duration: c_uint);
    pub fn bis_lapel_set_fold_policy(self_: *mut BisLapel, policy: BisLapelFoldPolicy);
    pub fn bis_lapel_set_fold_threshold_policy(
        self_: *mut BisLapel,
        policy: BisFoldThresholdPolicy,
    );
    pub fn bis_lapel_set_lapel(self_: *mut BisLapel, lapel: *mut gtk::GtkWidget);
    pub fn bis_lapel_set_lapel_position(self_: *mut BisLapel, position: gtk::GtkPackType);
    pub fn bis_lapel_set_locked(self_: *mut BisLapel, locked: gboolean);
    pub fn bis_lapel_set_modal(self_: *mut BisLapel, modal: gboolean);
    pub fn bis_lapel_set_reveal_lapel(self_: *mut BisLapel, reveal_lapel: gboolean);
    pub fn bis_lapel_set_reveal_params(self_: *mut BisLapel, params: *mut BisSpringParams);
    pub fn bis_lapel_set_separator(self_: *mut BisLapel, separator: *mut gtk::GtkWidget);
    pub fn bis_lapel_set_swipe_to_close(self_: *mut BisLapel, swipe_to_close: gboolean);
    pub fn bis_lapel_set_swipe_to_open(self_: *mut BisLapel, swipe_to_open: gboolean);
    pub fn bis_lapel_set_transition_type(
        self_: *mut BisLapel,
        transition_type: BisLapelTransitionType,
    );

    //=========================================================================
    // BisLatch
    //=========================================================================
    pub fn bis_latch_get_type() -> GType;
    pub fn bis_latch_new() -> *mut gtk::GtkWidget;
    pub fn bis_latch_get_child(self_: *mut BisLatch) -> *mut gtk::GtkWidget;
    pub fn bis_latch_get_maximum_size(self_: *mut BisLatch) -> c_int;
    pub fn bis_latch_get_tightening_threshold(self_: *mut BisLatch) -> c_int;
    pub fn bis_latch_set_child(self_: *mut BisLatch, child: *mut gtk::GtkWidget);
    pub fn bis_latch_set_maximum_size(self_: *mut BisLatch, maximum_size: c_int);
    pub fn bis_latch_set_tightening_threshold(self_: *mut BisLatch, tightening_threshold: c_int);

    //=========================================================================
    // BisLatchLayout
    //=========================================================================
    pub fn bis_latch_layout_get_type() -> GType;
    pub fn bis_latch_layout_new() -> *mut gtk::GtkLayoutManager;
    pub fn bis_latch_layout_get_maximum_size(self_: *mut BisLatchLayout) -> c_int;
    pub fn bis_latch_layout_get_tightening_threshold(self_: *mut BisLatchLayout) -> c_int;
    pub fn bis_latch_layout_set_maximum_size(self_: *mut BisLatchLayout, maximum_size: c_int);
    pub fn bis_latch_layout_set_tightening_threshold(
        self_: *mut BisLatchLayout,
        tightening_threshold: c_int,
    );

    //=========================================================================
    // BisLatchScrollable
    //=========================================================================
    pub fn bis_latch_scrollable_get_type() -> GType;
    pub fn bis_latch_scrollable_new() -> *mut gtk::GtkWidget;
    pub fn bis_latch_scrollable_get_child(self_: *mut BisLatchScrollable) -> *mut gtk::GtkWidget;
    pub fn bis_latch_scrollable_get_maximum_size(self_: *mut BisLatchScrollable) -> c_int;
    pub fn bis_latch_scrollable_get_tightening_threshold(self_: *mut BisLatchScrollable) -> c_int;
    pub fn bis_latch_scrollable_set_child(
        self_: *mut BisLatchScrollable,
        child: *mut gtk::GtkWidget,
    );
    pub fn bis_latch_scrollable_set_maximum_size(
        self_: *mut BisLatchScrollable,
        maximum_size: c_int,
    );
    pub fn bis_latch_scrollable_set_tightening_threshold(
        self_: *mut BisLatchScrollable,
        tightening_threshold: c_int,
    );

    //=========================================================================
    // BisPropertyAnimationTarget
    //=========================================================================
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn bis_property_animation_target_get_type() -> GType;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn bis_property_animation_target_new(
        object: *mut gobject::GObject,
        property_name: *const c_char,
    ) -> *mut BisAnimationTarget;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn bis_property_animation_target_new_for_pspec(
        object: *mut gobject::GObject,
        pspec: *mut gobject::GParamSpec,
    ) -> *mut BisAnimationTarget;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn bis_property_animation_target_get_object(
        self_: *mut BisPropertyAnimationTarget,
    ) -> *mut gobject::GObject;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn bis_property_animation_target_get_pspec(
        self_: *mut BisPropertyAnimationTarget,
    ) -> *mut gobject::GParamSpec;

    //=========================================================================
    // BisSpringAnimation
    //=========================================================================
    pub fn bis_spring_animation_get_type() -> GType;
    pub fn bis_spring_animation_new(
        widget: *mut gtk::GtkWidget,
        from: c_double,
        to: c_double,
        spring_params: *mut BisSpringParams,
        target: *mut BisAnimationTarget,
    ) -> *mut BisAnimation;
    pub fn bis_spring_animation_get_epsilon(self_: *mut BisSpringAnimation) -> c_double;
    pub fn bis_spring_animation_get_estimated_duration(self_: *mut BisSpringAnimation) -> c_uint;
    pub fn bis_spring_animation_get_initial_velocity(self_: *mut BisSpringAnimation) -> c_double;
    pub fn bis_spring_animation_get_latch(self_: *mut BisSpringAnimation) -> gboolean;
    pub fn bis_spring_animation_get_spring_params(
        self_: *mut BisSpringAnimation,
    ) -> *mut BisSpringParams;
    pub fn bis_spring_animation_get_value_from(self_: *mut BisSpringAnimation) -> c_double;
    pub fn bis_spring_animation_get_value_to(self_: *mut BisSpringAnimation) -> c_double;
    pub fn bis_spring_animation_get_velocity(self_: *mut BisSpringAnimation) -> c_double;
    pub fn bis_spring_animation_set_epsilon(self_: *mut BisSpringAnimation, epsilon: c_double);
    pub fn bis_spring_animation_set_initial_velocity(
        self_: *mut BisSpringAnimation,
        velocity: c_double,
    );
    pub fn bis_spring_animation_set_latch(self_: *mut BisSpringAnimation, latch: gboolean);
    pub fn bis_spring_animation_set_spring_params(
        self_: *mut BisSpringAnimation,
        spring_params: *mut BisSpringParams,
    );
    pub fn bis_spring_animation_set_value_from(self_: *mut BisSpringAnimation, value: c_double);
    pub fn bis_spring_animation_set_value_to(self_: *mut BisSpringAnimation, value: c_double);

    //=========================================================================
    // BisSwipeTracker
    //=========================================================================
    pub fn bis_swipe_tracker_get_type() -> GType;
    pub fn bis_swipe_tracker_new(swipeable: *mut BisSwipeable) -> *mut BisSwipeTracker;
    pub fn bis_swipe_tracker_get_allow_long_swipes(self_: *mut BisSwipeTracker) -> gboolean;
    pub fn bis_swipe_tracker_get_allow_mouse_drag(self_: *mut BisSwipeTracker) -> gboolean;
    pub fn bis_swipe_tracker_get_enabled(self_: *mut BisSwipeTracker) -> gboolean;
    pub fn bis_swipe_tracker_get_reversed(self_: *mut BisSwipeTracker) -> gboolean;
    pub fn bis_swipe_tracker_get_swipeable(self_: *mut BisSwipeTracker) -> *mut BisSwipeable;
    pub fn bis_swipe_tracker_set_allow_long_swipes(
        self_: *mut BisSwipeTracker,
        allow_long_swipes: gboolean,
    );
    pub fn bis_swipe_tracker_set_allow_mouse_drag(
        self_: *mut BisSwipeTracker,
        allow_mouse_drag: gboolean,
    );
    pub fn bis_swipe_tracker_set_enabled(self_: *mut BisSwipeTracker, enabled: gboolean);
    pub fn bis_swipe_tracker_set_reversed(self_: *mut BisSwipeTracker, reversed: gboolean);
    pub fn bis_swipe_tracker_shift_position(self_: *mut BisSwipeTracker, delta: c_double);

    //=========================================================================
    // BisTimedAnimation
    //=========================================================================
    pub fn bis_timed_animation_get_type() -> GType;
    pub fn bis_timed_animation_new(
        widget: *mut gtk::GtkWidget,
        from: c_double,
        to: c_double,
        duration: c_uint,
        target: *mut BisAnimationTarget,
    ) -> *mut BisAnimation;
    pub fn bis_timed_animation_get_alternate(self_: *mut BisTimedAnimation) -> gboolean;
    pub fn bis_timed_animation_get_duration(self_: *mut BisTimedAnimation) -> c_uint;
    pub fn bis_timed_animation_get_easing(self_: *mut BisTimedAnimation) -> BisEasing;
    pub fn bis_timed_animation_get_repeat_count(self_: *mut BisTimedAnimation) -> c_uint;
    pub fn bis_timed_animation_get_reverse(self_: *mut BisTimedAnimation) -> gboolean;
    pub fn bis_timed_animation_get_value_from(self_: *mut BisTimedAnimation) -> c_double;
    pub fn bis_timed_animation_get_value_to(self_: *mut BisTimedAnimation) -> c_double;
    pub fn bis_timed_animation_set_alternate(self_: *mut BisTimedAnimation, alternate: gboolean);
    pub fn bis_timed_animation_set_duration(self_: *mut BisTimedAnimation, duration: c_uint);
    pub fn bis_timed_animation_set_easing(self_: *mut BisTimedAnimation, easing: BisEasing);
    pub fn bis_timed_animation_set_repeat_count(
        self_: *mut BisTimedAnimation,
        repeat_count: c_uint,
    );
    pub fn bis_timed_animation_set_reverse(self_: *mut BisTimedAnimation, reverse: gboolean);
    pub fn bis_timed_animation_set_value_from(self_: *mut BisTimedAnimation, value: c_double);
    pub fn bis_timed_animation_set_value_to(self_: *mut BisTimedAnimation, value: c_double);

    //=========================================================================
    // BisSwipeable
    //=========================================================================
    pub fn bis_swipeable_get_type() -> GType;
    pub fn bis_swipeable_get_cancel_progress(self_: *mut BisSwipeable) -> c_double;
    pub fn bis_swipeable_get_distance(self_: *mut BisSwipeable) -> c_double;
    pub fn bis_swipeable_get_progress(self_: *mut BisSwipeable) -> c_double;
    pub fn bis_swipeable_get_snap_points(
        self_: *mut BisSwipeable,
        n_snap_points: *mut c_int,
    ) -> *mut c_double;
    pub fn bis_swipeable_get_swipe_area(
        self_: *mut BisSwipeable,
        navigation_direction: BisNavigationDirection,
        is_drag: gboolean,
        rect: *mut gdk::GdkRectangle,
    );

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn bis_get_enable_animations(widget: *mut gtk::GtkWidget) -> gboolean;
    pub fn bis_get_major_version() -> c_uint;
    pub fn bis_get_micro_version() -> c_uint;
    pub fn bis_get_minor_version() -> c_uint;
    pub fn bis_init();
    pub fn bis_is_initialized() -> gboolean;
    pub fn bis_lerp(a: c_double, b: c_double, t: c_double) -> c_double;

}