libxmlb-sys 0.4.0

// Generated by gir (https://github.com/gtk-rs/gir @ 8336b4ebe16f)
// from
// from gir-files (https://github.com/gtk-rs/gir-files.git @ 4d1189172a70)
// 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 gio_sys as gio;
use glib_sys as glib;
use gobject_sys as gobject;

#[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 XbOpcodeKind = c_int;
pub const XB_OPCODE_KIND_UNKNOWN: XbOpcodeKind = 0;
pub const XB_OPCODE_KIND_INTEGER: XbOpcodeKind = 1;
pub const XB_OPCODE_KIND_TEXT: XbOpcodeKind = 2;
pub const XB_OPCODE_KIND_FUNCTION: XbOpcodeKind = 5;
pub const XB_OPCODE_KIND_BOUND_UNSET: XbOpcodeKind = 8;
pub const XB_OPCODE_KIND_BOUND_INTEGER: XbOpcodeKind = 9;
pub const XB_OPCODE_KIND_BOUND_TEXT: XbOpcodeKind = 10;
pub const XB_OPCODE_KIND_INDEXED_TEXT: XbOpcodeKind = 3;
pub const XB_OPCODE_KIND_BOOLEAN: XbOpcodeKind = 17;
pub const XB_OPCODE_KIND_BOUND_INDEXED_TEXT: XbOpcodeKind = 11;

// Constants
pub const XMLB_MAJOR_VERSION: c_int = 0;
pub const XMLB_MICRO_VERSION: c_int = 19;
pub const XMLB_MINOR_VERSION: c_int = 3;

// Flags
pub type XbBuilderCompileFlags = c_uint;
pub const XB_BUILDER_COMPILE_FLAG_NONE: XbBuilderCompileFlags = 0;
pub const XB_BUILDER_COMPILE_FLAG_NATIVE_LANGS: XbBuilderCompileFlags = 2;
pub const XB_BUILDER_COMPILE_FLAG_IGNORE_INVALID: XbBuilderCompileFlags = 4;
pub const XB_BUILDER_COMPILE_FLAG_SINGLE_LANG: XbBuilderCompileFlags = 8;
pub const XB_BUILDER_COMPILE_FLAG_WATCH_BLOB: XbBuilderCompileFlags = 16;
pub const XB_BUILDER_COMPILE_FLAG_IGNORE_GUID: XbBuilderCompileFlags = 32;
pub const XB_BUILDER_COMPILE_FLAG_SINGLE_ROOT: XbBuilderCompileFlags = 64;

pub type XbBuilderNodeFlags = c_uint;
pub const XB_BUILDER_NODE_FLAG_NONE: XbBuilderNodeFlags = 0;
pub const XB_BUILDER_NODE_FLAG_IGNORE: XbBuilderNodeFlags = 1;
pub const XB_BUILDER_NODE_FLAG_LITERAL_TEXT: XbBuilderNodeFlags = 2;
pub const XB_BUILDER_NODE_FLAG_HAS_TEXT: XbBuilderNodeFlags = 4;
pub const XB_BUILDER_NODE_FLAG_HAS_TAIL: XbBuilderNodeFlags = 8;
pub const XB_BUILDER_NODE_FLAG_TOKENIZE_TEXT: XbBuilderNodeFlags = 16;
pub const XB_BUILDER_NODE_FLAG_STRIP_TEXT: XbBuilderNodeFlags = 32;

pub type XbBuilderSourceFlags = c_uint;
pub const XB_BUILDER_SOURCE_FLAG_NONE: XbBuilderSourceFlags = 0;
pub const XB_BUILDER_SOURCE_FLAG_LITERAL_TEXT: XbBuilderSourceFlags = 1;
pub const XB_BUILDER_SOURCE_FLAG_WATCH_FILE: XbBuilderSourceFlags = 2;
pub const XB_BUILDER_SOURCE_FLAG_WATCH_DIRECTORY: XbBuilderSourceFlags = 4;

pub type XbMachineDebugFlags = c_uint;
pub const XB_MACHINE_DEBUG_FLAG_NONE: XbMachineDebugFlags = 0;
pub const XB_MACHINE_DEBUG_FLAG_SHOW_STACK: XbMachineDebugFlags = 1;
pub const XB_MACHINE_DEBUG_FLAG_SHOW_PARSING: XbMachineDebugFlags = 2;
pub const XB_MACHINE_DEBUG_FLAG_SHOW_OPTIMIZER: XbMachineDebugFlags = 4;
pub const XB_MACHINE_DEBUG_FLAG_SHOW_SLOW_PATH: XbMachineDebugFlags = 8;

pub type XbMachineParseFlags = c_uint;
pub const XB_MACHINE_PARSE_FLAG_NONE: XbMachineParseFlags = 0;
pub const XB_MACHINE_PARSE_FLAG_OPTIMIZE: XbMachineParseFlags = 1;

pub type XbNodeExportFlags = c_uint;
pub const XB_NODE_EXPORT_FLAG_NONE: XbNodeExportFlags = 0;
pub const XB_NODE_EXPORT_FLAG_ADD_HEADER: XbNodeExportFlags = 1;
pub const XB_NODE_EXPORT_FLAG_FORMAT_MULTILINE: XbNodeExportFlags = 2;
pub const XB_NODE_EXPORT_FLAG_FORMAT_INDENT: XbNodeExportFlags = 4;
pub const XB_NODE_EXPORT_FLAG_INCLUDE_SIBLINGS: XbNodeExportFlags = 8;
pub const XB_NODE_EXPORT_FLAG_ONLY_CHILDREN: XbNodeExportFlags = 16;
pub const XB_NODE_EXPORT_FLAG_COLLAPSE_EMPTY: XbNodeExportFlags = 32;

pub type XbOpcodeFlags = c_uint;
pub const XB_OPCODE_FLAG_UNKNOWN: XbOpcodeFlags = 0;
pub const XB_OPCODE_FLAG_INTEGER: XbOpcodeFlags = 1;
pub const XB_OPCODE_FLAG_TEXT: XbOpcodeFlags = 2;
pub const XB_OPCODE_FLAG_FUNCTION: XbOpcodeFlags = 4;
pub const XB_OPCODE_FLAG_BOUND: XbOpcodeFlags = 8;
pub const XB_OPCODE_FLAG_BOOLEAN: XbOpcodeFlags = 16;
pub const XB_OPCODE_FLAG_TOKENIZED: XbOpcodeFlags = 32;

pub type XbQueryFlags = c_uint;
pub const XB_QUERY_FLAG_NONE: XbQueryFlags = 0;
pub const XB_QUERY_FLAG_OPTIMIZE: XbQueryFlags = 1;
pub const XB_QUERY_FLAG_USE_INDEXES: XbQueryFlags = 2;
pub const XB_QUERY_FLAG_REVERSE: XbQueryFlags = 4;
pub const XB_QUERY_FLAG_FORCE_NODE_CACHE: XbQueryFlags = 8;

pub type XbSiloLoadFlags = c_uint;
pub const XB_SILO_LOAD_FLAG_NONE: XbSiloLoadFlags = 0;
pub const XB_SILO_LOAD_FLAG_NO_MAGIC: XbSiloLoadFlags = 1;
pub const XB_SILO_LOAD_FLAG_WATCH_BLOB: XbSiloLoadFlags = 2;

pub type XbSiloProfileFlags = c_uint;
pub const XB_SILO_PROFILE_FLAG_NONE: XbSiloProfileFlags = 0;
pub const XB_SILO_PROFILE_FLAG_DEBUG: XbSiloProfileFlags = 1;
pub const XB_SILO_PROFILE_FLAG_APPEND: XbSiloProfileFlags = 2;
pub const XB_SILO_PROFILE_FLAG_XPATH: XbSiloProfileFlags = 4;
pub const XB_SILO_PROFILE_FLAG_OPTIMIZER: XbSiloProfileFlags = 8;

// Callbacks
pub type XbBuilderFixupFunc = Option<
    unsafe extern "C" fn(
        *mut XbBuilderFixup,
        *mut XbBuilderNode,
        gpointer,
        *mut *mut glib::GError,
    ) -> gboolean,
>;
pub type XbBuilderNodeSortFunc =
    Option<unsafe extern "C" fn(*mut XbBuilderNode, *mut XbBuilderNode, gpointer) -> c_int>;
pub type XbBuilderNodeTraverseFunc =
    Option<unsafe extern "C" fn(*mut XbBuilderNode, gpointer) -> gboolean>;
pub type XbBuilderSourceAdapterFunc = Option<
    unsafe extern "C" fn(
        *mut XbBuilderSource,
        *mut XbBuilderSourceCtx,
        gpointer,
        *mut gio::GCancellable,
        *mut *mut glib::GError,
    ) -> *mut gio::GInputStream,
>;
pub type XbBuilderSourceNodeFunc = Option<
    unsafe extern "C" fn(
        *mut XbBuilderSource,
        *mut XbBuilderNode,
        gpointer,
        *mut *mut glib::GError,
    ) -> gboolean,
>;
pub type XbMachineMethodFunc = Option<
    unsafe extern "C" fn(
        *mut XbMachine,
        *mut XbStack,
        *mut gboolean,
        gpointer,
        gpointer,
        *mut *mut glib::GError,
    ) -> gboolean,
>;
pub type XbMachineOpcodeFixupFunc = Option<
    unsafe extern "C" fn(
        *mut XbMachine,
        *mut XbStack,
        gpointer,
        *mut *mut glib::GError,
    ) -> gboolean,
>;
pub type XbMachineTextHandlerFunc = Option<
    unsafe extern "C" fn(
        *mut XbMachine,
        *mut XbStack,
        *const c_char,
        *mut gboolean,
        gpointer,
        *mut *mut glib::GError,
    ) -> gboolean,
>;
pub type XbNodeTransmogrifyFunc = Option<unsafe extern "C" fn(*mut XbNode, gpointer) -> gboolean>;

// Records
#[derive(Copy, Clone)]
#[repr(C)]
pub struct XbBuilderClass {
    pub parent_class: gobject::GObjectClass,
    pub _xb_reserved1: Option<unsafe extern "C" fn()>,
    pub _xb_reserved2: Option<unsafe extern "C" fn()>,
    pub _xb_reserved3: Option<unsafe extern "C" fn()>,
    pub _xb_reserved4: Option<unsafe extern "C" fn()>,
    pub _xb_reserved5: Option<unsafe extern "C" fn()>,
    pub _xb_reserved6: Option<unsafe extern "C" fn()>,
    pub _xb_reserved7: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for XbBuilderClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("XbBuilderClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_xb_reserved1", &self._xb_reserved1)
            .field("_xb_reserved2", &self._xb_reserved2)
            .field("_xb_reserved3", &self._xb_reserved3)
            .field("_xb_reserved4", &self._xb_reserved4)
            .field("_xb_reserved5", &self._xb_reserved5)
            .field("_xb_reserved6", &self._xb_reserved6)
            .field("_xb_reserved7", &self._xb_reserved7)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct XbBuilderFixupClass {
    pub parent_class: gobject::GObjectClass,
    pub _xb_reserved1: Option<unsafe extern "C" fn()>,
    pub _xb_reserved2: Option<unsafe extern "C" fn()>,
    pub _xb_reserved3: Option<unsafe extern "C" fn()>,
    pub _xb_reserved4: Option<unsafe extern "C" fn()>,
    pub _xb_reserved5: Option<unsafe extern "C" fn()>,
    pub _xb_reserved6: Option<unsafe extern "C" fn()>,
    pub _xb_reserved7: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for XbBuilderFixupClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("XbBuilderFixupClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_xb_reserved1", &self._xb_reserved1)
            .field("_xb_reserved2", &self._xb_reserved2)
            .field("_xb_reserved3", &self._xb_reserved3)
            .field("_xb_reserved4", &self._xb_reserved4)
            .field("_xb_reserved5", &self._xb_reserved5)
            .field("_xb_reserved6", &self._xb_reserved6)
            .field("_xb_reserved7", &self._xb_reserved7)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct XbBuilderNodeClass {
    pub parent_class: gobject::GObjectClass,
    pub _xb_reserved1: Option<unsafe extern "C" fn()>,
    pub _xb_reserved2: Option<unsafe extern "C" fn()>,
    pub _xb_reserved3: Option<unsafe extern "C" fn()>,
    pub _xb_reserved4: Option<unsafe extern "C" fn()>,
    pub _xb_reserved5: Option<unsafe extern "C" fn()>,
    pub _xb_reserved6: Option<unsafe extern "C" fn()>,
    pub _xb_reserved7: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for XbBuilderNodeClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("XbBuilderNodeClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_xb_reserved1", &self._xb_reserved1)
            .field("_xb_reserved2", &self._xb_reserved2)
            .field("_xb_reserved3", &self._xb_reserved3)
            .field("_xb_reserved4", &self._xb_reserved4)
            .field("_xb_reserved5", &self._xb_reserved5)
            .field("_xb_reserved6", &self._xb_reserved6)
            .field("_xb_reserved7", &self._xb_reserved7)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct XbBuilderSourceClass {
    pub parent_class: gobject::GObjectClass,
    pub _xb_reserved1: Option<unsafe extern "C" fn()>,
    pub _xb_reserved2: Option<unsafe extern "C" fn()>,
    pub _xb_reserved3: Option<unsafe extern "C" fn()>,
    pub _xb_reserved4: Option<unsafe extern "C" fn()>,
    pub _xb_reserved5: Option<unsafe extern "C" fn()>,
    pub _xb_reserved6: Option<unsafe extern "C" fn()>,
    pub _xb_reserved7: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for XbBuilderSourceClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("XbBuilderSourceClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_xb_reserved1", &self._xb_reserved1)
            .field("_xb_reserved2", &self._xb_reserved2)
            .field("_xb_reserved3", &self._xb_reserved3)
            .field("_xb_reserved4", &self._xb_reserved4)
            .field("_xb_reserved5", &self._xb_reserved5)
            .field("_xb_reserved6", &self._xb_reserved6)
            .field("_xb_reserved7", &self._xb_reserved7)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct XbBuilderSourceCtxClass {
    pub parent_class: gobject::GObjectClass,
    pub _xb_reserved1: Option<unsafe extern "C" fn()>,
    pub _xb_reserved2: Option<unsafe extern "C" fn()>,
    pub _xb_reserved3: Option<unsafe extern "C" fn()>,
    pub _xb_reserved4: Option<unsafe extern "C" fn()>,
    pub _xb_reserved5: Option<unsafe extern "C" fn()>,
    pub _xb_reserved6: Option<unsafe extern "C" fn()>,
    pub _xb_reserved7: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for XbBuilderSourceCtxClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("XbBuilderSourceCtxClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_xb_reserved1", &self._xb_reserved1)
            .field("_xb_reserved2", &self._xb_reserved2)
            .field("_xb_reserved3", &self._xb_reserved3)
            .field("_xb_reserved4", &self._xb_reserved4)
            .field("_xb_reserved5", &self._xb_reserved5)
            .field("_xb_reserved6", &self._xb_reserved6)
            .field("_xb_reserved7", &self._xb_reserved7)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct XbMachineClass {
    pub parent_class: gobject::GObjectClass,
    pub _xb_reserved1: Option<unsafe extern "C" fn()>,
    pub _xb_reserved2: Option<unsafe extern "C" fn()>,
    pub _xb_reserved3: Option<unsafe extern "C" fn()>,
    pub _xb_reserved4: Option<unsafe extern "C" fn()>,
    pub _xb_reserved5: Option<unsafe extern "C" fn()>,
    pub _xb_reserved6: Option<unsafe extern "C" fn()>,
    pub _xb_reserved7: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for XbMachineClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("XbMachineClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_xb_reserved1", &self._xb_reserved1)
            .field("_xb_reserved2", &self._xb_reserved2)
            .field("_xb_reserved3", &self._xb_reserved3)
            .field("_xb_reserved4", &self._xb_reserved4)
            .field("_xb_reserved5", &self._xb_reserved5)
            .field("_xb_reserved6", &self._xb_reserved6)
            .field("_xb_reserved7", &self._xb_reserved7)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct XbNodeAttrIter {
    pub dummy1: gpointer,
    pub dummy2: u8,
    pub dummy3: gpointer,
    pub dummy4: gpointer,
    pub dummy5: gpointer,
    pub dummy6: gpointer,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct XbNodeChildIter {
    pub dummy1: gpointer,
    pub dummy2: gpointer,
    pub dummy3: gboolean,
    pub dummy4: gpointer,
    pub dummy5: gpointer,
    pub dummy6: gpointer,
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct XbNodeClass {
    pub parent_class: gobject::GObjectClass,
    pub _xb_reserved1: Option<unsafe extern "C" fn()>,
    pub _xb_reserved2: Option<unsafe extern "C" fn()>,
    pub _xb_reserved3: Option<unsafe extern "C" fn()>,
    pub _xb_reserved4: Option<unsafe extern "C" fn()>,
    pub _xb_reserved5: Option<unsafe extern "C" fn()>,
    pub _xb_reserved6: Option<unsafe extern "C" fn()>,
    pub _xb_reserved7: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for XbNodeClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("XbNodeClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_xb_reserved1", &self._xb_reserved1)
            .field("_xb_reserved2", &self._xb_reserved2)
            .field("_xb_reserved3", &self._xb_reserved3)
            .field("_xb_reserved4", &self._xb_reserved4)
            .field("_xb_reserved5", &self._xb_reserved5)
            .field("_xb_reserved6", &self._xb_reserved6)
            .field("_xb_reserved7", &self._xb_reserved7)
            .finish()
    }
}

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

pub type XbOpcode = _XbOpcode;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct XbQueryClass {
    pub parent_class: gobject::GObjectClass,
    pub _xb_reserved1: Option<unsafe extern "C" fn()>,
    pub _xb_reserved2: Option<unsafe extern "C" fn()>,
    pub _xb_reserved3: Option<unsafe extern "C" fn()>,
    pub _xb_reserved4: Option<unsafe extern "C" fn()>,
    pub _xb_reserved5: Option<unsafe extern "C" fn()>,
    pub _xb_reserved6: Option<unsafe extern "C" fn()>,
    pub _xb_reserved7: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for XbQueryClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("XbQueryClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_xb_reserved1", &self._xb_reserved1)
            .field("_xb_reserved2", &self._xb_reserved2)
            .field("_xb_reserved3", &self._xb_reserved3)
            .field("_xb_reserved4", &self._xb_reserved4)
            .field("_xb_reserved5", &self._xb_reserved5)
            .field("_xb_reserved6", &self._xb_reserved6)
            .field("_xb_reserved7", &self._xb_reserved7)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct XbQueryContext {
    pub dummy0: c_int,
    pub dummy1: c_uint,
    pub dummy2: XbValueBindings,
    pub dummy3: [gpointer; 5],
}

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct XbSiloClass {
    pub parent_class: gobject::GObjectClass,
    pub _xb_reserved1: Option<unsafe extern "C" fn()>,
    pub _xb_reserved2: Option<unsafe extern "C" fn()>,
    pub _xb_reserved3: Option<unsafe extern "C" fn()>,
    pub _xb_reserved4: Option<unsafe extern "C" fn()>,
    pub _xb_reserved5: Option<unsafe extern "C" fn()>,
    pub _xb_reserved6: Option<unsafe extern "C" fn()>,
    pub _xb_reserved7: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for XbSiloClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("XbSiloClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_xb_reserved1", &self._xb_reserved1)
            .field("_xb_reserved2", &self._xb_reserved2)
            .field("_xb_reserved3", &self._xb_reserved3)
            .field("_xb_reserved4", &self._xb_reserved4)
            .field("_xb_reserved5", &self._xb_reserved5)
            .field("_xb_reserved6", &self._xb_reserved6)
            .field("_xb_reserved7", &self._xb_reserved7)
            .finish()
    }
}

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

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

#[derive(Copy, Clone)]
#[repr(C)]
pub struct XbValueBindings {
    pub dummy0: u8,
    pub dummy1: u32,
    pub dummy2: [gpointer; 2],
    pub dummy3: u8,
    pub dummy4: u32,
    pub dummy5: [gpointer; 2],
    pub dummy6: u8,
    pub dummy7: u32,
    pub dummy8: [gpointer; 2],
    pub dummy9: u8,
    pub dummy10: u32,
    pub dummy11: [gpointer; 2],
    pub dummy12: [gpointer; 3],
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[link(name = "xmlb")]
extern "C" {

    //=========================================================================
    // XbNodeAttrIter
    //=========================================================================
    pub fn xb_node_attr_iter_init(iter: *mut XbNodeAttrIter, self_: *mut XbNode);
    pub fn xb_node_attr_iter_next(
        iter: *mut XbNodeAttrIter,
        name: *mut *const c_char,
        value: *mut *const c_char,
    ) -> gboolean;

    //=========================================================================
    // XbNodeChildIter
    //=========================================================================
    pub fn xb_node_child_iter_init(iter: *mut XbNodeChildIter, self_: *mut XbNode);
    pub fn xb_node_child_iter_loop(iter: *mut XbNodeChildIter, child: *mut *mut XbNode)
        -> gboolean;
    pub fn xb_node_child_iter_next(iter: *mut XbNodeChildIter, child: *mut *mut XbNode)
        -> gboolean;

    //=========================================================================
    // XbOpcode
    //=========================================================================
    pub fn xb_opcode_cmp_str(self_: *mut XbOpcode) -> gboolean;
    pub fn xb_opcode_cmp_val(self_: *mut XbOpcode) -> gboolean;
    pub fn xb_opcode_func_init(self_: *mut XbOpcode, func: u32);
    pub fn xb_opcode_get_kind(self_: *mut XbOpcode) -> XbOpcodeKind;
    pub fn xb_opcode_get_str(self_: *mut XbOpcode) -> *const c_char;
    pub fn xb_opcode_get_val(self_: *mut XbOpcode) -> u32;
    pub fn xb_opcode_integer_init(self_: *mut XbOpcode, val: u32);
    pub fn xb_opcode_text_init(self_: *mut XbOpcode, str: *const c_char);
    pub fn xb_opcode_text_init_static(self_: *mut XbOpcode, str: *const c_char);
    pub fn xb_opcode_text_init_steal(self_: *mut XbOpcode, str: *mut c_char);
    pub fn xb_opcode_to_string(self_: *mut XbOpcode) -> *mut c_char;
    pub fn xb_opcode_kind_from_string(str: *const c_char) -> XbOpcodeKind;
    pub fn xb_opcode_kind_to_string(kind: XbOpcodeKind) -> *const c_char;

    //=========================================================================
    // XbQueryContext
    //=========================================================================
    pub fn xb_query_context_get_type() -> GType;
    pub fn xb_query_context_clear(self_: *mut XbQueryContext);
    pub fn xb_query_context_copy(self_: *mut XbQueryContext) -> *mut XbQueryContext;
    pub fn xb_query_context_free(self_: *mut XbQueryContext);
    pub fn xb_query_context_get_bindings(self_: *mut XbQueryContext) -> *mut XbValueBindings;
    pub fn xb_query_context_get_flags(self_: *mut XbQueryContext) -> XbQueryFlags;
    pub fn xb_query_context_get_limit(self_: *mut XbQueryContext) -> c_uint;
    pub fn xb_query_context_init(self_: *mut XbQueryContext);
    pub fn xb_query_context_set_flags(self_: *mut XbQueryContext, flags: XbQueryFlags);
    pub fn xb_query_context_set_limit(self_: *mut XbQueryContext, limit: c_uint);

    //=========================================================================
    // XbStack
    //=========================================================================
    pub fn xb_stack_get_type() -> GType;
    pub fn xb_stack_pop(
        self_: *mut XbStack,
        opcode_out: *mut XbOpcode,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_stack_push(
        self_: *mut XbStack,
        opcode_out: *mut *mut XbOpcode,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_stack_to_string(self_: *mut XbStack) -> *mut c_char;

    //=========================================================================
    // XbValueBindings
    //=========================================================================
    pub fn xb_value_bindings_get_type() -> GType;
    pub fn xb_value_bindings_bind_str(
        self_: *mut XbValueBindings,
        idx: c_uint,
        str: *const c_char,
        destroy_func: glib::GDestroyNotify,
    );
    pub fn xb_value_bindings_bind_val(self_: *mut XbValueBindings, idx: c_uint, val: u32);
    pub fn xb_value_bindings_clear(self_: *mut XbValueBindings);
    pub fn xb_value_bindings_copy(self_: *mut XbValueBindings) -> *mut XbValueBindings;
    pub fn xb_value_bindings_copy_binding(
        self_: *mut XbValueBindings,
        idx: c_uint,
        dest: *mut XbValueBindings,
        dest_idx: c_uint,
    ) -> gboolean;
    pub fn xb_value_bindings_free(self_: *mut XbValueBindings);
    pub fn xb_value_bindings_init(self_: *mut XbValueBindings);
    pub fn xb_value_bindings_is_bound(self_: *mut XbValueBindings, idx: c_uint) -> gboolean;
    pub fn xb_value_bindings_lookup_opcode(
        self_: *mut XbValueBindings,
        idx: c_uint,
        opcode_out: *mut XbOpcode,
    ) -> gboolean;

    //=========================================================================
    // XbBuilder
    //=========================================================================
    pub fn xb_builder_get_type() -> GType;
    pub fn xb_builder_new() -> *mut XbBuilder;
    pub fn xb_builder_add_fixup(self_: *mut XbBuilder, fixup: *mut XbBuilderFixup);
    pub fn xb_builder_add_locale(self_: *mut XbBuilder, locale: *const c_char);
    pub fn xb_builder_append_guid(self_: *mut XbBuilder, guid: *const c_char);
    pub fn xb_builder_compile(
        self_: *mut XbBuilder,
        flags: XbBuilderCompileFlags,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> *mut XbSilo;
    pub fn xb_builder_ensure(
        self_: *mut XbBuilder,
        file: *mut gio::GFile,
        flags: XbBuilderCompileFlags,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> *mut XbSilo;
    pub fn xb_builder_import_node(self_: *mut XbBuilder, bn: *mut XbBuilderNode);
    pub fn xb_builder_import_source(self_: *mut XbBuilder, source: *mut XbBuilderSource);
    pub fn xb_builder_set_profile_flags(self_: *mut XbBuilder, profile_flags: XbSiloProfileFlags);

    //=========================================================================
    // XbBuilderFixup
    //=========================================================================
    pub fn xb_builder_fixup_get_type() -> GType;
    pub fn xb_builder_fixup_new(
        id: *const c_char,
        func: XbBuilderFixupFunc,
        user_data: gpointer,
        user_data_free: glib::GDestroyNotify,
    ) -> *mut XbBuilderFixup;
    pub fn xb_builder_fixup_get_max_depth(self_: *mut XbBuilderFixup) -> c_int;
    pub fn xb_builder_fixup_set_max_depth(self_: *mut XbBuilderFixup, max_depth: c_int);

    //=========================================================================
    // XbBuilderNode
    //=========================================================================
    pub fn xb_builder_node_get_type() -> GType;
    pub fn xb_builder_node_new(element: *const c_char) -> *mut XbBuilderNode;
    pub fn xb_builder_node_add_child(self_: *mut XbBuilderNode, child: *mut XbBuilderNode);
    pub fn xb_builder_node_add_flag(self_: *mut XbBuilderNode, flag: XbBuilderNodeFlags);
    pub fn xb_builder_node_add_token(self_: *mut XbBuilderNode, token: *const c_char);
    pub fn xb_builder_node_depth(self_: *mut XbBuilderNode) -> c_uint;
    pub fn xb_builder_node_export(
        self_: *mut XbBuilderNode,
        flags: XbNodeExportFlags,
        error: *mut *mut glib::GError,
    ) -> *mut c_char;
    pub fn xb_builder_node_get_attr(
        self_: *mut XbBuilderNode,
        name: *const c_char,
    ) -> *const c_char;
    pub fn xb_builder_node_get_attr_as_uint(self_: *mut XbBuilderNode, name: *const c_char) -> u64;
    pub fn xb_builder_node_get_child(
        self_: *mut XbBuilderNode,
        element: *const c_char,
        text: *const c_char,
    ) -> *mut XbBuilderNode;
    pub fn xb_builder_node_get_children(self_: *mut XbBuilderNode) -> *mut glib::GPtrArray;
    pub fn xb_builder_node_get_element(self_: *mut XbBuilderNode) -> *const c_char;
    pub fn xb_builder_node_get_first_child(self_: *mut XbBuilderNode) -> *mut XbBuilderNode;
    pub fn xb_builder_node_get_last_child(self_: *mut XbBuilderNode) -> *mut XbBuilderNode;
    pub fn xb_builder_node_get_parent(self_: *mut XbBuilderNode) -> *mut XbBuilderNode;
    pub fn xb_builder_node_get_tail(self_: *mut XbBuilderNode) -> *const c_char;
    pub fn xb_builder_node_get_text(self_: *mut XbBuilderNode) -> *const c_char;
    pub fn xb_builder_node_get_text_as_uint(self_: *mut XbBuilderNode) -> u64;
    pub fn xb_builder_node_get_tokens(self_: *mut XbBuilderNode) -> *mut glib::GPtrArray;
    pub fn xb_builder_node_has_flag(
        self_: *mut XbBuilderNode,
        flag: XbBuilderNodeFlags,
    ) -> gboolean;
    pub fn xb_builder_node_insert(
        parent: *mut XbBuilderNode,
        element: *const c_char,
        ...
    ) -> *mut XbBuilderNode;
    pub fn xb_builder_node_insert_text(
        parent: *mut XbBuilderNode,
        element: *const c_char,
        text: *const c_char,
        ...
    );
    pub fn xb_builder_node_remove_attr(self_: *mut XbBuilderNode, name: *const c_char);
    pub fn xb_builder_node_remove_child(self_: *mut XbBuilderNode, child: *mut XbBuilderNode);
    pub fn xb_builder_node_set_attr(
        self_: *mut XbBuilderNode,
        name: *const c_char,
        value: *const c_char,
    );
    pub fn xb_builder_node_set_element(self_: *mut XbBuilderNode, element: *const c_char);
    pub fn xb_builder_node_set_tail(
        self_: *mut XbBuilderNode,
        tail: *const c_char,
        tail_len: ssize_t,
    );
    pub fn xb_builder_node_set_text(
        self_: *mut XbBuilderNode,
        text: *const c_char,
        text_len: ssize_t,
    );
    pub fn xb_builder_node_sort_children(
        self_: *mut XbBuilderNode,
        func: XbBuilderNodeSortFunc,
        user_data: gpointer,
    );
    pub fn xb_builder_node_tokenize_text(self_: *mut XbBuilderNode);
    pub fn xb_builder_node_traverse(
        self_: *mut XbBuilderNode,
        order: glib::GTraverseType,
        flags: glib::GTraverseFlags,
        max_depth: c_int,
        func: XbBuilderNodeTraverseFunc,
        user_data: gpointer,
    );
    pub fn xb_builder_node_unlink(self_: *mut XbBuilderNode);

    //=========================================================================
    // XbBuilderSource
    //=========================================================================
    pub fn xb_builder_source_get_type() -> GType;
    pub fn xb_builder_source_new() -> *mut XbBuilderSource;
    pub fn xb_builder_source_add_adapter(
        self_: *mut XbBuilderSource,
        content_types: *const c_char,
        func: XbBuilderSourceAdapterFunc,
        user_data: gpointer,
        user_data_free: glib::GDestroyNotify,
    );
    pub fn xb_builder_source_add_fixup(self_: *mut XbBuilderSource, fixup: *mut XbBuilderFixup);
    pub fn xb_builder_source_add_simple_adapter(
        self_: *mut XbBuilderSource,
        content_types: *const c_char,
        func: XbBuilderSourceAdapterFunc,
        user_data: gpointer,
        user_data_free: glib::GDestroyNotify,
    );
    pub fn xb_builder_source_load_bytes(
        self_: *mut XbBuilderSource,
        bytes: *mut glib::GBytes,
        flags: XbBuilderSourceFlags,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_builder_source_load_file(
        self_: *mut XbBuilderSource,
        file: *mut gio::GFile,
        flags: XbBuilderSourceFlags,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_builder_source_load_xml(
        self_: *mut XbBuilderSource,
        xml: *const c_char,
        flags: XbBuilderSourceFlags,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_builder_source_set_info(self_: *mut XbBuilderSource, info: *mut XbBuilderNode);
    pub fn xb_builder_source_set_prefix(self_: *mut XbBuilderSource, prefix: *const c_char);

    //=========================================================================
    // XbBuilderSourceCtx
    //=========================================================================
    pub fn xb_builder_source_ctx_get_type() -> GType;
    pub fn xb_builder_source_ctx_get_bytes(
        self_: *mut XbBuilderSourceCtx,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> *mut glib::GBytes;
    pub fn xb_builder_source_ctx_get_filename(self_: *mut XbBuilderSourceCtx) -> *const c_char;
    pub fn xb_builder_source_ctx_get_stream(
        self_: *mut XbBuilderSourceCtx,
    ) -> *mut gio::GInputStream;

    //=========================================================================
    // XbMachine
    //=========================================================================
    pub fn xb_machine_get_type() -> GType;
    pub fn xb_machine_new() -> *mut XbMachine;
    pub fn xb_machine_add_method(
        self_: *mut XbMachine,
        name: *const c_char,
        n_opcodes: c_uint,
        method_cb: XbMachineMethodFunc,
        user_data: gpointer,
        user_data_free: glib::GDestroyNotify,
    );
    pub fn xb_machine_add_opcode_fixup(
        self_: *mut XbMachine,
        opcodes_sig: *const c_char,
        fixup_cb: XbMachineOpcodeFixupFunc,
        user_data: gpointer,
        user_data_free: glib::GDestroyNotify,
    );
    pub fn xb_machine_add_operator(self_: *mut XbMachine, str: *const c_char, name: *const c_char);
    pub fn xb_machine_add_text_handler(
        self_: *mut XbMachine,
        handler_cb: XbMachineTextHandlerFunc,
        user_data: gpointer,
        user_data_free: glib::GDestroyNotify,
    );
    pub fn xb_machine_get_stack_size(self_: *mut XbMachine) -> c_uint;
    pub fn xb_machine_opcode_func_init(
        self_: *mut XbMachine,
        opcode: *mut XbOpcode,
        func_name: *const c_char,
    ) -> gboolean;
    pub fn xb_machine_parse(
        self_: *mut XbMachine,
        text: *const c_char,
        text_len: ssize_t,
        error: *mut *mut glib::GError,
    ) -> *mut XbStack;
    pub fn xb_machine_parse_full(
        self_: *mut XbMachine,
        text: *const c_char,
        text_len: ssize_t,
        flags: XbMachineParseFlags,
        error: *mut *mut glib::GError,
    ) -> *mut XbStack;
    pub fn xb_machine_run(
        self_: *mut XbMachine,
        opcodes: *mut XbStack,
        result: *mut gboolean,
        exec_data: gpointer,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_machine_run_with_bindings(
        self_: *mut XbMachine,
        opcodes: *mut XbStack,
        bindings: *mut XbValueBindings,
        result: *mut gboolean,
        exec_data: gpointer,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_machine_set_debug_flags(self_: *mut XbMachine, flags: XbMachineDebugFlags);
    pub fn xb_machine_set_stack_size(self_: *mut XbMachine, stack_size: c_uint);
    pub fn xb_machine_stack_pop(
        self_: *mut XbMachine,
        stack: *mut XbStack,
        opcode_out: *mut XbOpcode,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_machine_stack_push(
        self_: *mut XbMachine,
        stack: *mut XbStack,
        opcode_out: *mut *mut XbOpcode,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_machine_stack_push_integer(
        self_: *mut XbMachine,
        stack: *mut XbStack,
        val: u32,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_machine_stack_push_text(
        self_: *mut XbMachine,
        stack: *mut XbStack,
        str: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_machine_stack_push_text_static(
        self_: *mut XbMachine,
        stack: *mut XbStack,
        str: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_machine_stack_push_text_steal(
        self_: *mut XbMachine,
        stack: *mut XbStack,
        str: *mut c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // XbNode
    //=========================================================================
    pub fn xb_node_get_type() -> GType;
    pub fn xb_node_export(
        self_: *mut XbNode,
        flags: XbNodeExportFlags,
        error: *mut *mut glib::GError,
    ) -> *mut c_char;
    pub fn xb_node_get_attr(self_: *mut XbNode, name: *const c_char) -> *const c_char;
    pub fn xb_node_get_attr_as_uint(self_: *mut XbNode, name: *const c_char) -> u64;
    pub fn xb_node_get_child(self_: *mut XbNode) -> *mut XbNode;
    pub fn xb_node_get_children(self_: *mut XbNode) -> *mut glib::GPtrArray;
    pub fn xb_node_get_data(self_: *mut XbNode, key: *const c_char) -> *mut glib::GBytes;
    pub fn xb_node_get_depth(self_: *mut XbNode) -> c_uint;
    pub fn xb_node_get_element(self_: *mut XbNode) -> *const c_char;
    pub fn xb_node_get_next(self_: *mut XbNode) -> *mut XbNode;
    pub fn xb_node_get_parent(self_: *mut XbNode) -> *mut XbNode;
    pub fn xb_node_get_root(self_: *mut XbNode) -> *mut XbNode;
    pub fn xb_node_get_silo(self_: *mut XbNode) -> *mut XbSilo;
    pub fn xb_node_get_tail(self_: *mut XbNode) -> *const c_char;
    pub fn xb_node_get_text(self_: *mut XbNode) -> *const c_char;
    pub fn xb_node_get_text_as_uint(self_: *mut XbNode) -> u64;
    pub fn xb_node_query(
        self_: *mut XbNode,
        xpath: *const c_char,
        limit: c_uint,
        error: *mut *mut glib::GError,
    ) -> *mut glib::GPtrArray;
    pub fn xb_node_query_attr(
        self_: *mut XbNode,
        xpath: *const c_char,
        name: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *const c_char;
    pub fn xb_node_query_attr_as_uint(
        self_: *mut XbNode,
        xpath: *const c_char,
        name: *const c_char,
        error: *mut *mut glib::GError,
    ) -> u64;
    pub fn xb_node_query_export(
        self_: *mut XbNode,
        xpath: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut c_char;
    pub fn xb_node_query_first(
        self_: *mut XbNode,
        xpath: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut XbNode;
    pub fn xb_node_query_first_full(
        self_: *mut XbNode,
        query: *mut XbQuery,
        error: *mut *mut glib::GError,
    ) -> *mut XbNode;
    pub fn xb_node_query_first_with_context(
        self_: *mut XbNode,
        query: *mut XbQuery,
        context: *mut XbQueryContext,
        error: *mut *mut glib::GError,
    ) -> *mut XbNode;
    pub fn xb_node_query_full(
        self_: *mut XbNode,
        query: *mut XbQuery,
        error: *mut *mut glib::GError,
    ) -> *mut glib::GPtrArray;
    pub fn xb_node_query_text(
        self_: *mut XbNode,
        xpath: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *const c_char;
    pub fn xb_node_query_text_as_uint(
        self_: *mut XbNode,
        xpath: *const c_char,
        error: *mut *mut glib::GError,
    ) -> u64;
    pub fn xb_node_query_with_context(
        self_: *mut XbNode,
        query: *mut XbQuery,
        context: *mut XbQueryContext,
        error: *mut *mut glib::GError,
    ) -> *mut glib::GPtrArray;
    pub fn xb_node_set_data(self_: *mut XbNode, key: *const c_char, data: *mut glib::GBytes);
    pub fn xb_node_transmogrify(
        self_: *mut XbNode,
        func_text: XbNodeTransmogrifyFunc,
        func_tail: XbNodeTransmogrifyFunc,
        user_data: gpointer,
    ) -> gboolean;

    //=========================================================================
    // XbQuery
    //=========================================================================
    pub fn xb_query_get_type() -> GType;
    pub fn xb_query_new(
        silo: *mut XbSilo,
        xpath: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut XbQuery;
    pub fn xb_query_new_full(
        silo: *mut XbSilo,
        xpath: *const c_char,
        flags: XbQueryFlags,
        error: *mut *mut glib::GError,
    ) -> *mut XbQuery;
    pub fn xb_query_bind_str(
        self_: *mut XbQuery,
        idx: c_uint,
        str: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_query_bind_val(
        self_: *mut XbQuery,
        idx: c_uint,
        val: u32,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_query_get_flags(self_: *mut XbQuery) -> XbQueryFlags;
    pub fn xb_query_get_limit(self_: *mut XbQuery) -> c_uint;
    pub fn xb_query_get_xpath(self_: *mut XbQuery) -> *const c_char;
    pub fn xb_query_set_flags(self_: *mut XbQuery, flags: XbQueryFlags);
    pub fn xb_query_set_limit(self_: *mut XbQuery, limit: c_uint);

    //=========================================================================
    // XbSilo
    //=========================================================================
    pub fn xb_silo_get_type() -> GType;
    pub fn xb_silo_new() -> *mut XbSilo;
    pub fn xb_silo_new_from_xml(xml: *const c_char, error: *mut *mut glib::GError) -> *mut XbSilo;
    pub fn xb_silo_export(
        self_: *mut XbSilo,
        flags: XbNodeExportFlags,
        error: *mut *mut glib::GError,
    ) -> *mut c_char;
    pub fn xb_silo_export_file(
        self_: *mut XbSilo,
        file: *mut gio::GFile,
        flags: XbNodeExportFlags,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_silo_get_bytes(self_: *mut XbSilo) -> *mut glib::GBytes;
    pub fn xb_silo_get_enable_node_cache(self_: *mut XbSilo) -> gboolean;
    pub fn xb_silo_get_guid(self_: *mut XbSilo) -> *const c_char;
    pub fn xb_silo_get_profile_string(self_: *mut XbSilo) -> *const c_char;
    pub fn xb_silo_get_root(self_: *mut XbSilo) -> *mut XbNode;
    pub fn xb_silo_get_size(self_: *mut XbSilo) -> c_uint;
    pub fn xb_silo_invalidate(self_: *mut XbSilo);
    pub fn xb_silo_is_valid(self_: *mut XbSilo) -> gboolean;
    pub fn xb_silo_load_from_bytes(
        self_: *mut XbSilo,
        blob: *mut glib::GBytes,
        flags: XbSiloLoadFlags,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_silo_load_from_file(
        self_: *mut XbSilo,
        file: *mut gio::GFile,
        flags: XbSiloLoadFlags,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_silo_lookup_query(self_: *mut XbSilo, xpath: *const c_char) -> *mut XbQuery;
    pub fn xb_silo_query(
        self_: *mut XbSilo,
        xpath: *const c_char,
        limit: c_uint,
        error: *mut *mut glib::GError,
    ) -> *mut glib::GPtrArray;
    pub fn xb_silo_query_build_index(
        self_: *mut XbSilo,
        xpath: *const c_char,
        attr: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_silo_query_first(
        self_: *mut XbSilo,
        xpath: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut XbNode;
    pub fn xb_silo_query_first_full(
        self_: *mut XbSilo,
        query: *mut XbQuery,
        error: *mut *mut glib::GError,
    ) -> *mut XbNode;
    pub fn xb_silo_query_first_with_context(
        self_: *mut XbSilo,
        query: *mut XbQuery,
        context: *mut XbQueryContext,
        error: *mut *mut glib::GError,
    ) -> *mut XbNode;
    pub fn xb_silo_query_full(
        self_: *mut XbSilo,
        query: *mut XbQuery,
        error: *mut *mut glib::GError,
    ) -> *mut glib::GPtrArray;
    pub fn xb_silo_query_with_context(
        self_: *mut XbSilo,
        query: *mut XbQuery,
        context: *mut XbQueryContext,
        error: *mut *mut glib::GError,
    ) -> *mut glib::GPtrArray;
    pub fn xb_silo_save_to_file(
        self_: *mut XbSilo,
        file: *mut gio::GFile,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn xb_silo_set_enable_node_cache(self_: *mut XbSilo, enable_node_cache: gboolean);
    pub fn xb_silo_set_profile_flags(self_: *mut XbSilo, profile_flags: XbSiloProfileFlags);
    pub fn xb_silo_to_string(self_: *mut XbSilo, error: *mut *mut glib::GError) -> *mut c_char;
    pub fn xb_silo_watch_file(
        self_: *mut XbSilo,
        file: *mut gio::GFile,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn xb_string_append_union(xpath: *mut glib::GString, fmt: *const c_char, ...);
    pub fn xb_string_escape(str: *const c_char) -> *mut c_char;
    pub fn xb_version_string() -> *const c_char;

}