/* automatically generated by rust-bindgen 0.60.1 */

pub type __int64_t = ::std::os::raw::c_long;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __off_t = ::std::os::raw::c_long;
pub type mode_t = __mode_t;
pub type off_t = __off_t;
pub type va_list = __builtin_va_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct archive {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct archive_entry {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __alpm_list_t {
    pub data: *mut ::std::os::raw::c_void,
    pub prev: *mut __alpm_list_t,
    pub next: *mut __alpm_list_t,
}
#[test]
fn bindgen_test_layout___alpm_list_t() {
    assert_eq!(
        ::std::mem::size_of::<__alpm_list_t>(),
        24usize,
        concat!("Size of: ", stringify!(__alpm_list_t))
    );
    assert_eq!(
        ::std::mem::align_of::<__alpm_list_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__alpm_list_t))
    );
    fn test_field_data() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<__alpm_list_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(__alpm_list_t),
                "::",
                stringify!(data)
            )
        );
    }
    test_field_data();
    fn test_field_prev() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<__alpm_list_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(__alpm_list_t),
                "::",
                stringify!(prev)
            )
        );
    }
    test_field_prev();
    fn test_field_next() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<__alpm_list_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(__alpm_list_t),
                "::",
                stringify!(next)
            )
        );
    }
    test_field_next();
}
pub type alpm_list_t = __alpm_list_t;
pub type alpm_list_fn_free =
    ::std::option::Option<unsafe extern "C" fn(item: *mut ::std::os::raw::c_void)>;
pub type alpm_list_fn_cmp = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *const ::std::os::raw::c_void,
        arg2: *const ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
#[doc = " The libalpm context handle."]
#[doc = ""]
#[doc = " This struct represents an instance of libalpm."]
#[doc = " @ingroup libalpm_handle"]
pub type alpm_handle_t = u8;
#[doc = " A database."]
#[doc = ""]
#[doc = " A database is a container that stores metadata about packages."]
#[doc = ""]
#[doc = " A database can be located on the local filesystem or on a remote server."]
#[doc = ""]
#[doc = " To use a database, it must first be registered via \\link alpm_register_syncdb \\endlink."]
#[doc = " If the database is already present in dbpath then it will be usable. Otherwise,"]
#[doc = " the database needs to be downloaded using \\link alpm_db_update \\endlink. Even if the"]
#[doc = " source of the database is the local filesystem."]
#[doc = ""]
#[doc = " After this, the database can be used to query packages and groups. Any packages or groups"]
#[doc = " from the database will continue to be owned by the database and do not need to be freed by"]
#[doc = " the user. They will be freed when the database is unregistered."]
#[doc = ""]
#[doc = " Databases are automatically unregistered when the \\link alpm_handle_t \\endlink is released."]
#[doc = " @ingroup libalpm_databases"]
pub type alpm_db_t = u8;
#[doc = " A package."]
#[doc = ""]
#[doc = " A package can be loaded from disk via \\link alpm_pkg_load \\endlink or retrieved from a database."]
#[doc = " Packages from databases are automatically freed when the database is unregistered. Packages loaded"]
#[doc = " from a file must be freed manually."]
#[doc = ""]
#[doc = " Packages can then be queried for metadata or added to a \\link alpm_trans_t transaction \\endlink"]
#[doc = " to be added or removed from the system."]
#[doc = " @ingroup libalpm_packages"]
pub type alpm_pkg_t = u8;
#[doc = " Transaction structure used internally by libalpm"]
#[doc = " @ingroup libalpm_trans"]
pub type alpm_trans_t = u8;
#[doc = " The time type used by libalpm. Represents a unix time stamp"]
#[doc = " @ingroup libalpm_misc"]
pub type alpm_time_t = i64;
#[doc = " File in a package"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_file_t {
    #[doc = " Name of the file"]
    pub name: *mut ::std::os::raw::c_char,
    #[doc = " Size of the file"]
    pub size: off_t,
    #[doc = " The file's permissions"]
    pub mode: mode_t,
}
#[test]
fn bindgen_test_layout__alpm_file_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_file_t>(),
        24usize,
        concat!("Size of: ", stringify!(_alpm_file_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_file_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_file_t))
    );
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_file_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_file_t),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
    fn test_field_size() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_file_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_file_t),
                "::",
                stringify!(size)
            )
        );
    }
    test_field_size();
    fn test_field_mode() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_file_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_file_t),
                "::",
                stringify!(mode)
            )
        );
    }
    test_field_mode();
}
#[doc = " File in a package"]
pub type alpm_file_t = _alpm_file_t;
#[doc = " Package filelist container"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_filelist_t {
    #[doc = " Amount of files in the array"]
    pub count: usize,
    #[doc = " An array of files"]
    pub files: *mut alpm_file_t,
}
#[test]
fn bindgen_test_layout__alpm_filelist_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_filelist_t>(),
        16usize,
        concat!("Size of: ", stringify!(_alpm_filelist_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_filelist_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_filelist_t))
    );
    fn test_field_count() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_filelist_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_filelist_t),
                "::",
                stringify!(count)
            )
        );
    }
    test_field_count();
    fn test_field_files() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_filelist_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).files) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_filelist_t),
                "::",
                stringify!(files)
            )
        );
    }
    test_field_files();
}
#[doc = " Package filelist container"]
pub type alpm_filelist_t = _alpm_filelist_t;
#[doc = " Local package or package file backup entry"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_backup_t {
    #[doc = " Name of the file (without .pacsave extension)"]
    pub name: *mut ::std::os::raw::c_char,
    #[doc = " Hash of the filename (used internally)"]
    pub hash: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__alpm_backup_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_backup_t>(),
        16usize,
        concat!("Size of: ", stringify!(_alpm_backup_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_backup_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_backup_t))
    );
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_backup_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_backup_t),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
    fn test_field_hash() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_backup_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_backup_t),
                "::",
                stringify!(hash)
            )
        );
    }
    test_field_hash();
}
#[doc = " Local package or package file backup entry"]
pub type alpm_backup_t = _alpm_backup_t;
#[doc = " Package group"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_group_t {
    #[doc = " group name"]
    pub name: *mut ::std::os::raw::c_char,
    #[doc = " list of alpm_pkg_t packages"]
    pub packages: *mut alpm_list_t,
}
#[test]
fn bindgen_test_layout__alpm_group_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_group_t>(),
        16usize,
        concat!("Size of: ", stringify!(_alpm_group_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_group_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_group_t))
    );
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_group_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_group_t),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
    fn test_field_packages() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_group_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).packages) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_group_t),
                "::",
                stringify!(packages)
            )
        );
    }
    test_field_packages();
}
#[doc = " Package group"]
pub type alpm_group_t = _alpm_group_t;
#[repr(u32)]
#[doc = " libalpm's error type"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _alpm_errno_t {
    #[doc = " No error"]
    ALPM_ERR_OK = 0,
    #[doc = " Failed to allocate memory"]
    ALPM_ERR_MEMORY = 1,
    #[doc = " A system error occurred"]
    ALPM_ERR_SYSTEM = 2,
    #[doc = " Permmision denied"]
    ALPM_ERR_BADPERMS = 3,
    #[doc = " Should be a file"]
    ALPM_ERR_NOT_A_FILE = 4,
    #[doc = " Should be a directory"]
    ALPM_ERR_NOT_A_DIR = 5,
    #[doc = " Function was called with invalid arguments"]
    ALPM_ERR_WRONG_ARGS = 6,
    #[doc = " Insufficient disk space"]
    ALPM_ERR_DISK_SPACE = 7,
    #[doc = " Handle should be null"]
    ALPM_ERR_HANDLE_NULL = 8,
    #[doc = " Handle should not be null"]
    ALPM_ERR_HANDLE_NOT_NULL = 9,
    #[doc = " Failed to acquire lock"]
    ALPM_ERR_HANDLE_LOCK = 10,
    #[doc = " Failed to open database"]
    ALPM_ERR_DB_OPEN = 11,
    #[doc = " Failed to create database"]
    ALPM_ERR_DB_CREATE = 12,
    #[doc = " Database should not be null"]
    ALPM_ERR_DB_NULL = 13,
    #[doc = " Database should be null"]
    ALPM_ERR_DB_NOT_NULL = 14,
    #[doc = " The database could not be found"]
    ALPM_ERR_DB_NOT_FOUND = 15,
    #[doc = " Database is invalid"]
    ALPM_ERR_DB_INVALID = 16,
    #[doc = " Database has an invalid signature"]
    ALPM_ERR_DB_INVALID_SIG = 17,
    #[doc = " The localdb is in a newer/older format than libalpm expects"]
    ALPM_ERR_DB_VERSION = 18,
    #[doc = " Failed to write to the database"]
    ALPM_ERR_DB_WRITE = 19,
    #[doc = " Failed to remove entry from database"]
    ALPM_ERR_DB_REMOVE = 20,
    #[doc = " Server URL is in an invalid format"]
    ALPM_ERR_SERVER_BAD_URL = 21,
    #[doc = " The database has no configured servers"]
    ALPM_ERR_SERVER_NONE = 22,
    #[doc = " A transaction is already initialized"]
    ALPM_ERR_TRANS_NOT_NULL = 23,
    #[doc = " A transaction has not been initialized"]
    ALPM_ERR_TRANS_NULL = 24,
    #[doc = " Duplicate target in transaction"]
    ALPM_ERR_TRANS_DUP_TARGET = 25,
    #[doc = " Duplicate filename in transaction"]
    ALPM_ERR_TRANS_DUP_FILENAME = 26,
    #[doc = " A transaction has not been initialized"]
    ALPM_ERR_TRANS_NOT_INITIALIZED = 27,
    #[doc = " Transaction has not been prepared"]
    ALPM_ERR_TRANS_NOT_PREPARED = 28,
    #[doc = " Transaction was aborted"]
    ALPM_ERR_TRANS_ABORT = 29,
    #[doc = " Failed to interrupt transaction"]
    ALPM_ERR_TRANS_TYPE = 30,
    #[doc = " Tried to commit transaction without locking the database"]
    ALPM_ERR_TRANS_NOT_LOCKED = 31,
    #[doc = " A hook failed to run"]
    ALPM_ERR_TRANS_HOOK_FAILED = 32,
    #[doc = " Package not found"]
    ALPM_ERR_PKG_NOT_FOUND = 33,
    #[doc = " Package is in ignorepkg"]
    ALPM_ERR_PKG_IGNORED = 34,
    #[doc = " Package is invalid"]
    ALPM_ERR_PKG_INVALID = 35,
    #[doc = " Package has an invalid checksum"]
    ALPM_ERR_PKG_INVALID_CHECKSUM = 36,
    #[doc = " Package has an invalid signature"]
    ALPM_ERR_PKG_INVALID_SIG = 37,
    #[doc = " Package does not have a signature"]
    ALPM_ERR_PKG_MISSING_SIG = 38,
    #[doc = " Cannot open the package file"]
    ALPM_ERR_PKG_OPEN = 39,
    #[doc = " Failed to remove package files"]
    ALPM_ERR_PKG_CANT_REMOVE = 40,
    #[doc = " Package has an invalid name"]
    ALPM_ERR_PKG_INVALID_NAME = 41,
    #[doc = " Package has an invalid architecture"]
    ALPM_ERR_PKG_INVALID_ARCH = 42,
    #[doc = " Signatures are missing"]
    ALPM_ERR_SIG_MISSING = 43,
    #[doc = " Signatures are invalid"]
    ALPM_ERR_SIG_INVALID = 44,
    #[doc = " Dependencies could not be satisfied"]
    ALPM_ERR_UNSATISFIED_DEPS = 45,
    #[doc = " Conflicting dependencies"]
    ALPM_ERR_CONFLICTING_DEPS = 46,
    #[doc = " Files conflict"]
    ALPM_ERR_FILE_CONFLICTS = 47,
    #[doc = " Download failed"]
    ALPM_ERR_RETRIEVE = 48,
    #[doc = " Invalid Regex"]
    ALPM_ERR_INVALID_REGEX = 49,
    #[doc = " Error in libarchive"]
    ALPM_ERR_LIBARCHIVE = 50,
    #[doc = " Error in libcurl"]
    ALPM_ERR_LIBCURL = 51,
    #[doc = " Error in external download program"]
    ALPM_ERR_EXTERNAL_DOWNLOAD = 52,
    #[doc = " Error in gpgme"]
    ALPM_ERR_GPGME = 53,
    #[doc = " Missing compile-time features"]
    ALPM_ERR_MISSING_CAPABILITY_SIGNATURES = 54,
}
#[doc = " libalpm's error type"]
pub use self::_alpm_errno_t as alpm_errno_t;
pub mod _alpm_siglevel_t {
    #[doc = " PGP signature verification options"]
    pub type Type = ::std::os::raw::c_uint;
    #[doc = " Packages require a signature"]
    pub const ALPM_SIG_PACKAGE: Type = 1;
    #[doc = " Packages do not require a signature,"]
    #[doc = " but check packages that do have signatures"]
    pub const ALPM_SIG_PACKAGE_OPTIONAL: Type = 2;
    #[doc = " Packages do not require a signature,"]
    #[doc = " but check packages that do have signatures"]
    pub const ALPM_SIG_PACKAGE_MARGINAL_OK: Type = 4;
    #[doc = " Allow packages with signatures that are unknown trust"]
    pub const ALPM_SIG_PACKAGE_UNKNOWN_OK: Type = 8;
    #[doc = " Databases require a signature"]
    pub const ALPM_SIG_DATABASE: Type = 1024;
    #[doc = " Databases do not require a signature,"]
    #[doc = " but check databases that do have signatures"]
    pub const ALPM_SIG_DATABASE_OPTIONAL: Type = 2048;
    #[doc = " Allow databases with signatures that are marginal trust"]
    pub const ALPM_SIG_DATABASE_MARGINAL_OK: Type = 4096;
    #[doc = " Allow databases with signatures that are unknown trust"]
    pub const ALPM_SIG_DATABASE_UNKNOWN_OK: Type = 8192;
    #[doc = " The Default siglevel"]
    pub const ALPM_SIG_USE_DEFAULT: Type = 1073741824;
}
#[doc = " PGP signature verification options"]
pub use self::_alpm_siglevel_t::Type as alpm_siglevel_t;
#[repr(u32)]
#[doc = " PGP signature verification status return codes"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _alpm_sigstatus_t {
    #[doc = " Signature is valid"]
    ALPM_SIGSTATUS_VALID = 0,
    #[doc = " The key has expired"]
    ALPM_SIGSTATUS_KEY_EXPIRED = 1,
    #[doc = " The signature has expired"]
    ALPM_SIGSTATUS_SIG_EXPIRED = 2,
    #[doc = " The key is not in the keyring"]
    ALPM_SIGSTATUS_KEY_UNKNOWN = 3,
    #[doc = " The key has been disabled"]
    ALPM_SIGSTATUS_KEY_DISABLED = 4,
    #[doc = " The signature is invalid"]
    ALPM_SIGSTATUS_INVALID = 5,
}
#[doc = " PGP signature verification status return codes"]
pub use self::_alpm_sigstatus_t as alpm_sigstatus_t;
#[repr(u32)]
#[doc = " The trust level of a PGP key"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _alpm_sigvalidity_t {
    #[doc = " The signature is fully trusted"]
    ALPM_SIGVALIDITY_FULL = 0,
    #[doc = " The signature is marginally trusted"]
    ALPM_SIGVALIDITY_MARGINAL = 1,
    #[doc = " The signature is never trusted"]
    ALPM_SIGVALIDITY_NEVER = 2,
    #[doc = " The signature has unknown trust"]
    ALPM_SIGVALIDITY_UNKNOWN = 3,
}
#[doc = " The trust level of a PGP key"]
pub use self::_alpm_sigvalidity_t as alpm_sigvalidity_t;
#[doc = " A PGP key"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_pgpkey_t {
    #[doc = " The actual key data"]
    pub data: *mut ::std::os::raw::c_void,
    #[doc = " The key's fingerprint"]
    pub fingerprint: *mut ::std::os::raw::c_char,
    #[doc = " UID of the key"]
    pub uid: *mut ::std::os::raw::c_char,
    #[doc = " Name of the key's owner"]
    pub name: *mut ::std::os::raw::c_char,
    #[doc = " Email of the key's owner"]
    pub email: *mut ::std::os::raw::c_char,
    #[doc = " When the key was created"]
    pub created: alpm_time_t,
    #[doc = " When the key expires"]
    pub expires: alpm_time_t,
    #[doc = " The length of the key"]
    pub length: ::std::os::raw::c_uint,
    #[doc = " has the key been revoked"]
    pub revoked: ::std::os::raw::c_uint,
    #[doc = " A character representing the  encryption algorithm used by the public key"]
    #[doc = ""]
    #[doc = " ? = unknown"]
    #[doc = " R = RSA"]
    #[doc = " D = DSA"]
    #[doc = " E = EDDSA"]
    pub pubkey_algo: ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__alpm_pgpkey_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_pgpkey_t>(),
        72usize,
        concat!("Size of: ", stringify!(_alpm_pgpkey_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_pgpkey_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_pgpkey_t))
    );
    fn test_field_data() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_pgpkey_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_pgpkey_t),
                "::",
                stringify!(data)
            )
        );
    }
    test_field_data();
    fn test_field_fingerprint() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_pgpkey_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fingerprint) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_pgpkey_t),
                "::",
                stringify!(fingerprint)
            )
        );
    }
    test_field_fingerprint();
    fn test_field_uid() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_pgpkey_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).uid) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_pgpkey_t),
                "::",
                stringify!(uid)
            )
        );
    }
    test_field_uid();
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_pgpkey_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_pgpkey_t),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
    fn test_field_email() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_pgpkey_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).email) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_pgpkey_t),
                "::",
                stringify!(email)
            )
        );
    }
    test_field_email();
    fn test_field_created() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_pgpkey_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).created) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_pgpkey_t),
                "::",
                stringify!(created)
            )
        );
    }
    test_field_created();
    fn test_field_expires() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_pgpkey_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).expires) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_pgpkey_t),
                "::",
                stringify!(expires)
            )
        );
    }
    test_field_expires();
    fn test_field_length() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_pgpkey_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_pgpkey_t),
                "::",
                stringify!(length)
            )
        );
    }
    test_field_length();
    fn test_field_revoked() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_pgpkey_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).revoked) as usize - ptr as usize
            },
            60usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_pgpkey_t),
                "::",
                stringify!(revoked)
            )
        );
    }
    test_field_revoked();
    fn test_field_pubkey_algo() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_pgpkey_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).pubkey_algo) as usize - ptr as usize
            },
            64usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_pgpkey_t),
                "::",
                stringify!(pubkey_algo)
            )
        );
    }
    test_field_pubkey_algo();
}
#[doc = " A PGP key"]
pub type alpm_pgpkey_t = _alpm_pgpkey_t;
#[doc = " Signature result. Contains the key, status, and validity of a given"]
#[doc = " signature."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_sigresult_t {
    #[doc = " The key of the signature"]
    pub key: alpm_pgpkey_t,
    #[doc = " The status of the signature"]
    pub status: alpm_sigstatus_t,
    #[doc = " The validity of the signature"]
    pub validity: alpm_sigvalidity_t,
}
#[test]
fn bindgen_test_layout__alpm_sigresult_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_sigresult_t>(),
        80usize,
        concat!("Size of: ", stringify!(_alpm_sigresult_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_sigresult_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_sigresult_t))
    );
    fn test_field_key() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_sigresult_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_sigresult_t),
                "::",
                stringify!(key)
            )
        );
    }
    test_field_key();
    fn test_field_status() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_sigresult_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_sigresult_t),
                "::",
                stringify!(status)
            )
        );
    }
    test_field_status();
    fn test_field_validity() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_sigresult_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).validity) as usize - ptr as usize
            },
            76usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_sigresult_t),
                "::",
                stringify!(validity)
            )
        );
    }
    test_field_validity();
}
#[doc = " Signature result. Contains the key, status, and validity of a given"]
#[doc = " signature."]
pub type alpm_sigresult_t = _alpm_sigresult_t;
#[doc = " Signature list. Contains the number of signatures found and a pointer to an"]
#[doc = " array of results. The array is of size count."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_siglist_t {
    #[doc = " The amount of results in the array"]
    pub count: usize,
    #[doc = " An array of sigresults"]
    pub results: *mut alpm_sigresult_t,
}
#[test]
fn bindgen_test_layout__alpm_siglist_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_siglist_t>(),
        16usize,
        concat!("Size of: ", stringify!(_alpm_siglist_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_siglist_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_siglist_t))
    );
    fn test_field_count() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_siglist_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_siglist_t),
                "::",
                stringify!(count)
            )
        );
    }
    test_field_count();
    fn test_field_results() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_siglist_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).results) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_siglist_t),
                "::",
                stringify!(results)
            )
        );
    }
    test_field_results();
}
#[doc = " Signature list. Contains the number of signatures found and a pointer to an"]
#[doc = " array of results. The array is of size count."]
pub type alpm_siglist_t = _alpm_siglist_t;
#[repr(u32)]
#[doc = " Types of version constraints in dependency specs."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _alpm_depmod_t {
    #[doc = " No version constraint"]
    ALPM_DEP_MOD_ANY = 1,
    #[doc = " Test version equality (package=x.y.z)"]
    ALPM_DEP_MOD_EQ = 2,
    #[doc = " Test for at least a version (package>=x.y.z)"]
    ALPM_DEP_MOD_GE = 3,
    #[doc = " Test for at most a version (package<=x.y.z)"]
    ALPM_DEP_MOD_LE = 4,
    #[doc = " Test for greater than some version (package>x.y.z)"]
    ALPM_DEP_MOD_GT = 5,
    #[doc = " Test for less than some version (package<x.y.z)"]
    ALPM_DEP_MOD_LT = 6,
}
#[doc = " Types of version constraints in dependency specs."]
pub use self::_alpm_depmod_t as alpm_depmod_t;
#[repr(u32)]
#[doc = " File conflict type."]
#[doc = " Whether the conflict results from a file existing on the filesystem, or with"]
#[doc = " another target in the transaction."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _alpm_fileconflicttype_t {
    #[doc = " The conflict results with a another target in the transaction"]
    ALPM_FILECONFLICT_TARGET = 1,
    #[doc = " The conflict results from a file existing on the filesystem"]
    ALPM_FILECONFLICT_FILESYSTEM = 2,
}
#[doc = " File conflict type."]
#[doc = " Whether the conflict results from a file existing on the filesystem, or with"]
#[doc = " another target in the transaction."]
pub use self::_alpm_fileconflicttype_t as alpm_fileconflicttype_t;
#[doc = " The basic dependency type."]
#[doc = ""]
#[doc = " This type is used throughout libalpm, not just for dependencies"]
#[doc = " but also conflicts and providers."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_depend_t {
    #[doc = "  Name of the provider to satisfy this dependency"]
    pub name: *mut ::std::os::raw::c_char,
    #[doc = "  Version of the provider to match against (optional)"]
    pub version: *mut ::std::os::raw::c_char,
    #[doc = " A description of why this dependency is needed (optional)"]
    pub desc: *mut ::std::os::raw::c_char,
    #[doc = " A hash of name (used internally to speed up conflict checks)"]
    pub name_hash: ::std::os::raw::c_ulong,
    #[doc = " How the version should match against the provider"]
    pub mod_: alpm_depmod_t,
}
#[test]
fn bindgen_test_layout__alpm_depend_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_depend_t>(),
        40usize,
        concat!("Size of: ", stringify!(_alpm_depend_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_depend_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_depend_t))
    );
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_depend_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_depend_t),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
    fn test_field_version() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_depend_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_depend_t),
                "::",
                stringify!(version)
            )
        );
    }
    test_field_version();
    fn test_field_desc() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_depend_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).desc) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_depend_t),
                "::",
                stringify!(desc)
            )
        );
    }
    test_field_desc();
    fn test_field_name_hash() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_depend_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name_hash) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_depend_t),
                "::",
                stringify!(name_hash)
            )
        );
    }
    test_field_name_hash();
    fn test_field_mod() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_depend_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).mod_) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_depend_t),
                "::",
                stringify!(mod_)
            )
        );
    }
    test_field_mod();
}
#[doc = " The basic dependency type."]
#[doc = ""]
#[doc = " This type is used throughout libalpm, not just for dependencies"]
#[doc = " but also conflicts and providers."]
pub type alpm_depend_t = _alpm_depend_t;
#[doc = " Missing dependency."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_depmissing_t {
    #[doc = " Name of the package that has the dependency"]
    pub target: *mut ::std::os::raw::c_char,
    #[doc = " The dependency that was wanted"]
    pub depend: *mut alpm_depend_t,
    #[doc = " If the depmissing was caused by a conflict, the name of the package"]
    #[doc = " that would be installed, causing the satisfying package to be removed"]
    pub causingpkg: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__alpm_depmissing_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_depmissing_t>(),
        24usize,
        concat!("Size of: ", stringify!(_alpm_depmissing_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_depmissing_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_depmissing_t))
    );
    fn test_field_target() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_depmissing_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_depmissing_t),
                "::",
                stringify!(target)
            )
        );
    }
    test_field_target();
    fn test_field_depend() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_depmissing_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).depend) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_depmissing_t),
                "::",
                stringify!(depend)
            )
        );
    }
    test_field_depend();
    fn test_field_causingpkg() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_depmissing_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).causingpkg) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_depmissing_t),
                "::",
                stringify!(causingpkg)
            )
        );
    }
    test_field_causingpkg();
}
#[doc = " Missing dependency."]
pub type alpm_depmissing_t = _alpm_depmissing_t;
#[doc = " A conflict that has occurred between two packages."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_conflict_t {
    #[doc = " Hash of the first package name"]
    #[doc = " (used internally to speed up conflict checks)"]
    pub package1_hash: ::std::os::raw::c_ulong,
    #[doc = " Hash of the second package name"]
    #[doc = " (used internally to speed up conflict checks)"]
    pub package2_hash: ::std::os::raw::c_ulong,
    #[doc = " Name of the first package"]
    pub package1: *mut ::std::os::raw::c_char,
    #[doc = " Name of the second package"]
    pub package2: *mut ::std::os::raw::c_char,
    #[doc = " The conflict"]
    pub reason: *mut alpm_depend_t,
}
#[test]
fn bindgen_test_layout__alpm_conflict_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_conflict_t>(),
        40usize,
        concat!("Size of: ", stringify!(_alpm_conflict_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_conflict_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_conflict_t))
    );
    fn test_field_package1_hash() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_conflict_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).package1_hash) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_conflict_t),
                "::",
                stringify!(package1_hash)
            )
        );
    }
    test_field_package1_hash();
    fn test_field_package2_hash() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_conflict_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).package2_hash) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_conflict_t),
                "::",
                stringify!(package2_hash)
            )
        );
    }
    test_field_package2_hash();
    fn test_field_package1() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_conflict_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).package1) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_conflict_t),
                "::",
                stringify!(package1)
            )
        );
    }
    test_field_package1();
    fn test_field_package2() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_conflict_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).package2) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_conflict_t),
                "::",
                stringify!(package2)
            )
        );
    }
    test_field_package2();
    fn test_field_reason() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_conflict_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).reason) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_conflict_t),
                "::",
                stringify!(reason)
            )
        );
    }
    test_field_reason();
}
#[doc = " A conflict that has occurred between two packages."]
pub type alpm_conflict_t = _alpm_conflict_t;
#[doc = " File conflict."]
#[doc = ""]
#[doc = " A conflict that has happened due to a two packages containing the same file,"]
#[doc = " or a package contains a file that is already on the filesystem and not owned"]
#[doc = " by that package."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_fileconflict_t {
    #[doc = " The name of the package that caused the conflict"]
    pub target: *mut ::std::os::raw::c_char,
    #[doc = " The type of conflict"]
    pub type_: alpm_fileconflicttype_t,
    #[doc = " The name of the file that the package conflicts with"]
    pub file: *mut ::std::os::raw::c_char,
    #[doc = " The name of the package that also owns the file if there is one"]
    pub ctarget: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__alpm_fileconflict_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_fileconflict_t>(),
        32usize,
        concat!("Size of: ", stringify!(_alpm_fileconflict_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_fileconflict_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_fileconflict_t))
    );
    fn test_field_target() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_fileconflict_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_fileconflict_t),
                "::",
                stringify!(target)
            )
        );
    }
    test_field_target();
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_fileconflict_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_fileconflict_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_file() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_fileconflict_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_fileconflict_t),
                "::",
                stringify!(file)
            )
        );
    }
    test_field_file();
    fn test_field_ctarget() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_fileconflict_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ctarget) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_fileconflict_t),
                "::",
                stringify!(ctarget)
            )
        );
    }
    test_field_ctarget();
}
#[doc = " File conflict."]
#[doc = ""]
#[doc = " A conflict that has happened due to a two packages containing the same file,"]
#[doc = " or a package contains a file that is already on the filesystem and not owned"]
#[doc = " by that package."]
pub type alpm_fileconflict_t = _alpm_fileconflict_t;
#[repr(u32)]
#[doc = " Type of events."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _alpm_event_type_t {
    #[doc = " Dependencies will be computed for a package."]
    ALPM_EVENT_CHECKDEPS_START = 1,
    #[doc = " Dependencies were computed for a package."]
    ALPM_EVENT_CHECKDEPS_DONE = 2,
    #[doc = " File conflicts will be computed for a package."]
    ALPM_EVENT_FILECONFLICTS_START = 3,
    #[doc = " File conflicts were computed for a package."]
    ALPM_EVENT_FILECONFLICTS_DONE = 4,
    #[doc = " Dependencies will be resolved for target package."]
    ALPM_EVENT_RESOLVEDEPS_START = 5,
    #[doc = " Dependencies were resolved for target package."]
    ALPM_EVENT_RESOLVEDEPS_DONE = 6,
    #[doc = " Inter-conflicts will be checked for target package."]
    ALPM_EVENT_INTERCONFLICTS_START = 7,
    #[doc = " Inter-conflicts were checked for target package."]
    ALPM_EVENT_INTERCONFLICTS_DONE = 8,
    #[doc = " Processing the package transaction is starting."]
    ALPM_EVENT_TRANSACTION_START = 9,
    #[doc = " Processing the package transaction is finished."]
    ALPM_EVENT_TRANSACTION_DONE = 10,
    #[doc = " Package will be installed/upgraded/downgraded/re-installed/removed; See"]
    #[doc = " alpm_event_package_operation_t for arguments."]
    ALPM_EVENT_PACKAGE_OPERATION_START = 11,
    #[doc = " Package was installed/upgraded/downgraded/re-installed/removed; See"]
    #[doc = " alpm_event_package_operation_t for arguments."]
    ALPM_EVENT_PACKAGE_OPERATION_DONE = 12,
    #[doc = " Target package's integrity will be checked."]
    ALPM_EVENT_INTEGRITY_START = 13,
    #[doc = " Target package's integrity was checked."]
    ALPM_EVENT_INTEGRITY_DONE = 14,
    #[doc = " Target package will be loaded."]
    ALPM_EVENT_LOAD_START = 15,
    #[doc = " Target package is finished loading."]
    ALPM_EVENT_LOAD_DONE = 16,
    #[doc = " Scriptlet has printed information; See alpm_event_scriptlet_info_t for"]
    #[doc = " arguments."]
    ALPM_EVENT_SCRIPTLET_INFO = 17,
    #[doc = " Database files will be downloaded from a repository."]
    ALPM_EVENT_DB_RETRIEVE_START = 18,
    #[doc = " Database files were downloaded from a repository."]
    ALPM_EVENT_DB_RETRIEVE_DONE = 19,
    #[doc = " Not all database files were successfully downloaded from a repository."]
    ALPM_EVENT_DB_RETRIEVE_FAILED = 20,
    #[doc = " Package files will be downloaded from a repository."]
    ALPM_EVENT_PKG_RETRIEVE_START = 21,
    #[doc = " Package files were downloaded from a repository."]
    ALPM_EVENT_PKG_RETRIEVE_DONE = 22,
    #[doc = " Not all package files were successfully downloaded from a repository."]
    ALPM_EVENT_PKG_RETRIEVE_FAILED = 23,
    #[doc = " Disk space usage will be computed for a package."]
    ALPM_EVENT_DISKSPACE_START = 24,
    #[doc = " Disk space usage was computed for a package."]
    ALPM_EVENT_DISKSPACE_DONE = 25,
    #[doc = " An optdepend for another package is being removed; See"]
    #[doc = " alpm_event_optdep_removal_t for arguments."]
    ALPM_EVENT_OPTDEP_REMOVAL = 26,
    #[doc = " A configured repository database is missing; See"]
    #[doc = " alpm_event_database_missing_t for arguments."]
    ALPM_EVENT_DATABASE_MISSING = 27,
    #[doc = " Checking keys used to create signatures are in keyring."]
    ALPM_EVENT_KEYRING_START = 28,
    #[doc = " Keyring checking is finished."]
    ALPM_EVENT_KEYRING_DONE = 29,
    #[doc = " Downloading missing keys into keyring."]
    ALPM_EVENT_KEY_DOWNLOAD_START = 30,
    #[doc = " Key downloading is finished."]
    ALPM_EVENT_KEY_DOWNLOAD_DONE = 31,
    #[doc = " A .pacnew file was created; See alpm_event_pacnew_created_t for arguments."]
    ALPM_EVENT_PACNEW_CREATED = 32,
    #[doc = " A .pacsave file was created; See alpm_event_pacsave_created_t for"]
    #[doc = " arguments."]
    ALPM_EVENT_PACSAVE_CREATED = 33,
    #[doc = " Processing hooks will be started."]
    ALPM_EVENT_HOOK_START = 34,
    #[doc = " Processing hooks is finished."]
    ALPM_EVENT_HOOK_DONE = 35,
    #[doc = " A hook is starting"]
    ALPM_EVENT_HOOK_RUN_START = 36,
    #[doc = " A hook has finished running."]
    ALPM_EVENT_HOOK_RUN_DONE = 37,
}
#[doc = " Type of events."]
pub use self::_alpm_event_type_t as alpm_event_type_t;
#[doc = " An event that may represent any event."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_event_any_t {
    #[doc = " Type of event"]
    pub type_: alpm_event_type_t,
}
#[test]
fn bindgen_test_layout__alpm_event_any_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_event_any_t>(),
        4usize,
        concat!("Size of: ", stringify!(_alpm_event_any_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_event_any_t>(),
        4usize,
        concat!("Alignment of ", stringify!(_alpm_event_any_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_any_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_any_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
}
#[doc = " An event that may represent any event."]
pub type alpm_event_any_t = _alpm_event_any_t;
#[repr(u32)]
#[doc = " An enum over the kind of package operations."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _alpm_package_operation_t {
    #[doc = " Package (to be) installed. (No oldpkg)"]
    ALPM_PACKAGE_INSTALL = 1,
    #[doc = " Package (to be) upgraded"]
    ALPM_PACKAGE_UPGRADE = 2,
    #[doc = " Package (to be) re-installed"]
    ALPM_PACKAGE_REINSTALL = 3,
    #[doc = " Package (to be) downgraded"]
    ALPM_PACKAGE_DOWNGRADE = 4,
    #[doc = " Package (to be) removed (No newpkg)"]
    ALPM_PACKAGE_REMOVE = 5,
}
#[doc = " An enum over the kind of package operations."]
pub use self::_alpm_package_operation_t as alpm_package_operation_t;
#[doc = " A package operation event occurred."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_event_package_operation_t {
    #[doc = " Type of event"]
    pub type_: alpm_event_type_t,
    #[doc = " Type of operation"]
    pub operation: alpm_package_operation_t,
    #[doc = " Old package"]
    pub oldpkg: *mut alpm_pkg_t,
    #[doc = " New package"]
    pub newpkg: *mut alpm_pkg_t,
}
#[test]
fn bindgen_test_layout__alpm_event_package_operation_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_event_package_operation_t>(),
        24usize,
        concat!("Size of: ", stringify!(_alpm_event_package_operation_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_event_package_operation_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_event_package_operation_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_package_operation_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_package_operation_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_operation() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_package_operation_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).operation) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_package_operation_t),
                "::",
                stringify!(operation)
            )
        );
    }
    test_field_operation();
    fn test_field_oldpkg() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_package_operation_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).oldpkg) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_package_operation_t),
                "::",
                stringify!(oldpkg)
            )
        );
    }
    test_field_oldpkg();
    fn test_field_newpkg() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_package_operation_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).newpkg) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_package_operation_t),
                "::",
                stringify!(newpkg)
            )
        );
    }
    test_field_newpkg();
}
#[doc = " A package operation event occurred."]
pub type alpm_event_package_operation_t = _alpm_event_package_operation_t;
#[doc = " An optional dependency was removed."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_event_optdep_removal_t {
    #[doc = " Type of event"]
    pub type_: alpm_event_type_t,
    #[doc = " Package with the optdep"]
    pub pkg: *mut alpm_pkg_t,
    #[doc = " Optdep being removed"]
    pub optdep: *mut alpm_depend_t,
}
#[test]
fn bindgen_test_layout__alpm_event_optdep_removal_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_event_optdep_removal_t>(),
        24usize,
        concat!("Size of: ", stringify!(_alpm_event_optdep_removal_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_event_optdep_removal_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_event_optdep_removal_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_optdep_removal_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_optdep_removal_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_pkg() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_optdep_removal_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).pkg) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_optdep_removal_t),
                "::",
                stringify!(pkg)
            )
        );
    }
    test_field_pkg();
    fn test_field_optdep() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_optdep_removal_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).optdep) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_optdep_removal_t),
                "::",
                stringify!(optdep)
            )
        );
    }
    test_field_optdep();
}
#[doc = " An optional dependency was removed."]
pub type alpm_event_optdep_removal_t = _alpm_event_optdep_removal_t;
#[doc = " A scriptlet was ran."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_event_scriptlet_info_t {
    #[doc = " Type of event"]
    pub type_: alpm_event_type_t,
    #[doc = " Line of scriptlet output"]
    pub line: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__alpm_event_scriptlet_info_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_event_scriptlet_info_t>(),
        16usize,
        concat!("Size of: ", stringify!(_alpm_event_scriptlet_info_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_event_scriptlet_info_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_event_scriptlet_info_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_scriptlet_info_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_scriptlet_info_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_line() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_scriptlet_info_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_scriptlet_info_t),
                "::",
                stringify!(line)
            )
        );
    }
    test_field_line();
}
#[doc = " A scriptlet was ran."]
pub type alpm_event_scriptlet_info_t = _alpm_event_scriptlet_info_t;
#[doc = " A database is missing."]
#[doc = ""]
#[doc = " The database is registered but has not been downloaded"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_event_database_missing_t {
    #[doc = " Type of event"]
    pub type_: alpm_event_type_t,
    #[doc = " Name of the database"]
    pub dbname: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__alpm_event_database_missing_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_event_database_missing_t>(),
        16usize,
        concat!("Size of: ", stringify!(_alpm_event_database_missing_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_event_database_missing_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_event_database_missing_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_database_missing_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_database_missing_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_dbname() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_database_missing_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).dbname) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_database_missing_t),
                "::",
                stringify!(dbname)
            )
        );
    }
    test_field_dbname();
}
#[doc = " A database is missing."]
#[doc = ""]
#[doc = " The database is registered but has not been downloaded"]
pub type alpm_event_database_missing_t = _alpm_event_database_missing_t;
#[doc = " A package was downloaded."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_event_pkgdownload_t {
    #[doc = " Type of event"]
    pub type_: alpm_event_type_t,
    #[doc = " Name of the file"]
    pub file: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__alpm_event_pkgdownload_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_event_pkgdownload_t>(),
        16usize,
        concat!("Size of: ", stringify!(_alpm_event_pkgdownload_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_event_pkgdownload_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_event_pkgdownload_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_pkgdownload_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_pkgdownload_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_file() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_pkgdownload_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_pkgdownload_t),
                "::",
                stringify!(file)
            )
        );
    }
    test_field_file();
}
#[doc = " A package was downloaded."]
pub type alpm_event_pkgdownload_t = _alpm_event_pkgdownload_t;
#[doc = " A pacnew file was created."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_event_pacnew_created_t {
    #[doc = " Type of event"]
    pub type_: alpm_event_type_t,
    #[doc = " Whether the creation was result of a NoUpgrade or not"]
    pub from_noupgrade: ::std::os::raw::c_int,
    #[doc = " Old package"]
    pub oldpkg: *mut alpm_pkg_t,
    #[doc = " New Package"]
    pub newpkg: *mut alpm_pkg_t,
    #[doc = " Filename of the file without the .pacnew suffix"]
    pub file: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__alpm_event_pacnew_created_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_event_pacnew_created_t>(),
        32usize,
        concat!("Size of: ", stringify!(_alpm_event_pacnew_created_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_event_pacnew_created_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_event_pacnew_created_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_pacnew_created_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_pacnew_created_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_from_noupgrade() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_pacnew_created_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).from_noupgrade) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_pacnew_created_t),
                "::",
                stringify!(from_noupgrade)
            )
        );
    }
    test_field_from_noupgrade();
    fn test_field_oldpkg() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_pacnew_created_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).oldpkg) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_pacnew_created_t),
                "::",
                stringify!(oldpkg)
            )
        );
    }
    test_field_oldpkg();
    fn test_field_newpkg() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_pacnew_created_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).newpkg) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_pacnew_created_t),
                "::",
                stringify!(newpkg)
            )
        );
    }
    test_field_newpkg();
    fn test_field_file() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_pacnew_created_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_pacnew_created_t),
                "::",
                stringify!(file)
            )
        );
    }
    test_field_file();
}
#[doc = " A pacnew file was created."]
pub type alpm_event_pacnew_created_t = _alpm_event_pacnew_created_t;
#[doc = " A pacsave file was created."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_event_pacsave_created_t {
    #[doc = " Type of event"]
    pub type_: alpm_event_type_t,
    #[doc = " Old package"]
    pub oldpkg: *mut alpm_pkg_t,
    #[doc = " Filename of the file without the .pacsave suffix"]
    pub file: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__alpm_event_pacsave_created_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_event_pacsave_created_t>(),
        24usize,
        concat!("Size of: ", stringify!(_alpm_event_pacsave_created_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_event_pacsave_created_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_event_pacsave_created_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_pacsave_created_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_pacsave_created_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_oldpkg() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_pacsave_created_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).oldpkg) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_pacsave_created_t),
                "::",
                stringify!(oldpkg)
            )
        );
    }
    test_field_oldpkg();
    fn test_field_file() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_pacsave_created_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_pacsave_created_t),
                "::",
                stringify!(file)
            )
        );
    }
    test_field_file();
}
#[doc = " A pacsave file was created."]
pub type alpm_event_pacsave_created_t = _alpm_event_pacsave_created_t;
#[repr(u32)]
#[doc = " Kind of hook."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _alpm_hook_when_t {
    ALPM_HOOK_PRE_TRANSACTION = 1,
    ALPM_HOOK_POST_TRANSACTION = 2,
}
#[doc = " Kind of hook."]
pub use self::_alpm_hook_when_t as alpm_hook_when_t;
#[doc = " pre/post transaction hooks are to be ran."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_event_hook_t {
    #[doc = " Type of event"]
    pub type_: alpm_event_type_t,
    #[doc = " Type of hook"]
    pub when: alpm_hook_when_t,
}
#[test]
fn bindgen_test_layout__alpm_event_hook_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_event_hook_t>(),
        8usize,
        concat!("Size of: ", stringify!(_alpm_event_hook_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_event_hook_t>(),
        4usize,
        concat!("Alignment of ", stringify!(_alpm_event_hook_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_hook_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_hook_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_when() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_hook_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).when) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_hook_t),
                "::",
                stringify!(when)
            )
        );
    }
    test_field_when();
}
#[doc = " pre/post transaction hooks are to be ran."]
pub type alpm_event_hook_t = _alpm_event_hook_t;
#[doc = " A pre/post transaction hook was ran."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_event_hook_run_t {
    #[doc = " Type of event"]
    pub type_: alpm_event_type_t,
    #[doc = " Name of hook"]
    pub name: *const ::std::os::raw::c_char,
    #[doc = " Description of hook to be outputted"]
    pub desc: *const ::std::os::raw::c_char,
    #[doc = " position of hook being run"]
    pub position: usize,
    #[doc = " total hooks being run"]
    pub total: usize,
}
#[test]
fn bindgen_test_layout__alpm_event_hook_run_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_event_hook_run_t>(),
        40usize,
        concat!("Size of: ", stringify!(_alpm_event_hook_run_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_event_hook_run_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_event_hook_run_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_hook_run_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_hook_run_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_hook_run_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_hook_run_t),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
    fn test_field_desc() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_hook_run_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).desc) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_hook_run_t),
                "::",
                stringify!(desc)
            )
        );
    }
    test_field_desc();
    fn test_field_position() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_hook_run_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_hook_run_t),
                "::",
                stringify!(position)
            )
        );
    }
    test_field_position();
    fn test_field_total() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_hook_run_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).total) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_hook_run_t),
                "::",
                stringify!(total)
            )
        );
    }
    test_field_total();
}
#[doc = " A pre/post transaction hook was ran."]
pub type alpm_event_hook_run_t = _alpm_event_hook_run_t;
#[doc = " Packages downloading about to start."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_event_pkg_retrieve_t {
    #[doc = " Type of event"]
    pub type_: alpm_event_type_t,
    #[doc = " Number of packages to download"]
    pub num: usize,
    #[doc = " Total size of packages to download"]
    pub total_size: off_t,
}
#[test]
fn bindgen_test_layout__alpm_event_pkg_retrieve_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_event_pkg_retrieve_t>(),
        24usize,
        concat!("Size of: ", stringify!(_alpm_event_pkg_retrieve_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_event_pkg_retrieve_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_event_pkg_retrieve_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_pkg_retrieve_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_pkg_retrieve_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_num() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_pkg_retrieve_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).num) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_pkg_retrieve_t),
                "::",
                stringify!(num)
            )
        );
    }
    test_field_num();
    fn test_field_total_size() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_pkg_retrieve_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).total_size) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_pkg_retrieve_t),
                "::",
                stringify!(total_size)
            )
        );
    }
    test_field_total_size();
}
#[doc = " Packages downloading about to start."]
pub type alpm_event_pkg_retrieve_t = _alpm_event_pkg_retrieve_t;
#[doc = " Events."]
#[doc = " This is a union passed to the callback that allows the frontend to know"]
#[doc = " which type of event was triggered (via type). It is then possible to"]
#[doc = " typecast the pointer to the right structure, or use the union field, in order"]
#[doc = " to access event-specific data."]
#[repr(C)]
#[derive(Copy, Clone)]
pub union _alpm_event_t {
    #[doc = " Type of event it's always safe to access this."]
    pub type_: alpm_event_type_t,
    #[doc = " The any event type. It's always safe to access this."]
    pub any: alpm_event_any_t,
    #[doc = " Package operation"]
    pub package_operation: alpm_event_package_operation_t,
    #[doc = " An optdept was remove"]
    pub optdep_removal: alpm_event_optdep_removal_t,
    #[doc = " A scriptlet was ran"]
    pub scriptlet_info: alpm_event_scriptlet_info_t,
    #[doc = " A database is missing"]
    pub database_missing: alpm_event_database_missing_t,
    #[doc = " A package was downloaded"]
    pub pkgdownload: alpm_event_pkgdownload_t,
    #[doc = " A pacnew file was created"]
    pub pacnew_created: alpm_event_pacnew_created_t,
    #[doc = " A pacsave file was created"]
    pub pacsave_created: alpm_event_pacsave_created_t,
    #[doc = " Pre/post transaction hooks are being ran"]
    pub hook: alpm_event_hook_t,
    #[doc = " A hook was ran"]
    pub hook_run: alpm_event_hook_run_t,
    #[doc = " Download packages"]
    pub pkg_retrieve: alpm_event_pkg_retrieve_t,
}
#[test]
fn bindgen_test_layout__alpm_event_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_event_t>(),
        40usize,
        concat!("Size of: ", stringify!(_alpm_event_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_event_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_event_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_any() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).any) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_t),
                "::",
                stringify!(any)
            )
        );
    }
    test_field_any();
    fn test_field_package_operation() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).package_operation) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_t),
                "::",
                stringify!(package_operation)
            )
        );
    }
    test_field_package_operation();
    fn test_field_optdep_removal() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).optdep_removal) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_t),
                "::",
                stringify!(optdep_removal)
            )
        );
    }
    test_field_optdep_removal();
    fn test_field_scriptlet_info() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).scriptlet_info) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_t),
                "::",
                stringify!(scriptlet_info)
            )
        );
    }
    test_field_scriptlet_info();
    fn test_field_database_missing() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).database_missing) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_t),
                "::",
                stringify!(database_missing)
            )
        );
    }
    test_field_database_missing();
    fn test_field_pkgdownload() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).pkgdownload) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_t),
                "::",
                stringify!(pkgdownload)
            )
        );
    }
    test_field_pkgdownload();
    fn test_field_pacnew_created() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).pacnew_created) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_t),
                "::",
                stringify!(pacnew_created)
            )
        );
    }
    test_field_pacnew_created();
    fn test_field_pacsave_created() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).pacsave_created) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_t),
                "::",
                stringify!(pacsave_created)
            )
        );
    }
    test_field_pacsave_created();
    fn test_field_hook() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).hook) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_t),
                "::",
                stringify!(hook)
            )
        );
    }
    test_field_hook();
    fn test_field_hook_run() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).hook_run) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_t),
                "::",
                stringify!(hook_run)
            )
        );
    }
    test_field_hook_run();
    fn test_field_pkg_retrieve() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_event_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).pkg_retrieve) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_event_t),
                "::",
                stringify!(pkg_retrieve)
            )
        );
    }
    test_field_pkg_retrieve();
}
#[doc = " Events."]
#[doc = " This is a union passed to the callback that allows the frontend to know"]
#[doc = " which type of event was triggered (via type). It is then possible to"]
#[doc = " typecast the pointer to the right structure, or use the union field, in order"]
#[doc = " to access event-specific data."]
pub type alpm_event_t = _alpm_event_t;
#[doc = " Event callback."]
#[doc = ""]
#[doc = " Called when an event occurs"]
#[doc = " @param ctx user-provided context"]
#[doc = " @param event the event that occurred"]
pub type alpm_cb_event = ::std::option::Option<
    unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, arg1: *mut alpm_event_t),
>;
pub mod _alpm_question_type_t {
    #[doc = " Type of question."]
    #[doc = " Unlike the events or progress enumerations, this enum has bitmask values"]
    #[doc = " so a frontend can use a bitmask map to supply preselected answers to the"]
    #[doc = " different types of questions."]
    pub type Type = ::std::os::raw::c_uint;
    #[doc = " Should target in ignorepkg be installed anyway?"]
    pub const ALPM_QUESTION_INSTALL_IGNOREPKG: Type = 1;
    #[doc = " Should a package be replaced?"]
    pub const ALPM_QUESTION_REPLACE_PKG: Type = 2;
    #[doc = " Should a conflicting package be removed?"]
    pub const ALPM_QUESTION_CONFLICT_PKG: Type = 4;
    #[doc = " Should a corrupted package be deleted?"]
    pub const ALPM_QUESTION_CORRUPTED_PKG: Type = 8;
    #[doc = " Should unresolvable targets be removed from the transaction?"]
    pub const ALPM_QUESTION_REMOVE_PKGS: Type = 16;
    #[doc = " Provider selection"]
    pub const ALPM_QUESTION_SELECT_PROVIDER: Type = 32;
    #[doc = " Should a key be imported?"]
    pub const ALPM_QUESTION_IMPORT_KEY: Type = 64;
}
#[doc = " Type of question."]
#[doc = " Unlike the events or progress enumerations, this enum has bitmask values"]
#[doc = " so a frontend can use a bitmask map to supply preselected answers to the"]
#[doc = " different types of questions."]
pub use self::_alpm_question_type_t::Type as alpm_question_type_t;
#[doc = " A question that can represent any other question."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_question_any_t {
    #[doc = " Type of question"]
    pub type_: alpm_question_type_t,
    #[doc = " Answer"]
    pub answer: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__alpm_question_any_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_question_any_t>(),
        8usize,
        concat!("Size of: ", stringify!(_alpm_question_any_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_question_any_t>(),
        4usize,
        concat!("Alignment of ", stringify!(_alpm_question_any_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_any_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_any_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_answer() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_any_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).answer) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_any_t),
                "::",
                stringify!(answer)
            )
        );
    }
    test_field_answer();
}
#[doc = " A question that can represent any other question."]
pub type alpm_question_any_t = _alpm_question_any_t;
#[doc = " Should target in ignorepkg be installed anyway?"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_question_install_ignorepkg_t {
    #[doc = " Type of question"]
    pub type_: alpm_question_type_t,
    #[doc = " Answer: whether or not to install pkg anyway"]
    pub install: ::std::os::raw::c_int,
    #[doc = " The ignored package that we are deciding whether to install"]
    pub pkg: *mut alpm_pkg_t,
}
#[test]
fn bindgen_test_layout__alpm_question_install_ignorepkg_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_question_install_ignorepkg_t>(),
        16usize,
        concat!("Size of: ", stringify!(_alpm_question_install_ignorepkg_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_question_install_ignorepkg_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_alpm_question_install_ignorepkg_t)
        )
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::std::mem::MaybeUninit::<_alpm_question_install_ignorepkg_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_install_ignorepkg_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_install() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::std::mem::MaybeUninit::<_alpm_question_install_ignorepkg_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).install) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_install_ignorepkg_t),
                "::",
                stringify!(install)
            )
        );
    }
    test_field_install();
    fn test_field_pkg() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::std::mem::MaybeUninit::<_alpm_question_install_ignorepkg_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).pkg) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_install_ignorepkg_t),
                "::",
                stringify!(pkg)
            )
        );
    }
    test_field_pkg();
}
#[doc = " Should target in ignorepkg be installed anyway?"]
pub type alpm_question_install_ignorepkg_t = _alpm_question_install_ignorepkg_t;
#[doc = " Should a package be replaced?"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_question_replace_t {
    #[doc = " Type of question"]
    pub type_: alpm_question_type_t,
    #[doc = " Answer: whether or not to replace oldpkg with newpkg"]
    pub replace: ::std::os::raw::c_int,
    #[doc = " Package to be replaced"]
    pub oldpkg: *mut alpm_pkg_t,
    #[doc = " Package to replace with."]
    pub newpkg: *mut alpm_pkg_t,
    #[doc = " DB of newpkg"]
    pub newdb: *mut alpm_db_t,
}
#[test]
fn bindgen_test_layout__alpm_question_replace_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_question_replace_t>(),
        32usize,
        concat!("Size of: ", stringify!(_alpm_question_replace_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_question_replace_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_question_replace_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_replace_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_replace_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_replace() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_replace_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).replace) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_replace_t),
                "::",
                stringify!(replace)
            )
        );
    }
    test_field_replace();
    fn test_field_oldpkg() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_replace_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).oldpkg) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_replace_t),
                "::",
                stringify!(oldpkg)
            )
        );
    }
    test_field_oldpkg();
    fn test_field_newpkg() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_replace_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).newpkg) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_replace_t),
                "::",
                stringify!(newpkg)
            )
        );
    }
    test_field_newpkg();
    fn test_field_newdb() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_replace_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).newdb) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_replace_t),
                "::",
                stringify!(newdb)
            )
        );
    }
    test_field_newdb();
}
#[doc = " Should a package be replaced?"]
pub type alpm_question_replace_t = _alpm_question_replace_t;
#[doc = " Should a conflicting package be removed?"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_question_conflict_t {
    #[doc = " Type of question"]
    pub type_: alpm_question_type_t,
    #[doc = " Answer: whether or not to remove conflict->package2"]
    pub remove: ::std::os::raw::c_int,
    #[doc = " Conflict info"]
    pub conflict: *mut alpm_conflict_t,
}
#[test]
fn bindgen_test_layout__alpm_question_conflict_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_question_conflict_t>(),
        16usize,
        concat!("Size of: ", stringify!(_alpm_question_conflict_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_question_conflict_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_question_conflict_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_conflict_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_conflict_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_remove() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_conflict_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).remove) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_conflict_t),
                "::",
                stringify!(remove)
            )
        );
    }
    test_field_remove();
    fn test_field_conflict() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_conflict_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).conflict) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_conflict_t),
                "::",
                stringify!(conflict)
            )
        );
    }
    test_field_conflict();
}
#[doc = " Should a conflicting package be removed?"]
pub type alpm_question_conflict_t = _alpm_question_conflict_t;
#[doc = " Should a corrupted package be deleted?"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_question_corrupted_t {
    #[doc = " Type of question"]
    pub type_: alpm_question_type_t,
    #[doc = " Answer: whether or not to remove filepath"]
    pub remove: ::std::os::raw::c_int,
    #[doc = " File to remove"]
    pub filepath: *const ::std::os::raw::c_char,
    #[doc = " Error code indicating the reason for package invalidity"]
    pub reason: alpm_errno_t,
}
#[test]
fn bindgen_test_layout__alpm_question_corrupted_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_question_corrupted_t>(),
        24usize,
        concat!("Size of: ", stringify!(_alpm_question_corrupted_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_question_corrupted_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_question_corrupted_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_corrupted_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_corrupted_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_remove() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_corrupted_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).remove) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_corrupted_t),
                "::",
                stringify!(remove)
            )
        );
    }
    test_field_remove();
    fn test_field_filepath() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_corrupted_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).filepath) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_corrupted_t),
                "::",
                stringify!(filepath)
            )
        );
    }
    test_field_filepath();
    fn test_field_reason() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_corrupted_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).reason) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_corrupted_t),
                "::",
                stringify!(reason)
            )
        );
    }
    test_field_reason();
}
#[doc = " Should a corrupted package be deleted?"]
pub type alpm_question_corrupted_t = _alpm_question_corrupted_t;
#[doc = " Should unresolvable targets be removed from the transaction?"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_question_remove_pkgs_t {
    #[doc = " Type of question"]
    pub type_: alpm_question_type_t,
    #[doc = " Answer: whether or not to skip packages"]
    pub skip: ::std::os::raw::c_int,
    #[doc = " List of alpm_pkg_t* with unresolved dependencies"]
    pub packages: *mut alpm_list_t,
}
#[test]
fn bindgen_test_layout__alpm_question_remove_pkgs_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_question_remove_pkgs_t>(),
        16usize,
        concat!("Size of: ", stringify!(_alpm_question_remove_pkgs_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_question_remove_pkgs_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_question_remove_pkgs_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_remove_pkgs_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_remove_pkgs_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_skip() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_remove_pkgs_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).skip) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_remove_pkgs_t),
                "::",
                stringify!(skip)
            )
        );
    }
    test_field_skip();
    fn test_field_packages() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_remove_pkgs_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).packages) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_remove_pkgs_t),
                "::",
                stringify!(packages)
            )
        );
    }
    test_field_packages();
}
#[doc = " Should unresolvable targets be removed from the transaction?"]
pub type alpm_question_remove_pkgs_t = _alpm_question_remove_pkgs_t;
#[doc = " Provider selection"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_question_select_provider_t {
    #[doc = " Type of question"]
    pub type_: alpm_question_type_t,
    #[doc = " Answer: which provider to use (index from providers)"]
    pub use_index: ::std::os::raw::c_int,
    #[doc = " List of alpm_pkg_t* as possible providers"]
    pub providers: *mut alpm_list_t,
    #[doc = " What providers provide for"]
    pub depend: *mut alpm_depend_t,
}
#[test]
fn bindgen_test_layout__alpm_question_select_provider_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_question_select_provider_t>(),
        24usize,
        concat!("Size of: ", stringify!(_alpm_question_select_provider_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_question_select_provider_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_alpm_question_select_provider_t)
        )
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_select_provider_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_select_provider_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_use_index() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_select_provider_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).use_index) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_select_provider_t),
                "::",
                stringify!(use_index)
            )
        );
    }
    test_field_use_index();
    fn test_field_providers() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_select_provider_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).providers) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_select_provider_t),
                "::",
                stringify!(providers)
            )
        );
    }
    test_field_providers();
    fn test_field_depend() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_select_provider_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).depend) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_select_provider_t),
                "::",
                stringify!(depend)
            )
        );
    }
    test_field_depend();
}
#[doc = " Provider selection"]
pub type alpm_question_select_provider_t = _alpm_question_select_provider_t;
#[doc = " Should a key be imported?"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_question_import_key_t {
    #[doc = " Type of question"]
    pub type_: alpm_question_type_t,
    #[doc = " Answer: whether or not to import key"]
    pub import: ::std::os::raw::c_int,
    #[doc = " The key to import"]
    pub key: *mut alpm_pgpkey_t,
}
#[test]
fn bindgen_test_layout__alpm_question_import_key_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_question_import_key_t>(),
        16usize,
        concat!("Size of: ", stringify!(_alpm_question_import_key_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_question_import_key_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_question_import_key_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_import_key_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_import_key_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_import() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_import_key_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).import) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_import_key_t),
                "::",
                stringify!(import)
            )
        );
    }
    test_field_import();
    fn test_field_key() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_import_key_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_import_key_t),
                "::",
                stringify!(key)
            )
        );
    }
    test_field_key();
}
#[doc = " Should a key be imported?"]
pub type alpm_question_import_key_t = _alpm_question_import_key_t;
#[doc = " Questions."]
#[doc = " This is an union passed to the callback that allows the frontend to know"]
#[doc = " which type of question was triggered (via type). It is then possible to"]
#[doc = " typecast the pointer to the right structure, or use the union field, in order"]
#[doc = " to access question-specific data."]
#[repr(C)]
#[derive(Copy, Clone)]
pub union _alpm_question_t {
    #[doc = " The type of question. It's always safe to access this."]
    pub type_: alpm_question_type_t,
    #[doc = " A question that can represent any question."]
    #[doc = " It's always safe to access this."]
    pub any: alpm_question_any_t,
    #[doc = " Should target in ignorepkg be installed anyway?"]
    pub install_ignorepkg: alpm_question_install_ignorepkg_t,
    #[doc = " Should a package be replaced?"]
    pub replace: alpm_question_replace_t,
    #[doc = " Should a conflicting package be removed?"]
    pub conflict: alpm_question_conflict_t,
    #[doc = " Should a corrupted package be deleted?"]
    pub corrupted: alpm_question_corrupted_t,
    #[doc = " Should unresolvable targets be removed from the transaction?"]
    pub remove_pkgs: alpm_question_remove_pkgs_t,
    #[doc = " Provider selection"]
    pub select_provider: alpm_question_select_provider_t,
    #[doc = " Should a key be imported?"]
    pub import_key: alpm_question_import_key_t,
}
#[test]
fn bindgen_test_layout__alpm_question_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_question_t>(),
        32usize,
        concat!("Size of: ", stringify!(_alpm_question_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_question_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_question_t))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_t),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_any() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).any) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_t),
                "::",
                stringify!(any)
            )
        );
    }
    test_field_any();
    fn test_field_install_ignorepkg() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).install_ignorepkg) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_t),
                "::",
                stringify!(install_ignorepkg)
            )
        );
    }
    test_field_install_ignorepkg();
    fn test_field_replace() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).replace) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_t),
                "::",
                stringify!(replace)
            )
        );
    }
    test_field_replace();
    fn test_field_conflict() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).conflict) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_t),
                "::",
                stringify!(conflict)
            )
        );
    }
    test_field_conflict();
    fn test_field_corrupted() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).corrupted) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_t),
                "::",
                stringify!(corrupted)
            )
        );
    }
    test_field_corrupted();
    fn test_field_remove_pkgs() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).remove_pkgs) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_t),
                "::",
                stringify!(remove_pkgs)
            )
        );
    }
    test_field_remove_pkgs();
    fn test_field_select_provider() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).select_provider) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_t),
                "::",
                stringify!(select_provider)
            )
        );
    }
    test_field_select_provider();
    fn test_field_import_key() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_question_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).import_key) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_question_t),
                "::",
                stringify!(import_key)
            )
        );
    }
    test_field_import_key();
}
#[doc = " Questions."]
#[doc = " This is an union passed to the callback that allows the frontend to know"]
#[doc = " which type of question was triggered (via type). It is then possible to"]
#[doc = " typecast the pointer to the right structure, or use the union field, in order"]
#[doc = " to access question-specific data."]
pub type alpm_question_t = _alpm_question_t;
#[doc = " Question callback."]
#[doc = ""]
#[doc = " This callback allows user to give input and decide what to do during certain events"]
#[doc = " @param ctx user-provided context"]
#[doc = " @param question the question being asked."]
pub type alpm_cb_question = ::std::option::Option<
    unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, arg1: *mut alpm_question_t),
>;
#[repr(u32)]
#[doc = " An enum over different kinds of progress alerts."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _alpm_progress_t {
    #[doc = " Package install"]
    ALPM_PROGRESS_ADD_START = 0,
    #[doc = " Package upgrade"]
    ALPM_PROGRESS_UPGRADE_START = 1,
    #[doc = " Package downgrade"]
    ALPM_PROGRESS_DOWNGRADE_START = 2,
    #[doc = " Package reinstall"]
    ALPM_PROGRESS_REINSTALL_START = 3,
    #[doc = " Package removal"]
    ALPM_PROGRESS_REMOVE_START = 4,
    #[doc = " Conflict checking"]
    ALPM_PROGRESS_CONFLICTS_START = 5,
    #[doc = " Diskspace checking"]
    ALPM_PROGRESS_DISKSPACE_START = 6,
    #[doc = " Package Integrity checking"]
    ALPM_PROGRESS_INTEGRITY_START = 7,
    #[doc = " Loading packages from disk"]
    ALPM_PROGRESS_LOAD_START = 8,
    #[doc = " Checking signatures of packages"]
    ALPM_PROGRESS_KEYRING_START = 9,
}
#[doc = " An enum over different kinds of progress alerts."]
pub use self::_alpm_progress_t as alpm_progress_t;
#[doc = " Progress callback"]
#[doc = ""]
#[doc = " Alert the front end about the progress of certain events."]
#[doc = " Allows the implementation of loading bars for events that"]
#[doc = " make take a while to complete."]
#[doc = " @param ctx user-provided context"]
#[doc = " @param progress the kind of event that is progressing"]
#[doc = " @param pkg for package operations, the name of the package being operated on"]
#[doc = " @param percent the percent completion of the action"]
#[doc = " @param howmany the total amount of items in the action"]
#[doc = " @param current the current amount of items completed"]
pub type alpm_cb_progress = ::std::option::Option<
    unsafe extern "C" fn(
        ctx: *mut ::std::os::raw::c_void,
        progress: alpm_progress_t,
        pkg: *const ::std::os::raw::c_char,
        percent: ::std::os::raw::c_int,
        howmany: usize,
        current: usize,
    ),
>;
#[repr(u32)]
#[doc = " File download events."]
#[doc = " These events are reported by ALPM via download callback."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _alpm_download_event_type_t {
    #[doc = " A download was started"]
    ALPM_DOWNLOAD_INIT = 0,
    #[doc = " A download made progress"]
    ALPM_DOWNLOAD_PROGRESS = 1,
    #[doc = " Download will be retried"]
    ALPM_DOWNLOAD_RETRY = 2,
    #[doc = " A download completed"]
    ALPM_DOWNLOAD_COMPLETED = 3,
}
#[doc = " File download events."]
#[doc = " These events are reported by ALPM via download callback."]
pub use self::_alpm_download_event_type_t as alpm_download_event_type_t;
#[doc = " Context struct for when a download starts."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_download_event_init_t {
    #[doc = " whether this file is optional and thus the errors could be ignored"]
    pub optional: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__alpm_download_event_init_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_download_event_init_t>(),
        4usize,
        concat!("Size of: ", stringify!(_alpm_download_event_init_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_download_event_init_t>(),
        4usize,
        concat!("Alignment of ", stringify!(_alpm_download_event_init_t))
    );
    fn test_field_optional() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_download_event_init_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).optional) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_download_event_init_t),
                "::",
                stringify!(optional)
            )
        );
    }
    test_field_optional();
}
#[doc = " Context struct for when a download starts."]
pub type alpm_download_event_init_t = _alpm_download_event_init_t;
#[doc = " Context struct for when a download progresses."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_download_event_progress_t {
    #[doc = " Amount of data downloaded"]
    pub downloaded: off_t,
    #[doc = " Total amount need to be downloaded"]
    pub total: off_t,
}
#[test]
fn bindgen_test_layout__alpm_download_event_progress_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_download_event_progress_t>(),
        16usize,
        concat!("Size of: ", stringify!(_alpm_download_event_progress_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_download_event_progress_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_alpm_download_event_progress_t))
    );
    fn test_field_downloaded() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_download_event_progress_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).downloaded) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_download_event_progress_t),
                "::",
                stringify!(downloaded)
            )
        );
    }
    test_field_downloaded();
    fn test_field_total() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_download_event_progress_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).total) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_download_event_progress_t),
                "::",
                stringify!(total)
            )
        );
    }
    test_field_total();
}
#[doc = " Context struct for when a download progresses."]
pub type alpm_download_event_progress_t = _alpm_download_event_progress_t;
#[doc = " Context struct for when a download retries."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_download_event_retry_t {
    #[doc = " If the download will resume or start over"]
    pub resume: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__alpm_download_event_retry_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_download_event_retry_t>(),
        4usize,
        concat!("Size of: ", stringify!(_alpm_download_event_retry_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_download_event_retry_t>(),
        4usize,
        concat!("Alignment of ", stringify!(_alpm_download_event_retry_t))
    );
    fn test_field_resume() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_download_event_retry_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).resume) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_download_event_retry_t),
                "::",
                stringify!(resume)
            )
        );
    }
    test_field_resume();
}
#[doc = " Context struct for when a download retries."]
pub type alpm_download_event_retry_t = _alpm_download_event_retry_t;
#[doc = " Context struct for when a download completes."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _alpm_download_event_completed_t {
    #[doc = " Total bytes in file"]
    pub total: off_t,
    #[doc = " download result code:"]
    #[doc = "    0 - download completed successfully"]
    #[doc = "    1 - the file is up-to-date"]
    #[doc = "   -1 - error"]
    pub result: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__alpm_download_event_completed_t() {
    assert_eq!(
        ::std::mem::size_of::<_alpm_download_event_completed_t>(),
        16usize,
        concat!("Size of: ", stringify!(_alpm_download_event_completed_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_alpm_download_event_completed_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_alpm_download_event_completed_t)
        )
    );
    fn test_field_total() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_download_event_completed_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).total) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_download_event_completed_t),
                "::",
                stringify!(total)
            )
        );
    }
    test_field_total();
    fn test_field_result() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<_alpm_download_event_completed_t>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).result) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(_alpm_download_event_completed_t),
                "::",
                stringify!(result)
            )
        );
    }
    test_field_result();
}
#[doc = " Context struct for when a download completes."]
pub type alpm_download_event_completed_t = _alpm_download_event_completed_t;
#[doc = " Type of download progress callbacks."]
#[doc = " @param ctx user-provided context"]
#[doc = " @param filename the name of the file being downloaded"]
#[doc = " @param event the event type"]
#[doc = " @param data the event data of type alpm_download_event_*_t"]
pub type alpm_cb_download = ::std::option::Option<
    unsafe extern "C" fn(
        ctx: *mut ::std::os::raw::c_void,
        filename: *const ::std::os::raw::c_char,
        event: alpm_download_event_type_t,
        data: *mut ::std::os::raw::c_void,
    ),
>;
#[doc = " A callback for downloading files"]
#[doc = " @param ctx user-provided context"]
#[doc = " @param url the URL of the file to be downloaded"]
#[doc = " @param localpath the directory to which the file should be downloaded"]
#[doc = " @param force whether to force an update, even if the file is the same"]
#[doc = " @return 0 on success, 1 if the file exists and is identical, -1 on"]
#[doc = " error."]
pub type alpm_cb_fetch = ::std::option::Option<
    unsafe extern "C" fn(
        ctx: *mut ::std::os::raw::c_void,
        url: *const ::std::os::raw::c_char,
        localpath: *const ::std::os::raw::c_char,
        force: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
>;
pub mod _alpm_db_usage_t {
    #[doc = " The usage level of a database."]
    pub type Type = ::std::os::raw::c_uint;
    #[doc = " Enable refreshes for this database"]
    pub const ALPM_DB_USAGE_SYNC: Type = 1;
    #[doc = " Enable search for this database"]
    pub const ALPM_DB_USAGE_SEARCH: Type = 2;
    #[doc = " Enable installing packages from this database"]
    pub const ALPM_DB_USAGE_INSTALL: Type = 4;
    #[doc = " Enable sysupgrades with this database"]
    pub const ALPM_DB_USAGE_UPGRADE: Type = 8;
    #[doc = " Enable all usage levels"]
    pub const ALPM_DB_USAGE_ALL: Type = 15;
}
#[doc = " The usage level of a database."]
pub use self::_alpm_db_usage_t::Type as alpm_db_usage_t;
pub mod _alpm_loglevel_t {
    #[doc = " Logging Levels"]
    pub type Type = ::std::os::raw::c_uint;
    #[doc = " Error"]
    pub const ALPM_LOG_ERROR: Type = 1;
    #[doc = " Warning"]
    pub const ALPM_LOG_WARNING: Type = 2;
    #[doc = " Debug"]
    pub const ALPM_LOG_DEBUG: Type = 4;
    #[doc = " Function"]
    pub const ALPM_LOG_FUNCTION: Type = 8;
}
#[doc = " Logging Levels"]
pub use self::_alpm_loglevel_t::Type as alpm_loglevel_t;
#[doc = " The callback type for logging."]
#[doc = ""]
#[doc = " libalpm will call this function whenever something is to be logged."]
#[doc = " many libalpm will produce log output. Additionally any calls to \\link alpm_logaction"]
#[doc = " \\endlink will also call this callback."]
#[doc = " @param ctx user-provided context"]
#[doc = " @param level the currently set loglevel"]
#[doc = " @param fmt the printf like format string"]
#[doc = " @param args printf like arguments"]
pub type alpm_cb_log = ::std::option::Option<
    unsafe extern "C" fn(
        ctx: *mut ::std::os::raw::c_void,
        level: alpm_loglevel_t,
        fmt: *const ::std::os::raw::c_char,
        args: *mut __va_list_tag,
    ),
>;
#[repr(u32)]
#[doc = " Package install reasons."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _alpm_pkgreason_t {
    #[doc = " Explicitly requested by the user."]
    ALPM_PKG_REASON_EXPLICIT = 0,
    #[doc = " Installed as a dependency for another package."]
    ALPM_PKG_REASON_DEPEND = 1,
}
#[doc = " Package install reasons."]
pub use self::_alpm_pkgreason_t as alpm_pkgreason_t;
#[repr(u32)]
#[doc = " Location a package object was loaded from."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _alpm_pkgfrom_t {
    #[doc = " Loaded from a file via \\link alpm_pkg_load \\endlink"]
    ALPM_PKG_FROM_FILE = 1,
    #[doc = " From the local database"]
    ALPM_PKG_FROM_LOCALDB = 2,
    #[doc = " From a sync database"]
    ALPM_PKG_FROM_SYNCDB = 3,
}
#[doc = " Location a package object was loaded from."]
pub use self::_alpm_pkgfrom_t as alpm_pkgfrom_t;
pub mod _alpm_pkgvalidation_t {
    #[doc = " Method used to validate a package."]
    pub type Type = ::std::os::raw::c_uint;
    #[doc = " The package's validation type is unknown"]
    pub const ALPM_PKG_VALIDATION_UNKNOWN: Type = 0;
    #[doc = " The package does not have any validation"]
    pub const ALPM_PKG_VALIDATION_NONE: Type = 1;
    #[doc = " The package is validated with md5"]
    pub const ALPM_PKG_VALIDATION_MD5SUM: Type = 2;
    #[doc = " The package is validated with sha256"]
    pub const ALPM_PKG_VALIDATION_SHA256SUM: Type = 4;
    #[doc = " The package is validated with a PGP signature"]
    pub const ALPM_PKG_VALIDATION_SIGNATURE: Type = 8;
}
#[doc = " Method used to validate a package."]
pub use self::_alpm_pkgvalidation_t::Type as alpm_pkgvalidation_t;
pub mod _alpm_transflag_t {
    #[doc = " Transaction flags"]
    pub type Type = ::std::os::raw::c_uint;
    #[doc = " Ignore dependency checks."]
    pub const ALPM_TRANS_FLAG_NODEPS: Type = 1;
    #[doc = " Delete files even if they are tagged as backup."]
    pub const ALPM_TRANS_FLAG_NOSAVE: Type = 4;
    #[doc = " Ignore version numbers when checking dependencies."]
    pub const ALPM_TRANS_FLAG_NODEPVERSION: Type = 8;
    #[doc = " Remove also any packages depending on a package being removed."]
    pub const ALPM_TRANS_FLAG_CASCADE: Type = 16;
    #[doc = " Remove packages and their unneeded deps (not explicitly installed)."]
    pub const ALPM_TRANS_FLAG_RECURSE: Type = 32;
    #[doc = " Modify database but do not commit changes to the filesystem."]
    pub const ALPM_TRANS_FLAG_DBONLY: Type = 64;
    #[doc = " Use ALPM_PKG_REASON_DEPEND when installing packages."]
    pub const ALPM_TRANS_FLAG_ALLDEPS: Type = 256;
    #[doc = " Only download packages and do not actually install."]
    pub const ALPM_TRANS_FLAG_DOWNLOADONLY: Type = 512;
    #[doc = " Do not execute install scriptlets after installing."]
    pub const ALPM_TRANS_FLAG_NOSCRIPTLET: Type = 1024;
    #[doc = " Ignore dependency conflicts."]
    pub const ALPM_TRANS_FLAG_NOCONFLICTS: Type = 2048;
    #[doc = " Do not install a package if it is already installed and up to date."]
    pub const ALPM_TRANS_FLAG_NEEDED: Type = 8192;
    #[doc = " Use ALPM_PKG_REASON_EXPLICIT when installing packages."]
    pub const ALPM_TRANS_FLAG_ALLEXPLICIT: Type = 16384;
    #[doc = " Do not remove a package if it is needed by another one."]
    pub const ALPM_TRANS_FLAG_UNNEEDED: Type = 32768;
    #[doc = " Remove also explicitly installed unneeded deps (use with ALPM_TRANS_FLAG_RECURSE)."]
    pub const ALPM_TRANS_FLAG_RECURSEALL: Type = 65536;
    #[doc = " Do not lock the database during the operation."]
    pub const ALPM_TRANS_FLAG_NOLOCK: Type = 131072;
}
#[doc = " Transaction flags"]
pub use self::_alpm_transflag_t::Type as alpm_transflag_t;
pub mod alpm_caps {
    #[doc = " Enum of possible compile time features"]
    pub type Type = ::std::os::raw::c_uint;
    #[doc = " localization"]
    pub const ALPM_CAPABILITY_NLS: Type = 1;
    #[doc = " Ability to download"]
    pub const ALPM_CAPABILITY_DOWNLOADER: Type = 2;
    #[doc = " Signature checking"]
    pub const ALPM_CAPABILITY_SIGNATURES: Type = 4;
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
    pub gp_offset: ::std::os::raw::c_uint,
    pub fp_offset: ::std::os::raw::c_uint,
    pub overflow_arg_area: *mut ::std::os::raw::c_void,
    pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
    assert_eq!(
        ::std::mem::size_of::<__va_list_tag>(),
        24usize,
        concat!("Size of: ", stringify!(__va_list_tag))
    );
    assert_eq!(
        ::std::mem::align_of::<__va_list_tag>(),
        8usize,
        concat!("Alignment of ", stringify!(__va_list_tag))
    );
    fn test_field_gp_offset() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<__va_list_tag>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).gp_offset) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(__va_list_tag),
                "::",
                stringify!(gp_offset)
            )
        );
    }
    test_field_gp_offset();
    fn test_field_fp_offset() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<__va_list_tag>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(__va_list_tag),
                "::",
                stringify!(fp_offset)
            )
        );
    }
    test_field_fp_offset();
    fn test_field_overflow_arg_area() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<__va_list_tag>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(__va_list_tag),
                "::",
                stringify!(overflow_arg_area)
            )
        );
    }
    test_field_overflow_arg_area();
    fn test_field_reg_save_area() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<__va_list_tag>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(__va_list_tag),
                "::",
                stringify!(reg_save_area)
            )
        );
    }
    test_field_reg_save_area();
}
extern crate libloading;
pub struct libalpm {
    __library: ::libloading::Library,
    pub alpm_list_free: unsafe extern "C" fn(list: *mut alpm_list_t),
    pub alpm_list_free_inner: unsafe extern "C" fn(list: *mut alpm_list_t, fn_: alpm_list_fn_free),
    pub alpm_list_add: unsafe extern "C" fn(
        list: *mut alpm_list_t,
        data: *mut ::std::os::raw::c_void,
    ) -> *mut alpm_list_t,
    pub alpm_list_append: unsafe extern "C" fn(
        list: *mut *mut alpm_list_t,
        data: *mut ::std::os::raw::c_void,
    ) -> *mut alpm_list_t,
    pub alpm_list_append_strdup: unsafe extern "C" fn(
        list: *mut *mut alpm_list_t,
        data: *const ::std::os::raw::c_char,
    ) -> *mut alpm_list_t,
    pub alpm_list_add_sorted: unsafe extern "C" fn(
        list: *mut alpm_list_t,
        data: *mut ::std::os::raw::c_void,
        fn_: alpm_list_fn_cmp,
    ) -> *mut alpm_list_t,
    pub alpm_list_join:
        unsafe extern "C" fn(first: *mut alpm_list_t, second: *mut alpm_list_t) -> *mut alpm_list_t,
    pub alpm_list_mmerge: unsafe extern "C" fn(
        left: *mut alpm_list_t,
        right: *mut alpm_list_t,
        fn_: alpm_list_fn_cmp,
    ) -> *mut alpm_list_t,
    pub alpm_list_msort: unsafe extern "C" fn(
        list: *mut alpm_list_t,
        n: usize,
        fn_: alpm_list_fn_cmp,
    ) -> *mut alpm_list_t,
    pub alpm_list_remove_item: unsafe extern "C" fn(
        haystack: *mut alpm_list_t,
        item: *mut alpm_list_t,
    ) -> *mut alpm_list_t,
    pub alpm_list_remove: unsafe extern "C" fn(
        haystack: *mut alpm_list_t,
        needle: *const ::std::os::raw::c_void,
        fn_: alpm_list_fn_cmp,
        data: *mut *mut ::std::os::raw::c_void,
    ) -> *mut alpm_list_t,
    pub alpm_list_remove_str: unsafe extern "C" fn(
        haystack: *mut alpm_list_t,
        needle: *const ::std::os::raw::c_char,
        data: *mut *mut ::std::os::raw::c_char,
    ) -> *mut alpm_list_t,
    pub alpm_list_remove_dupes: unsafe extern "C" fn(list: *const alpm_list_t) -> *mut alpm_list_t,
    pub alpm_list_strdup: unsafe extern "C" fn(list: *const alpm_list_t) -> *mut alpm_list_t,
    pub alpm_list_copy: unsafe extern "C" fn(list: *const alpm_list_t) -> *mut alpm_list_t,
    pub alpm_list_copy_data:
        unsafe extern "C" fn(list: *const alpm_list_t, size: usize) -> *mut alpm_list_t,
    pub alpm_list_reverse: unsafe extern "C" fn(list: *mut alpm_list_t) -> *mut alpm_list_t,
    pub alpm_list_nth: unsafe extern "C" fn(list: *const alpm_list_t, n: usize) -> *mut alpm_list_t,
    pub alpm_list_next: unsafe extern "C" fn(list: *const alpm_list_t) -> *mut alpm_list_t,
    pub alpm_list_previous: unsafe extern "C" fn(list: *const alpm_list_t) -> *mut alpm_list_t,
    pub alpm_list_last: unsafe extern "C" fn(list: *const alpm_list_t) -> *mut alpm_list_t,
    pub alpm_list_count: unsafe extern "C" fn(list: *const alpm_list_t) -> usize,
    pub alpm_list_find: unsafe extern "C" fn(
        haystack: *const alpm_list_t,
        needle: *const ::std::os::raw::c_void,
        fn_: alpm_list_fn_cmp,
    ) -> *mut ::std::os::raw::c_void,
    pub alpm_list_find_ptr: unsafe extern "C" fn(
        haystack: *const alpm_list_t,
        needle: *const ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
    pub alpm_list_find_str: unsafe extern "C" fn(
        haystack: *const alpm_list_t,
        needle: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char,
    pub alpm_list_diff_sorted: unsafe extern "C" fn(
        left: *const alpm_list_t,
        right: *const alpm_list_t,
        fn_: alpm_list_fn_cmp,
        onlyleft: *mut *mut alpm_list_t,
        onlyright: *mut *mut alpm_list_t,
    ),
    pub alpm_list_diff: unsafe extern "C" fn(
        lhs: *const alpm_list_t,
        rhs: *const alpm_list_t,
        fn_: alpm_list_fn_cmp,
    ) -> *mut alpm_list_t,
    pub alpm_list_to_array: unsafe extern "C" fn(
        list: *const alpm_list_t,
        n: usize,
        size: usize,
    ) -> *mut ::std::os::raw::c_void,
    pub alpm_filelist_contains: unsafe extern "C" fn(
        filelist: *mut alpm_filelist_t,
        path: *const ::std::os::raw::c_char,
    ) -> *mut alpm_file_t,
    pub alpm_find_group_pkgs: unsafe extern "C" fn(
        dbs: *mut alpm_list_t,
        name: *const ::std::os::raw::c_char,
    ) -> *mut alpm_list_t,
    pub alpm_errno: unsafe extern "C" fn(handle: *mut alpm_handle_t) -> alpm_errno_t,
    pub alpm_strerror: unsafe extern "C" fn(err: alpm_errno_t) -> *const ::std::os::raw::c_char,
    pub alpm_initialize: unsafe extern "C" fn(
        root: *const ::std::os::raw::c_char,
        dbpath: *const ::std::os::raw::c_char,
        err: *mut alpm_errno_t,
    ) -> *mut alpm_handle_t,
    pub alpm_release: unsafe extern "C" fn(handle: *mut alpm_handle_t) -> ::std::os::raw::c_int,
    pub alpm_pkg_check_pgp_signature: unsafe extern "C" fn(
        pkg: *mut alpm_pkg_t,
        siglist: *mut alpm_siglist_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_db_check_pgp_signature: unsafe extern "C" fn(
        db: *mut alpm_db_t,
        siglist: *mut alpm_siglist_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_siglist_cleanup:
        unsafe extern "C" fn(siglist: *mut alpm_siglist_t) -> ::std::os::raw::c_int,
    pub alpm_decode_signature: unsafe extern "C" fn(
        base64_data: *const ::std::os::raw::c_char,
        data: *mut *mut ::std::os::raw::c_uchar,
        data_len: *mut usize,
    ) -> ::std::os::raw::c_int,
    pub alpm_extract_keyid: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        identifier: *const ::std::os::raw::c_char,
        sig: *const ::std::os::raw::c_uchar,
        len: usize,
        keys: *mut *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_checkdeps: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        pkglist: *mut alpm_list_t,
        remove: *mut alpm_list_t,
        upgrade: *mut alpm_list_t,
        reversedeps: ::std::os::raw::c_int,
    ) -> *mut alpm_list_t,
    pub alpm_find_satisfier: unsafe extern "C" fn(
        pkgs: *mut alpm_list_t,
        depstring: *const ::std::os::raw::c_char,
    ) -> *mut alpm_pkg_t,
    pub alpm_find_dbs_satisfier: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        dbs: *mut alpm_list_t,
        depstring: *const ::std::os::raw::c_char,
    ) -> *mut alpm_pkg_t,
    pub alpm_checkconflicts: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        pkglist: *mut alpm_list_t,
    ) -> *mut alpm_list_t,
    pub alpm_dep_compute_string:
        unsafe extern "C" fn(dep: *const alpm_depend_t) -> *mut ::std::os::raw::c_char,
    pub alpm_dep_from_string:
        unsafe extern "C" fn(depstring: *const ::std::os::raw::c_char) -> *mut alpm_depend_t,
    pub alpm_dep_free: unsafe extern "C" fn(dep: *mut alpm_depend_t),
    pub alpm_fileconflict_free: unsafe extern "C" fn(conflict: *mut alpm_fileconflict_t),
    pub alpm_depmissing_free: unsafe extern "C" fn(miss: *mut alpm_depmissing_t),
    pub alpm_conflict_free: unsafe extern "C" fn(conflict: *mut alpm_conflict_t),
    pub alpm_get_localdb: unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut alpm_db_t,
    pub alpm_get_syncdbs: unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut alpm_list_t,
    pub alpm_register_syncdb: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        treename: *const ::std::os::raw::c_char,
        level: ::std::os::raw::c_int,
    ) -> *mut alpm_db_t,
    pub alpm_unregister_all_syncdbs:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> ::std::os::raw::c_int,
    pub alpm_db_unregister: unsafe extern "C" fn(db: *mut alpm_db_t) -> ::std::os::raw::c_int,
    pub alpm_db_get_name:
        unsafe extern "C" fn(db: *const alpm_db_t) -> *const ::std::os::raw::c_char,
    pub alpm_db_get_siglevel: unsafe extern "C" fn(db: *mut alpm_db_t) -> ::std::os::raw::c_int,
    pub alpm_db_get_valid: unsafe extern "C" fn(db: *mut alpm_db_t) -> ::std::os::raw::c_int,
    pub alpm_db_get_servers: unsafe extern "C" fn(db: *const alpm_db_t) -> *mut alpm_list_t,
    pub alpm_db_set_servers: unsafe extern "C" fn(
        db: *mut alpm_db_t,
        servers: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_db_add_server: unsafe extern "C" fn(
        db: *mut alpm_db_t,
        url: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_db_remove_server: unsafe extern "C" fn(
        db: *mut alpm_db_t,
        url: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_db_update: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        dbs: *mut alpm_list_t,
        force: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
    pub alpm_db_get_pkg: unsafe extern "C" fn(
        db: *mut alpm_db_t,
        name: *const ::std::os::raw::c_char,
    ) -> *mut alpm_pkg_t,
    pub alpm_db_get_pkgcache: unsafe extern "C" fn(db: *mut alpm_db_t) -> *mut alpm_list_t,
    pub alpm_db_get_group: unsafe extern "C" fn(
        db: *mut alpm_db_t,
        name: *const ::std::os::raw::c_char,
    ) -> *mut alpm_group_t,
    pub alpm_db_get_groupcache: unsafe extern "C" fn(db: *mut alpm_db_t) -> *mut alpm_list_t,
    pub alpm_db_search: unsafe extern "C" fn(
        db: *mut alpm_db_t,
        needles: *const alpm_list_t,
        ret: *mut *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_db_set_usage: unsafe extern "C" fn(
        db: *mut alpm_db_t,
        usage: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
    pub alpm_db_get_usage: unsafe extern "C" fn(
        db: *mut alpm_db_t,
        usage: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
    pub alpm_logaction: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        prefix: *const ::std::os::raw::c_char,
        fmt: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_logcb: unsafe extern "C" fn(handle: *mut alpm_handle_t) -> alpm_cb_log,
    pub alpm_option_get_logcb_ctx:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut ::std::os::raw::c_void,
    pub alpm_option_set_logcb: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        cb: alpm_cb_log,
        ctx: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_dlcb: unsafe extern "C" fn(handle: *mut alpm_handle_t) -> alpm_cb_download,
    pub alpm_option_get_dlcb_ctx:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut ::std::os::raw::c_void,
    pub alpm_option_set_dlcb: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        cb: alpm_cb_download,
        ctx: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_fetchcb: unsafe extern "C" fn(handle: *mut alpm_handle_t) -> alpm_cb_fetch,
    pub alpm_option_get_fetchcb_ctx:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut ::std::os::raw::c_void,
    pub alpm_option_set_fetchcb: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        cb: alpm_cb_fetch,
        ctx: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_eventcb: unsafe extern "C" fn(handle: *mut alpm_handle_t) -> alpm_cb_event,
    pub alpm_option_get_eventcb_ctx:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut ::std::os::raw::c_void,
    pub alpm_option_set_eventcb: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        cb: alpm_cb_event,
        ctx: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_questioncb:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> alpm_cb_question,
    pub alpm_option_get_questioncb_ctx:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut ::std::os::raw::c_void,
    pub alpm_option_set_questioncb: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        cb: alpm_cb_question,
        ctx: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_progresscb:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> alpm_cb_progress,
    pub alpm_option_get_progresscb_ctx:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut ::std::os::raw::c_void,
    pub alpm_option_set_progresscb: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        cb: alpm_cb_progress,
        ctx: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_root:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *const ::std::os::raw::c_char,
    pub alpm_option_get_dbpath:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *const ::std::os::raw::c_char,
    pub alpm_option_get_lockfile:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *const ::std::os::raw::c_char,
    pub alpm_option_get_cachedirs:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut alpm_list_t,
    pub alpm_option_set_cachedirs: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        cachedirs: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_add_cachedir: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        cachedir: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_remove_cachedir: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        cachedir: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_hookdirs:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut alpm_list_t,
    pub alpm_option_set_hookdirs: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        hookdirs: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_add_hookdir: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        hookdir: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_remove_hookdir: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        hookdir: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_overwrite_files:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut alpm_list_t,
    pub alpm_option_set_overwrite_files: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        globs: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_add_overwrite_file: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        glob: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_remove_overwrite_file: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        glob: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_logfile:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *const ::std::os::raw::c_char,
    pub alpm_option_set_logfile: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        logfile: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_gpgdir:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *const ::std::os::raw::c_char,
    pub alpm_option_set_gpgdir: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        gpgdir: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_usesyslog:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> ::std::os::raw::c_int,
    pub alpm_option_set_usesyslog: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        usesyslog: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_noupgrades:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut alpm_list_t,
    pub alpm_option_add_noupgrade: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        path: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_set_noupgrades: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        noupgrade: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_remove_noupgrade: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        path: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_match_noupgrade: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        path: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_noextracts:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut alpm_list_t,
    pub alpm_option_add_noextract: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        path: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_set_noextracts: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        noextract: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_remove_noextract: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        path: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_match_noextract: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        path: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_ignorepkgs:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut alpm_list_t,
    pub alpm_option_add_ignorepkg: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        pkg: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_set_ignorepkgs: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        ignorepkgs: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_remove_ignorepkg: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        pkg: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_ignoregroups:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut alpm_list_t,
    pub alpm_option_add_ignoregroup: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        grp: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_set_ignoregroups: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        ignoregrps: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_remove_ignoregroup: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        grp: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_assumeinstalled:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut alpm_list_t,
    pub alpm_option_add_assumeinstalled: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        dep: *const alpm_depend_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_set_assumeinstalled: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        deps: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_remove_assumeinstalled: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        dep: *const alpm_depend_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_architectures:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut alpm_list_t,
    pub alpm_option_add_architecture: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        arch: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_set_architectures: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        arches: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_remove_architecture: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        arch: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_checkspace:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> ::std::os::raw::c_int,
    pub alpm_option_set_checkspace: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        checkspace: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_dbext:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *const ::std::os::raw::c_char,
    pub alpm_option_set_dbext: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        dbext: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_default_siglevel:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> ::std::os::raw::c_int,
    pub alpm_option_set_default_siglevel: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        level: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_local_file_siglevel:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> ::std::os::raw::c_int,
    pub alpm_option_set_local_file_siglevel: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        level: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_remote_file_siglevel:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> ::std::os::raw::c_int,
    pub alpm_option_set_remote_file_siglevel: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        level: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_set_disable_dl_timeout: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        disable_dl_timeout: ::std::os::raw::c_ushort,
    ) -> ::std::os::raw::c_int,
    pub alpm_option_get_parallel_downloads:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> ::std::os::raw::c_int,
    pub alpm_option_set_parallel_downloads: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        num_streams: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int,
    pub alpm_pkg_load: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        filename: *const ::std::os::raw::c_char,
        full: ::std::os::raw::c_int,
        level: ::std::os::raw::c_int,
        pkg: *mut *mut alpm_pkg_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_fetch_pkgurl: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        urls: *const alpm_list_t,
        fetched: *mut *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_pkg_find: unsafe extern "C" fn(
        haystack: *mut alpm_list_t,
        needle: *const ::std::os::raw::c_char,
    ) -> *mut alpm_pkg_t,
    pub alpm_pkg_free: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> ::std::os::raw::c_int,
    pub alpm_pkg_checkmd5sum: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> ::std::os::raw::c_int,
    pub alpm_pkg_vercmp: unsafe extern "C" fn(
        a: *const ::std::os::raw::c_char,
        b: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
    pub alpm_pkg_compute_requiredby: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_list_t,
    pub alpm_pkg_compute_optionalfor:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_list_t,
    pub alpm_pkg_should_ignore: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        pkg: *mut alpm_pkg_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_pkg_get_filename:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char,
    pub alpm_pkg_get_base:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char,
    pub alpm_pkg_get_name:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char,
    pub alpm_pkg_get_version:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char,
    pub alpm_pkg_get_origin: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> alpm_pkgfrom_t,
    pub alpm_pkg_get_desc:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char,
    pub alpm_pkg_get_url:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char,
    pub alpm_pkg_get_builddate: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> alpm_time_t,
    pub alpm_pkg_get_installdate: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> alpm_time_t,
    pub alpm_pkg_get_packager:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char,
    pub alpm_pkg_get_md5sum:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char,
    pub alpm_pkg_get_sha256sum:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char,
    pub alpm_pkg_get_arch:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char,
    pub alpm_pkg_get_size: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> off_t,
    pub alpm_pkg_get_isize: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> off_t,
    pub alpm_pkg_get_reason: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> alpm_pkgreason_t,
    pub alpm_pkg_get_licenses: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_list_t,
    pub alpm_pkg_get_groups: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_list_t,
    pub alpm_pkg_get_depends: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_list_t,
    pub alpm_pkg_get_optdepends: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_list_t,
    pub alpm_pkg_get_checkdepends: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_list_t,
    pub alpm_pkg_get_makedepends: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_list_t,
    pub alpm_pkg_get_conflicts: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_list_t,
    pub alpm_pkg_get_provides: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_list_t,
    pub alpm_pkg_get_replaces: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_list_t,
    pub alpm_pkg_get_files: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_filelist_t,
    pub alpm_pkg_get_backup: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_list_t,
    pub alpm_pkg_get_db: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut alpm_db_t,
    pub alpm_pkg_get_base64_sig:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char,
    pub alpm_pkg_get_sig: unsafe extern "C" fn(
        pkg: *mut alpm_pkg_t,
        sig: *mut *mut ::std::os::raw::c_uchar,
        sig_len: *mut usize,
    ) -> ::std::os::raw::c_int,
    pub alpm_pkg_get_validation:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> ::std::os::raw::c_int,
    pub alpm_pkg_has_scriptlet: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> ::std::os::raw::c_int,
    pub alpm_pkg_download_size: unsafe extern "C" fn(newpkg: *mut alpm_pkg_t) -> off_t,
    pub alpm_pkg_set_reason: unsafe extern "C" fn(
        pkg: *mut alpm_pkg_t,
        reason: alpm_pkgreason_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_pkg_changelog_open:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut ::std::os::raw::c_void,
    pub alpm_pkg_changelog_read: unsafe extern "C" fn(
        ptr: *mut ::std::os::raw::c_void,
        size: usize,
        pkg: *const alpm_pkg_t,
        fp: *mut ::std::os::raw::c_void,
    ) -> usize,
    pub alpm_pkg_changelog_close: unsafe extern "C" fn(
        pkg: *const alpm_pkg_t,
        fp: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
    pub alpm_pkg_mtree_open: unsafe extern "C" fn(pkg: *mut alpm_pkg_t) -> *mut archive,
    pub alpm_pkg_mtree_next: unsafe extern "C" fn(
        pkg: *const alpm_pkg_t,
        archive: *mut archive,
        entry: *mut *mut archive_entry,
    ) -> ::std::os::raw::c_int,
    pub alpm_pkg_mtree_close: unsafe extern "C" fn(
        pkg: *const alpm_pkg_t,
        archive: *mut archive,
    ) -> ::std::os::raw::c_int,
    pub alpm_trans_get_flags:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> ::std::os::raw::c_int,
    pub alpm_trans_get_add: unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut alpm_list_t,
    pub alpm_trans_get_remove: unsafe extern "C" fn(handle: *mut alpm_handle_t) -> *mut alpm_list_t,
    pub alpm_trans_init: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        flags: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
    pub alpm_trans_prepare: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        data: *mut *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_trans_commit: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        data: *mut *mut alpm_list_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_trans_interrupt:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> ::std::os::raw::c_int,
    pub alpm_trans_release:
        unsafe extern "C" fn(handle: *mut alpm_handle_t) -> ::std::os::raw::c_int,
    pub alpm_sync_sysupgrade: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        enable_downgrade: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
    pub alpm_add_pkg: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        pkg: *mut alpm_pkg_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_remove_pkg: unsafe extern "C" fn(
        handle: *mut alpm_handle_t,
        pkg: *mut alpm_pkg_t,
    ) -> ::std::os::raw::c_int,
    pub alpm_sync_get_new_version:
        unsafe extern "C" fn(pkg: *mut alpm_pkg_t, dbs_sync: *mut alpm_list_t) -> *mut alpm_pkg_t,
    pub alpm_compute_md5sum: unsafe extern "C" fn(
        filename: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char,
    pub alpm_compute_sha256sum: unsafe extern "C" fn(
        filename: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char,
    pub alpm_unlock: unsafe extern "C" fn(handle: *mut alpm_handle_t) -> ::std::os::raw::c_int,
    pub alpm_version: unsafe extern "C" fn() -> *const ::std::os::raw::c_char,
    pub alpm_capabilities: unsafe extern "C" fn() -> ::std::os::raw::c_int,
}
impl libalpm {
    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
    where
        P: AsRef<::std::ffi::OsStr>,
    {
        let library = ::libloading::Library::new(path)?;
        Self::from_library(library)
    }
    pub unsafe fn from_library<L>(library: L) -> Result<Self, ::libloading::Error>
    where
        L: Into<::libloading::Library>,
    {
        let __library = library.into();
        let alpm_list_free = __library.get(b"alpm_list_free\0").map(|sym| *sym)?;
        let alpm_list_free_inner = __library.get(b"alpm_list_free_inner\0").map(|sym| *sym)?;
        let alpm_list_add = __library.get(b"alpm_list_add\0").map(|sym| *sym)?;
        let alpm_list_append = __library.get(b"alpm_list_append\0").map(|sym| *sym)?;
        let alpm_list_append_strdup = __library
            .get(b"alpm_list_append_strdup\0")
            .map(|sym| *sym)?;
        let alpm_list_add_sorted = __library.get(b"alpm_list_add_sorted\0").map(|sym| *sym)?;
        let alpm_list_join = __library.get(b"alpm_list_join\0").map(|sym| *sym)?;
        let alpm_list_mmerge = __library.get(b"alpm_list_mmerge\0").map(|sym| *sym)?;
        let alpm_list_msort = __library.get(b"alpm_list_msort\0").map(|sym| *sym)?;
        let alpm_list_remove_item = __library.get(b"alpm_list_remove_item\0").map(|sym| *sym)?;
        let alpm_list_remove = __library.get(b"alpm_list_remove\0").map(|sym| *sym)?;
        let alpm_list_remove_str = __library.get(b"alpm_list_remove_str\0").map(|sym| *sym)?;
        let alpm_list_remove_dupes = __library.get(b"alpm_list_remove_dupes\0").map(|sym| *sym)?;
        let alpm_list_strdup = __library.get(b"alpm_list_strdup\0").map(|sym| *sym)?;
        let alpm_list_copy = __library.get(b"alpm_list_copy\0").map(|sym| *sym)?;
        let alpm_list_copy_data = __library.get(b"alpm_list_copy_data\0").map(|sym| *sym)?;
        let alpm_list_reverse = __library.get(b"alpm_list_reverse\0").map(|sym| *sym)?;
        let alpm_list_nth = __library.get(b"alpm_list_nth\0").map(|sym| *sym)?;
        let alpm_list_next = __library.get(b"alpm_list_next\0").map(|sym| *sym)?;
        let alpm_list_previous = __library.get(b"alpm_list_previous\0").map(|sym| *sym)?;
        let alpm_list_last = __library.get(b"alpm_list_last\0").map(|sym| *sym)?;
        let alpm_list_count = __library.get(b"alpm_list_count\0").map(|sym| *sym)?;
        let alpm_list_find = __library.get(b"alpm_list_find\0").map(|sym| *sym)?;
        let alpm_list_find_ptr = __library.get(b"alpm_list_find_ptr\0").map(|sym| *sym)?;
        let alpm_list_find_str = __library.get(b"alpm_list_find_str\0").map(|sym| *sym)?;
        let alpm_list_diff_sorted = __library.get(b"alpm_list_diff_sorted\0").map(|sym| *sym)?;
        let alpm_list_diff = __library.get(b"alpm_list_diff\0").map(|sym| *sym)?;
        let alpm_list_to_array = __library.get(b"alpm_list_to_array\0").map(|sym| *sym)?;
        let alpm_filelist_contains = __library.get(b"alpm_filelist_contains\0").map(|sym| *sym)?;
        let alpm_find_group_pkgs = __library.get(b"alpm_find_group_pkgs\0").map(|sym| *sym)?;
        let alpm_errno = __library.get(b"alpm_errno\0").map(|sym| *sym)?;
        let alpm_strerror = __library.get(b"alpm_strerror\0").map(|sym| *sym)?;
        let alpm_initialize = __library.get(b"alpm_initialize\0").map(|sym| *sym)?;
        let alpm_release = __library.get(b"alpm_release\0").map(|sym| *sym)?;
        let alpm_pkg_check_pgp_signature = __library
            .get(b"alpm_pkg_check_pgp_signature\0")
            .map(|sym| *sym)?;
        let alpm_db_check_pgp_signature = __library
            .get(b"alpm_db_check_pgp_signature\0")
            .map(|sym| *sym)?;
        let alpm_siglist_cleanup = __library.get(b"alpm_siglist_cleanup\0").map(|sym| *sym)?;
        let alpm_decode_signature = __library.get(b"alpm_decode_signature\0").map(|sym| *sym)?;
        let alpm_extract_keyid = __library.get(b"alpm_extract_keyid\0").map(|sym| *sym)?;
        let alpm_checkdeps = __library.get(b"alpm_checkdeps\0").map(|sym| *sym)?;
        let alpm_find_satisfier = __library.get(b"alpm_find_satisfier\0").map(|sym| *sym)?;
        let alpm_find_dbs_satisfier = __library
            .get(b"alpm_find_dbs_satisfier\0")
            .map(|sym| *sym)?;
        let alpm_checkconflicts = __library.get(b"alpm_checkconflicts\0").map(|sym| *sym)?;
        let alpm_dep_compute_string = __library
            .get(b"alpm_dep_compute_string\0")
            .map(|sym| *sym)?;
        let alpm_dep_from_string = __library.get(b"alpm_dep_from_string\0").map(|sym| *sym)?;
        let alpm_dep_free = __library.get(b"alpm_dep_free\0").map(|sym| *sym)?;
        let alpm_fileconflict_free = __library.get(b"alpm_fileconflict_free\0").map(|sym| *sym)?;
        let alpm_depmissing_free = __library.get(b"alpm_depmissing_free\0").map(|sym| *sym)?;
        let alpm_conflict_free = __library.get(b"alpm_conflict_free\0").map(|sym| *sym)?;
        let alpm_get_localdb = __library.get(b"alpm_get_localdb\0").map(|sym| *sym)?;
        let alpm_get_syncdbs = __library.get(b"alpm_get_syncdbs\0").map(|sym| *sym)?;
        let alpm_register_syncdb = __library.get(b"alpm_register_syncdb\0").map(|sym| *sym)?;
        let alpm_unregister_all_syncdbs = __library
            .get(b"alpm_unregister_all_syncdbs\0")
            .map(|sym| *sym)?;
        let alpm_db_unregister = __library.get(b"alpm_db_unregister\0").map(|sym| *sym)?;
        let alpm_db_get_name = __library.get(b"alpm_db_get_name\0").map(|sym| *sym)?;
        let alpm_db_get_siglevel = __library.get(b"alpm_db_get_siglevel\0").map(|sym| *sym)?;
        let alpm_db_get_valid = __library.get(b"alpm_db_get_valid\0").map(|sym| *sym)?;
        let alpm_db_get_servers = __library.get(b"alpm_db_get_servers\0").map(|sym| *sym)?;
        let alpm_db_set_servers = __library.get(b"alpm_db_set_servers\0").map(|sym| *sym)?;
        let alpm_db_add_server = __library.get(b"alpm_db_add_server\0").map(|sym| *sym)?;
        let alpm_db_remove_server = __library.get(b"alpm_db_remove_server\0").map(|sym| *sym)?;
        let alpm_db_update = __library.get(b"alpm_db_update\0").map(|sym| *sym)?;
        let alpm_db_get_pkg = __library.get(b"alpm_db_get_pkg\0").map(|sym| *sym)?;
        let alpm_db_get_pkgcache = __library.get(b"alpm_db_get_pkgcache\0").map(|sym| *sym)?;
        let alpm_db_get_group = __library.get(b"alpm_db_get_group\0").map(|sym| *sym)?;
        let alpm_db_get_groupcache = __library.get(b"alpm_db_get_groupcache\0").map(|sym| *sym)?;
        let alpm_db_search = __library.get(b"alpm_db_search\0").map(|sym| *sym)?;
        let alpm_db_set_usage = __library.get(b"alpm_db_set_usage\0").map(|sym| *sym)?;
        let alpm_db_get_usage = __library.get(b"alpm_db_get_usage\0").map(|sym| *sym)?;
        let alpm_logaction = __library.get(b"alpm_logaction\0").map(|sym| *sym)?;
        let alpm_option_get_logcb = __library.get(b"alpm_option_get_logcb\0").map(|sym| *sym)?;
        let alpm_option_get_logcb_ctx = __library
            .get(b"alpm_option_get_logcb_ctx\0")
            .map(|sym| *sym)?;
        let alpm_option_set_logcb = __library.get(b"alpm_option_set_logcb\0").map(|sym| *sym)?;
        let alpm_option_get_dlcb = __library.get(b"alpm_option_get_dlcb\0").map(|sym| *sym)?;
        let alpm_option_get_dlcb_ctx = __library
            .get(b"alpm_option_get_dlcb_ctx\0")
            .map(|sym| *sym)?;
        let alpm_option_set_dlcb = __library.get(b"alpm_option_set_dlcb\0").map(|sym| *sym)?;
        let alpm_option_get_fetchcb = __library
            .get(b"alpm_option_get_fetchcb\0")
            .map(|sym| *sym)?;
        let alpm_option_get_fetchcb_ctx = __library
            .get(b"alpm_option_get_fetchcb_ctx\0")
            .map(|sym| *sym)?;
        let alpm_option_set_fetchcb = __library
            .get(b"alpm_option_set_fetchcb\0")
            .map(|sym| *sym)?;
        let alpm_option_get_eventcb = __library
            .get(b"alpm_option_get_eventcb\0")
            .map(|sym| *sym)?;
        let alpm_option_get_eventcb_ctx = __library
            .get(b"alpm_option_get_eventcb_ctx\0")
            .map(|sym| *sym)?;
        let alpm_option_set_eventcb = __library
            .get(b"alpm_option_set_eventcb\0")
            .map(|sym| *sym)?;
        let alpm_option_get_questioncb = __library
            .get(b"alpm_option_get_questioncb\0")
            .map(|sym| *sym)?;
        let alpm_option_get_questioncb_ctx = __library
            .get(b"alpm_option_get_questioncb_ctx\0")
            .map(|sym| *sym)?;
        let alpm_option_set_questioncb = __library
            .get(b"alpm_option_set_questioncb\0")
            .map(|sym| *sym)?;
        let alpm_option_get_progresscb = __library
            .get(b"alpm_option_get_progresscb\0")
            .map(|sym| *sym)?;
        let alpm_option_get_progresscb_ctx = __library
            .get(b"alpm_option_get_progresscb_ctx\0")
            .map(|sym| *sym)?;
        let alpm_option_set_progresscb = __library
            .get(b"alpm_option_set_progresscb\0")
            .map(|sym| *sym)?;
        let alpm_option_get_root = __library.get(b"alpm_option_get_root\0").map(|sym| *sym)?;
        let alpm_option_get_dbpath = __library.get(b"alpm_option_get_dbpath\0").map(|sym| *sym)?;
        let alpm_option_get_lockfile = __library
            .get(b"alpm_option_get_lockfile\0")
            .map(|sym| *sym)?;
        let alpm_option_get_cachedirs = __library
            .get(b"alpm_option_get_cachedirs\0")
            .map(|sym| *sym)?;
        let alpm_option_set_cachedirs = __library
            .get(b"alpm_option_set_cachedirs\0")
            .map(|sym| *sym)?;
        let alpm_option_add_cachedir = __library
            .get(b"alpm_option_add_cachedir\0")
            .map(|sym| *sym)?;
        let alpm_option_remove_cachedir = __library
            .get(b"alpm_option_remove_cachedir\0")
            .map(|sym| *sym)?;
        let alpm_option_get_hookdirs = __library
            .get(b"alpm_option_get_hookdirs\0")
            .map(|sym| *sym)?;
        let alpm_option_set_hookdirs = __library
            .get(b"alpm_option_set_hookdirs\0")
            .map(|sym| *sym)?;
        let alpm_option_add_hookdir = __library
            .get(b"alpm_option_add_hookdir\0")
            .map(|sym| *sym)?;
        let alpm_option_remove_hookdir = __library
            .get(b"alpm_option_remove_hookdir\0")
            .map(|sym| *sym)?;
        let alpm_option_get_overwrite_files = __library
            .get(b"alpm_option_get_overwrite_files\0")
            .map(|sym| *sym)?;
        let alpm_option_set_overwrite_files = __library
            .get(b"alpm_option_set_overwrite_files\0")
            .map(|sym| *sym)?;
        let alpm_option_add_overwrite_file = __library
            .get(b"alpm_option_add_overwrite_file\0")
            .map(|sym| *sym)?;
        let alpm_option_remove_overwrite_file = __library
            .get(b"alpm_option_remove_overwrite_file\0")
            .map(|sym| *sym)?;
        let alpm_option_get_logfile = __library
            .get(b"alpm_option_get_logfile\0")
            .map(|sym| *sym)?;
        let alpm_option_set_logfile = __library
            .get(b"alpm_option_set_logfile\0")
            .map(|sym| *sym)?;
        let alpm_option_get_gpgdir = __library.get(b"alpm_option_get_gpgdir\0").map(|sym| *sym)?;
        let alpm_option_set_gpgdir = __library.get(b"alpm_option_set_gpgdir\0").map(|sym| *sym)?;
        let alpm_option_get_usesyslog = __library
            .get(b"alpm_option_get_usesyslog\0")
            .map(|sym| *sym)?;
        let alpm_option_set_usesyslog = __library
            .get(b"alpm_option_set_usesyslog\0")
            .map(|sym| *sym)?;
        let alpm_option_get_noupgrades = __library
            .get(b"alpm_option_get_noupgrades\0")
            .map(|sym| *sym)?;
        let alpm_option_add_noupgrade = __library
            .get(b"alpm_option_add_noupgrade\0")
            .map(|sym| *sym)?;
        let alpm_option_set_noupgrades = __library
            .get(b"alpm_option_set_noupgrades\0")
            .map(|sym| *sym)?;
        let alpm_option_remove_noupgrade = __library
            .get(b"alpm_option_remove_noupgrade\0")
            .map(|sym| *sym)?;
        let alpm_option_match_noupgrade = __library
            .get(b"alpm_option_match_noupgrade\0")
            .map(|sym| *sym)?;
        let alpm_option_get_noextracts = __library
            .get(b"alpm_option_get_noextracts\0")
            .map(|sym| *sym)?;
        let alpm_option_add_noextract = __library
            .get(b"alpm_option_add_noextract\0")
            .map(|sym| *sym)?;
        let alpm_option_set_noextracts = __library
            .get(b"alpm_option_set_noextracts\0")
            .map(|sym| *sym)?;
        let alpm_option_remove_noextract = __library
            .get(b"alpm_option_remove_noextract\0")
            .map(|sym| *sym)?;
        let alpm_option_match_noextract = __library
            .get(b"alpm_option_match_noextract\0")
            .map(|sym| *sym)?;
        let alpm_option_get_ignorepkgs = __library
            .get(b"alpm_option_get_ignorepkgs\0")
            .map(|sym| *sym)?;
        let alpm_option_add_ignorepkg = __library
            .get(b"alpm_option_add_ignorepkg\0")
            .map(|sym| *sym)?;
        let alpm_option_set_ignorepkgs = __library
            .get(b"alpm_option_set_ignorepkgs\0")
            .map(|sym| *sym)?;
        let alpm_option_remove_ignorepkg = __library
            .get(b"alpm_option_remove_ignorepkg\0")
            .map(|sym| *sym)?;
        let alpm_option_get_ignoregroups = __library
            .get(b"alpm_option_get_ignoregroups\0")
            .map(|sym| *sym)?;
        let alpm_option_add_ignoregroup = __library
            .get(b"alpm_option_add_ignoregroup\0")
            .map(|sym| *sym)?;
        let alpm_option_set_ignoregroups = __library
            .get(b"alpm_option_set_ignoregroups\0")
            .map(|sym| *sym)?;
        let alpm_option_remove_ignoregroup = __library
            .get(b"alpm_option_remove_ignoregroup\0")
            .map(|sym| *sym)?;
        let alpm_option_get_assumeinstalled = __library
            .get(b"alpm_option_get_assumeinstalled\0")
            .map(|sym| *sym)?;
        let alpm_option_add_assumeinstalled = __library
            .get(b"alpm_option_add_assumeinstalled\0")
            .map(|sym| *sym)?;
        let alpm_option_set_assumeinstalled = __library
            .get(b"alpm_option_set_assumeinstalled\0")
            .map(|sym| *sym)?;
        let alpm_option_remove_assumeinstalled = __library
            .get(b"alpm_option_remove_assumeinstalled\0")
            .map(|sym| *sym)?;
        let alpm_option_get_architectures = __library
            .get(b"alpm_option_get_architectures\0")
            .map(|sym| *sym)?;
        let alpm_option_add_architecture = __library
            .get(b"alpm_option_add_architecture\0")
            .map(|sym| *sym)?;
        let alpm_option_set_architectures = __library
            .get(b"alpm_option_set_architectures\0")
            .map(|sym| *sym)?;
        let alpm_option_remove_architecture = __library
            .get(b"alpm_option_remove_architecture\0")
            .map(|sym| *sym)?;
        let alpm_option_get_checkspace = __library
            .get(b"alpm_option_get_checkspace\0")
            .map(|sym| *sym)?;
        let alpm_option_set_checkspace = __library
            .get(b"alpm_option_set_checkspace\0")
            .map(|sym| *sym)?;
        let alpm_option_get_dbext = __library.get(b"alpm_option_get_dbext\0").map(|sym| *sym)?;
        let alpm_option_set_dbext = __library.get(b"alpm_option_set_dbext\0").map(|sym| *sym)?;
        let alpm_option_get_default_siglevel = __library
            .get(b"alpm_option_get_default_siglevel\0")
            .map(|sym| *sym)?;
        let alpm_option_set_default_siglevel = __library
            .get(b"alpm_option_set_default_siglevel\0")
            .map(|sym| *sym)?;
        let alpm_option_get_local_file_siglevel = __library
            .get(b"alpm_option_get_local_file_siglevel\0")
            .map(|sym| *sym)?;
        let alpm_option_set_local_file_siglevel = __library
            .get(b"alpm_option_set_local_file_siglevel\0")
            .map(|sym| *sym)?;
        let alpm_option_get_remote_file_siglevel = __library
            .get(b"alpm_option_get_remote_file_siglevel\0")
            .map(|sym| *sym)?;
        let alpm_option_set_remote_file_siglevel = __library
            .get(b"alpm_option_set_remote_file_siglevel\0")
            .map(|sym| *sym)?;
        let alpm_option_set_disable_dl_timeout = __library
            .get(b"alpm_option_set_disable_dl_timeout\0")
            .map(|sym| *sym)?;
        let alpm_option_get_parallel_downloads = __library
            .get(b"alpm_option_get_parallel_downloads\0")
            .map(|sym| *sym)?;
        let alpm_option_set_parallel_downloads = __library
            .get(b"alpm_option_set_parallel_downloads\0")
            .map(|sym| *sym)?;
        let alpm_pkg_load = __library.get(b"alpm_pkg_load\0").map(|sym| *sym)?;
        let alpm_fetch_pkgurl = __library.get(b"alpm_fetch_pkgurl\0").map(|sym| *sym)?;
        let alpm_pkg_find = __library.get(b"alpm_pkg_find\0").map(|sym| *sym)?;
        let alpm_pkg_free = __library.get(b"alpm_pkg_free\0").map(|sym| *sym)?;
        let alpm_pkg_checkmd5sum = __library.get(b"alpm_pkg_checkmd5sum\0").map(|sym| *sym)?;
        let alpm_pkg_vercmp = __library.get(b"alpm_pkg_vercmp\0").map(|sym| *sym)?;
        let alpm_pkg_compute_requiredby = __library
            .get(b"alpm_pkg_compute_requiredby\0")
            .map(|sym| *sym)?;
        let alpm_pkg_compute_optionalfor = __library
            .get(b"alpm_pkg_compute_optionalfor\0")
            .map(|sym| *sym)?;
        let alpm_pkg_should_ignore = __library.get(b"alpm_pkg_should_ignore\0").map(|sym| *sym)?;
        let alpm_pkg_get_filename = __library.get(b"alpm_pkg_get_filename\0").map(|sym| *sym)?;
        let alpm_pkg_get_base = __library.get(b"alpm_pkg_get_base\0").map(|sym| *sym)?;
        let alpm_pkg_get_name = __library.get(b"alpm_pkg_get_name\0").map(|sym| *sym)?;
        let alpm_pkg_get_version = __library.get(b"alpm_pkg_get_version\0").map(|sym| *sym)?;
        let alpm_pkg_get_origin = __library.get(b"alpm_pkg_get_origin\0").map(|sym| *sym)?;
        let alpm_pkg_get_desc = __library.get(b"alpm_pkg_get_desc\0").map(|sym| *sym)?;
        let alpm_pkg_get_url = __library.get(b"alpm_pkg_get_url\0").map(|sym| *sym)?;
        let alpm_pkg_get_builddate = __library.get(b"alpm_pkg_get_builddate\0").map(|sym| *sym)?;
        let alpm_pkg_get_installdate = __library
            .get(b"alpm_pkg_get_installdate\0")
            .map(|sym| *sym)?;
        let alpm_pkg_get_packager = __library.get(b"alpm_pkg_get_packager\0").map(|sym| *sym)?;
        let alpm_pkg_get_md5sum = __library.get(b"alpm_pkg_get_md5sum\0").map(|sym| *sym)?;
        let alpm_pkg_get_sha256sum = __library.get(b"alpm_pkg_get_sha256sum\0").map(|sym| *sym)?;
        let alpm_pkg_get_arch = __library.get(b"alpm_pkg_get_arch\0").map(|sym| *sym)?;
        let alpm_pkg_get_size = __library.get(b"alpm_pkg_get_size\0").map(|sym| *sym)?;
        let alpm_pkg_get_isize = __library.get(b"alpm_pkg_get_isize\0").map(|sym| *sym)?;
        let alpm_pkg_get_reason = __library.get(b"alpm_pkg_get_reason\0").map(|sym| *sym)?;
        let alpm_pkg_get_licenses = __library.get(b"alpm_pkg_get_licenses\0").map(|sym| *sym)?;
        let alpm_pkg_get_groups = __library.get(b"alpm_pkg_get_groups\0").map(|sym| *sym)?;
        let alpm_pkg_get_depends = __library.get(b"alpm_pkg_get_depends\0").map(|sym| *sym)?;
        let alpm_pkg_get_optdepends = __library
            .get(b"alpm_pkg_get_optdepends\0")
            .map(|sym| *sym)?;
        let alpm_pkg_get_checkdepends = __library
            .get(b"alpm_pkg_get_checkdepends\0")
            .map(|sym| *sym)?;
        let alpm_pkg_get_makedepends = __library
            .get(b"alpm_pkg_get_makedepends\0")
            .map(|sym| *sym)?;
        let alpm_pkg_get_conflicts = __library.get(b"alpm_pkg_get_conflicts\0").map(|sym| *sym)?;
        let alpm_pkg_get_provides = __library.get(b"alpm_pkg_get_provides\0").map(|sym| *sym)?;
        let alpm_pkg_get_replaces = __library.get(b"alpm_pkg_get_replaces\0").map(|sym| *sym)?;
        let alpm_pkg_get_files = __library.get(b"alpm_pkg_get_files\0").map(|sym| *sym)?;
        let alpm_pkg_get_backup = __library.get(b"alpm_pkg_get_backup\0").map(|sym| *sym)?;
        let alpm_pkg_get_db = __library.get(b"alpm_pkg_get_db\0").map(|sym| *sym)?;
        let alpm_pkg_get_base64_sig = __library
            .get(b"alpm_pkg_get_base64_sig\0")
            .map(|sym| *sym)?;
        let alpm_pkg_get_sig = __library.get(b"alpm_pkg_get_sig\0").map(|sym| *sym)?;
        let alpm_pkg_get_validation = __library
            .get(b"alpm_pkg_get_validation\0")
            .map(|sym| *sym)?;
        let alpm_pkg_has_scriptlet = __library.get(b"alpm_pkg_has_scriptlet\0").map(|sym| *sym)?;
        let alpm_pkg_download_size = __library.get(b"alpm_pkg_download_size\0").map(|sym| *sym)?;
        let alpm_pkg_set_reason = __library.get(b"alpm_pkg_set_reason\0").map(|sym| *sym)?;
        let alpm_pkg_changelog_open = __library
            .get(b"alpm_pkg_changelog_open\0")
            .map(|sym| *sym)?;
        let alpm_pkg_changelog_read = __library
            .get(b"alpm_pkg_changelog_read\0")
            .map(|sym| *sym)?;
        let alpm_pkg_changelog_close = __library
            .get(b"alpm_pkg_changelog_close\0")
            .map(|sym| *sym)?;
        let alpm_pkg_mtree_open = __library.get(b"alpm_pkg_mtree_open\0").map(|sym| *sym)?;
        let alpm_pkg_mtree_next = __library.get(b"alpm_pkg_mtree_next\0").map(|sym| *sym)?;
        let alpm_pkg_mtree_close = __library.get(b"alpm_pkg_mtree_close\0").map(|sym| *sym)?;
        let alpm_trans_get_flags = __library.get(b"alpm_trans_get_flags\0").map(|sym| *sym)?;
        let alpm_trans_get_add = __library.get(b"alpm_trans_get_add\0").map(|sym| *sym)?;
        let alpm_trans_get_remove = __library.get(b"alpm_trans_get_remove\0").map(|sym| *sym)?;
        let alpm_trans_init = __library.get(b"alpm_trans_init\0").map(|sym| *sym)?;
        let alpm_trans_prepare = __library.get(b"alpm_trans_prepare\0").map(|sym| *sym)?;
        let alpm_trans_commit = __library.get(b"alpm_trans_commit\0").map(|sym| *sym)?;
        let alpm_trans_interrupt = __library.get(b"alpm_trans_interrupt\0").map(|sym| *sym)?;
        let alpm_trans_release = __library.get(b"alpm_trans_release\0").map(|sym| *sym)?;
        let alpm_sync_sysupgrade = __library.get(b"alpm_sync_sysupgrade\0").map(|sym| *sym)?;
        let alpm_add_pkg = __library.get(b"alpm_add_pkg\0").map(|sym| *sym)?;
        let alpm_remove_pkg = __library.get(b"alpm_remove_pkg\0").map(|sym| *sym)?;
        let alpm_sync_get_new_version = __library
            .get(b"alpm_sync_get_new_version\0")
            .map(|sym| *sym)?;
        let alpm_compute_md5sum = __library.get(b"alpm_compute_md5sum\0").map(|sym| *sym)?;
        let alpm_compute_sha256sum = __library.get(b"alpm_compute_sha256sum\0").map(|sym| *sym)?;
        let alpm_unlock = __library.get(b"alpm_unlock\0").map(|sym| *sym)?;
        let alpm_version = __library.get(b"alpm_version\0").map(|sym| *sym)?;
        let alpm_capabilities = __library.get(b"alpm_capabilities\0").map(|sym| *sym)?;
        Ok(libalpm {
            __library,
            alpm_list_free,
            alpm_list_free_inner,
            alpm_list_add,
            alpm_list_append,
            alpm_list_append_strdup,
            alpm_list_add_sorted,
            alpm_list_join,
            alpm_list_mmerge,
            alpm_list_msort,
            alpm_list_remove_item,
            alpm_list_remove,
            alpm_list_remove_str,
            alpm_list_remove_dupes,
            alpm_list_strdup,
            alpm_list_copy,
            alpm_list_copy_data,
            alpm_list_reverse,
            alpm_list_nth,
            alpm_list_next,
            alpm_list_previous,
            alpm_list_last,
            alpm_list_count,
            alpm_list_find,
            alpm_list_find_ptr,
            alpm_list_find_str,
            alpm_list_diff_sorted,
            alpm_list_diff,
            alpm_list_to_array,
            alpm_filelist_contains,
            alpm_find_group_pkgs,
            alpm_errno,
            alpm_strerror,
            alpm_initialize,
            alpm_release,
            alpm_pkg_check_pgp_signature,
            alpm_db_check_pgp_signature,
            alpm_siglist_cleanup,
            alpm_decode_signature,
            alpm_extract_keyid,
            alpm_checkdeps,
            alpm_find_satisfier,
            alpm_find_dbs_satisfier,
            alpm_checkconflicts,
            alpm_dep_compute_string,
            alpm_dep_from_string,
            alpm_dep_free,
            alpm_fileconflict_free,
            alpm_depmissing_free,
            alpm_conflict_free,
            alpm_get_localdb,
            alpm_get_syncdbs,
            alpm_register_syncdb,
            alpm_unregister_all_syncdbs,
            alpm_db_unregister,
            alpm_db_get_name,
            alpm_db_get_siglevel,
            alpm_db_get_valid,
            alpm_db_get_servers,
            alpm_db_set_servers,
            alpm_db_add_server,
            alpm_db_remove_server,
            alpm_db_update,
            alpm_db_get_pkg,
            alpm_db_get_pkgcache,
            alpm_db_get_group,
            alpm_db_get_groupcache,
            alpm_db_search,
            alpm_db_set_usage,
            alpm_db_get_usage,
            alpm_logaction,
            alpm_option_get_logcb,
            alpm_option_get_logcb_ctx,
            alpm_option_set_logcb,
            alpm_option_get_dlcb,
            alpm_option_get_dlcb_ctx,
            alpm_option_set_dlcb,
            alpm_option_get_fetchcb,
            alpm_option_get_fetchcb_ctx,
            alpm_option_set_fetchcb,
            alpm_option_get_eventcb,
            alpm_option_get_eventcb_ctx,
            alpm_option_set_eventcb,
            alpm_option_get_questioncb,
            alpm_option_get_questioncb_ctx,
            alpm_option_set_questioncb,
            alpm_option_get_progresscb,
            alpm_option_get_progresscb_ctx,
            alpm_option_set_progresscb,
            alpm_option_get_root,
            alpm_option_get_dbpath,
            alpm_option_get_lockfile,
            alpm_option_get_cachedirs,
            alpm_option_set_cachedirs,
            alpm_option_add_cachedir,
            alpm_option_remove_cachedir,
            alpm_option_get_hookdirs,
            alpm_option_set_hookdirs,
            alpm_option_add_hookdir,
            alpm_option_remove_hookdir,
            alpm_option_get_overwrite_files,
            alpm_option_set_overwrite_files,
            alpm_option_add_overwrite_file,
            alpm_option_remove_overwrite_file,
            alpm_option_get_logfile,
            alpm_option_set_logfile,
            alpm_option_get_gpgdir,
            alpm_option_set_gpgdir,
            alpm_option_get_usesyslog,
            alpm_option_set_usesyslog,
            alpm_option_get_noupgrades,
            alpm_option_add_noupgrade,
            alpm_option_set_noupgrades,
            alpm_option_remove_noupgrade,
            alpm_option_match_noupgrade,
            alpm_option_get_noextracts,
            alpm_option_add_noextract,
            alpm_option_set_noextracts,
            alpm_option_remove_noextract,
            alpm_option_match_noextract,
            alpm_option_get_ignorepkgs,
            alpm_option_add_ignorepkg,
            alpm_option_set_ignorepkgs,
            alpm_option_remove_ignorepkg,
            alpm_option_get_ignoregroups,
            alpm_option_add_ignoregroup,
            alpm_option_set_ignoregroups,
            alpm_option_remove_ignoregroup,
            alpm_option_get_assumeinstalled,
            alpm_option_add_assumeinstalled,
            alpm_option_set_assumeinstalled,
            alpm_option_remove_assumeinstalled,
            alpm_option_get_architectures,
            alpm_option_add_architecture,
            alpm_option_set_architectures,
            alpm_option_remove_architecture,
            alpm_option_get_checkspace,
            alpm_option_set_checkspace,
            alpm_option_get_dbext,
            alpm_option_set_dbext,
            alpm_option_get_default_siglevel,
            alpm_option_set_default_siglevel,
            alpm_option_get_local_file_siglevel,
            alpm_option_set_local_file_siglevel,
            alpm_option_get_remote_file_siglevel,
            alpm_option_set_remote_file_siglevel,
            alpm_option_set_disable_dl_timeout,
            alpm_option_get_parallel_downloads,
            alpm_option_set_parallel_downloads,
            alpm_pkg_load,
            alpm_fetch_pkgurl,
            alpm_pkg_find,
            alpm_pkg_free,
            alpm_pkg_checkmd5sum,
            alpm_pkg_vercmp,
            alpm_pkg_compute_requiredby,
            alpm_pkg_compute_optionalfor,
            alpm_pkg_should_ignore,
            alpm_pkg_get_filename,
            alpm_pkg_get_base,
            alpm_pkg_get_name,
            alpm_pkg_get_version,
            alpm_pkg_get_origin,
            alpm_pkg_get_desc,
            alpm_pkg_get_url,
            alpm_pkg_get_builddate,
            alpm_pkg_get_installdate,
            alpm_pkg_get_packager,
            alpm_pkg_get_md5sum,
            alpm_pkg_get_sha256sum,
            alpm_pkg_get_arch,
            alpm_pkg_get_size,
            alpm_pkg_get_isize,
            alpm_pkg_get_reason,
            alpm_pkg_get_licenses,
            alpm_pkg_get_groups,
            alpm_pkg_get_depends,
            alpm_pkg_get_optdepends,
            alpm_pkg_get_checkdepends,
            alpm_pkg_get_makedepends,
            alpm_pkg_get_conflicts,
            alpm_pkg_get_provides,
            alpm_pkg_get_replaces,
            alpm_pkg_get_files,
            alpm_pkg_get_backup,
            alpm_pkg_get_db,
            alpm_pkg_get_base64_sig,
            alpm_pkg_get_sig,
            alpm_pkg_get_validation,
            alpm_pkg_has_scriptlet,
            alpm_pkg_download_size,
            alpm_pkg_set_reason,
            alpm_pkg_changelog_open,
            alpm_pkg_changelog_read,
            alpm_pkg_changelog_close,
            alpm_pkg_mtree_open,
            alpm_pkg_mtree_next,
            alpm_pkg_mtree_close,
            alpm_trans_get_flags,
            alpm_trans_get_add,
            alpm_trans_get_remove,
            alpm_trans_init,
            alpm_trans_prepare,
            alpm_trans_commit,
            alpm_trans_interrupt,
            alpm_trans_release,
            alpm_sync_sysupgrade,
            alpm_add_pkg,
            alpm_remove_pkg,
            alpm_sync_get_new_version,
            alpm_compute_md5sum,
            alpm_compute_sha256sum,
            alpm_unlock,
            alpm_version,
            alpm_capabilities,
        })
    }
    pub unsafe fn alpm_list_free(&self, list: *mut alpm_list_t) -> () {
        (self.alpm_list_free)(list)
    }
    pub unsafe fn alpm_list_free_inner(
        &self,
        list: *mut alpm_list_t,
        fn_: alpm_list_fn_free,
    ) -> () {
        (self.alpm_list_free_inner)(list, fn_)
    }
    pub unsafe fn alpm_list_add(
        &self,
        list: *mut alpm_list_t,
        data: *mut ::std::os::raw::c_void,
    ) -> *mut alpm_list_t {
        (self.alpm_list_add)(list, data)
    }
    pub unsafe fn alpm_list_append(
        &self,
        list: *mut *mut alpm_list_t,
        data: *mut ::std::os::raw::c_void,
    ) -> *mut alpm_list_t {
        (self.alpm_list_append)(list, data)
    }
    pub unsafe fn alpm_list_append_strdup(
        &self,
        list: *mut *mut alpm_list_t,
        data: *const ::std::os::raw::c_char,
    ) -> *mut alpm_list_t {
        (self.alpm_list_append_strdup)(list, data)
    }
    pub unsafe fn alpm_list_add_sorted(
        &self,
        list: *mut alpm_list_t,
        data: *mut ::std::os::raw::c_void,
        fn_: alpm_list_fn_cmp,
    ) -> *mut alpm_list_t {
        (self.alpm_list_add_sorted)(list, data, fn_)
    }
    pub unsafe fn alpm_list_join(
        &self,
        first: *mut alpm_list_t,
        second: *mut alpm_list_t,
    ) -> *mut alpm_list_t {
        (self.alpm_list_join)(first, second)
    }
    pub unsafe fn alpm_list_mmerge(
        &self,
        left: *mut alpm_list_t,
        right: *mut alpm_list_t,
        fn_: alpm_list_fn_cmp,
    ) -> *mut alpm_list_t {
        (self.alpm_list_mmerge)(left, right, fn_)
    }
    pub unsafe fn alpm_list_msort(
        &self,
        list: *mut alpm_list_t,
        n: usize,
        fn_: alpm_list_fn_cmp,
    ) -> *mut alpm_list_t {
        (self.alpm_list_msort)(list, n, fn_)
    }
    pub unsafe fn alpm_list_remove_item(
        &self,
        haystack: *mut alpm_list_t,
        item: *mut alpm_list_t,
    ) -> *mut alpm_list_t {
        (self.alpm_list_remove_item)(haystack, item)
    }
    pub unsafe fn alpm_list_remove(
        &self,
        haystack: *mut alpm_list_t,
        needle: *const ::std::os::raw::c_void,
        fn_: alpm_list_fn_cmp,
        data: *mut *mut ::std::os::raw::c_void,
    ) -> *mut alpm_list_t {
        (self.alpm_list_remove)(haystack, needle, fn_, data)
    }
    pub unsafe fn alpm_list_remove_str(
        &self,
        haystack: *mut alpm_list_t,
        needle: *const ::std::os::raw::c_char,
        data: *mut *mut ::std::os::raw::c_char,
    ) -> *mut alpm_list_t {
        (self.alpm_list_remove_str)(haystack, needle, data)
    }
    pub unsafe fn alpm_list_remove_dupes(&self, list: *const alpm_list_t) -> *mut alpm_list_t {
        (self.alpm_list_remove_dupes)(list)
    }
    pub unsafe fn alpm_list_strdup(&self, list: *const alpm_list_t) -> *mut alpm_list_t {
        (self.alpm_list_strdup)(list)
    }
    pub unsafe fn alpm_list_copy(&self, list: *const alpm_list_t) -> *mut alpm_list_t {
        (self.alpm_list_copy)(list)
    }
    pub unsafe fn alpm_list_copy_data(
        &self,
        list: *const alpm_list_t,
        size: usize,
    ) -> *mut alpm_list_t {
        (self.alpm_list_copy_data)(list, size)
    }
    pub unsafe fn alpm_list_reverse(&self, list: *mut alpm_list_t) -> *mut alpm_list_t {
        (self.alpm_list_reverse)(list)
    }
    pub unsafe fn alpm_list_nth(&self, list: *const alpm_list_t, n: usize) -> *mut alpm_list_t {
        (self.alpm_list_nth)(list, n)
    }
    pub unsafe fn alpm_list_next(&self, list: *const alpm_list_t) -> *mut alpm_list_t {
        (self.alpm_list_next)(list)
    }
    pub unsafe fn alpm_list_previous(&self, list: *const alpm_list_t) -> *mut alpm_list_t {
        (self.alpm_list_previous)(list)
    }
    pub unsafe fn alpm_list_last(&self, list: *const alpm_list_t) -> *mut alpm_list_t {
        (self.alpm_list_last)(list)
    }
    pub unsafe fn alpm_list_count(&self, list: *const alpm_list_t) -> usize {
        (self.alpm_list_count)(list)
    }
    pub unsafe fn alpm_list_find(
        &self,
        haystack: *const alpm_list_t,
        needle: *const ::std::os::raw::c_void,
        fn_: alpm_list_fn_cmp,
    ) -> *mut ::std::os::raw::c_void {
        (self.alpm_list_find)(haystack, needle, fn_)
    }
    pub unsafe fn alpm_list_find_ptr(
        &self,
        haystack: *const alpm_list_t,
        needle: *const ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void {
        (self.alpm_list_find_ptr)(haystack, needle)
    }
    pub unsafe fn alpm_list_find_str(
        &self,
        haystack: *const alpm_list_t,
        needle: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char {
        (self.alpm_list_find_str)(haystack, needle)
    }
    pub unsafe fn alpm_list_diff_sorted(
        &self,
        left: *const alpm_list_t,
        right: *const alpm_list_t,
        fn_: alpm_list_fn_cmp,
        onlyleft: *mut *mut alpm_list_t,
        onlyright: *mut *mut alpm_list_t,
    ) -> () {
        (self.alpm_list_diff_sorted)(left, right, fn_, onlyleft, onlyright)
    }
    pub unsafe fn alpm_list_diff(
        &self,
        lhs: *const alpm_list_t,
        rhs: *const alpm_list_t,
        fn_: alpm_list_fn_cmp,
    ) -> *mut alpm_list_t {
        (self.alpm_list_diff)(lhs, rhs, fn_)
    }
    pub unsafe fn alpm_list_to_array(
        &self,
        list: *const alpm_list_t,
        n: usize,
        size: usize,
    ) -> *mut ::std::os::raw::c_void {
        (self.alpm_list_to_array)(list, n, size)
    }
    #[doc = " Determines whether a package filelist contains a given path."]
    #[doc = " The provided path should be relative to the install root with no leading"]
    #[doc = " slashes, e.g. \"etc/localtime\". When searching for directories, the path must"]
    #[doc = " have a trailing slash."]
    #[doc = " @param filelist a pointer to a package filelist"]
    #[doc = " @param path the path to search for in the package"]
    #[doc = " @return a pointer to the matching file or NULL if not found"]
    pub unsafe fn alpm_filelist_contains(
        &self,
        filelist: *mut alpm_filelist_t,
        path: *const ::std::os::raw::c_char,
    ) -> *mut alpm_file_t {
        (self.alpm_filelist_contains)(filelist, path)
    }
    #[doc = " Find group members across a list of databases."]
    #[doc = " If a member exists in several databases, only the first database is used."]
    #[doc = " IgnorePkg is also handled."]
    #[doc = " @param dbs the list of alpm_db_t *"]
    #[doc = " @param name the name of the group"]
    #[doc = " @return the list of alpm_pkg_t * (caller is responsible for alpm_list_free)"]
    pub unsafe fn alpm_find_group_pkgs(
        &self,
        dbs: *mut alpm_list_t,
        name: *const ::std::os::raw::c_char,
    ) -> *mut alpm_list_t {
        (self.alpm_find_group_pkgs)(dbs, name)
    }
    #[doc = " Returns the current error code from the handle."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the current error code of the handle"]
    pub unsafe fn alpm_errno(&self, handle: *mut alpm_handle_t) -> alpm_errno_t {
        (self.alpm_errno)(handle)
    }
    #[doc = " Returns the string corresponding to an error number."]
    #[doc = " @param err the error code to get the string for"]
    #[doc = " @return the string relating to the given error code"]
    pub unsafe fn alpm_strerror(&self, err: alpm_errno_t) -> *const ::std::os::raw::c_char {
        (self.alpm_strerror)(err)
    }
    #[doc = " Initializes the library."]
    #[doc = " Creates handle, connects to database and creates lockfile."]
    #[doc = " This must be called before any other functions are called."]
    #[doc = " @param root the root path for all filesystem operations"]
    #[doc = " @param dbpath the absolute path to the libalpm database"]
    #[doc = " @param err an optional variable to hold any error return codes"]
    #[doc = " @return a context handle on success, NULL on error, err will be set if provided"]
    pub unsafe fn alpm_initialize(
        &self,
        root: *const ::std::os::raw::c_char,
        dbpath: *const ::std::os::raw::c_char,
        err: *mut alpm_errno_t,
    ) -> *mut alpm_handle_t {
        (self.alpm_initialize)(root, dbpath, err)
    }
    #[doc = " Release the library."]
    #[doc = " Disconnects from the database, removes handle and lockfile"]
    #[doc = " This should be the last alpm call you make."]
    #[doc = " After this returns, handle should be considered invalid and cannot be reused"]
    #[doc = " in any way."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return 0 on success, -1 on error"]
    pub unsafe fn alpm_release(&self, handle: *mut alpm_handle_t) -> ::std::os::raw::c_int {
        (self.alpm_release)(handle)
    }
    #[doc = " Check the PGP signature for the given package file."]
    #[doc = " @param pkg the package to check"]
    #[doc = " @param siglist a pointer to storage for signature results"]
    #[doc = " @return a int value : 0 (valid), 1 (invalid), -1 (an error occurred)"]
    pub unsafe fn alpm_pkg_check_pgp_signature(
        &self,
        pkg: *mut alpm_pkg_t,
        siglist: *mut alpm_siglist_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_pkg_check_pgp_signature)(pkg, siglist)
    }
    #[doc = " Check the PGP signature for the given database."]
    #[doc = " @param db the database to check"]
    #[doc = " @param siglist a pointer to storage for signature results"]
    #[doc = " @return a int value : 0 (valid), 1 (invalid), -1 (an error occurred)"]
    pub unsafe fn alpm_db_check_pgp_signature(
        &self,
        db: *mut alpm_db_t,
        siglist: *mut alpm_siglist_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_db_check_pgp_signature)(db, siglist)
    }
    #[doc = " Clean up and free a signature result list."]
    #[doc = " Note that this does not free the siglist object itself in case that"]
    #[doc = " was allocated on the stack; this is the responsibility of the caller."]
    #[doc = " @param siglist a pointer to storage for signature results"]
    #[doc = " @return 0 on success, -1 on error"]
    pub unsafe fn alpm_siglist_cleanup(
        &self,
        siglist: *mut alpm_siglist_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_siglist_cleanup)(siglist)
    }
    #[doc = " Decode a loaded signature in base64 form."]
    #[doc = " @param base64_data the signature to attempt to decode"]
    #[doc = " @param data the decoded data; must be freed by the caller"]
    #[doc = " @param data_len the length of the returned data"]
    #[doc = " @return 0 on success, -1 on failure to properly decode"]
    pub unsafe fn alpm_decode_signature(
        &self,
        base64_data: *const ::std::os::raw::c_char,
        data: *mut *mut ::std::os::raw::c_uchar,
        data_len: *mut usize,
    ) -> ::std::os::raw::c_int {
        (self.alpm_decode_signature)(base64_data, data, data_len)
    }
    #[doc = " Extract the Issuer Key ID from a signature"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param identifier the identifier of the key."]
    #[doc = " This may be the name of the package or the path to the package."]
    #[doc = " @param sig PGP signature"]
    #[doc = " @param len length of signature"]
    #[doc = " @param keys a pointer to storage for key IDs"]
    #[doc = " @return 0 on success, -1 on error"]
    pub unsafe fn alpm_extract_keyid(
        &self,
        handle: *mut alpm_handle_t,
        identifier: *const ::std::os::raw::c_char,
        sig: *const ::std::os::raw::c_uchar,
        len: usize,
        keys: *mut *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_extract_keyid)(handle, identifier, sig, len, keys)
    }
    #[doc = " Checks dependencies and returns missing ones in a list."]
    #[doc = " Dependencies can include versions with depmod operators."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param pkglist the list of local packages"]
    #[doc = " @param remove an alpm_list_t* of packages to be removed"]
    #[doc = " @param upgrade an alpm_list_t* of packages to be upgraded (remove-then-upgrade)"]
    #[doc = " @param reversedeps handles the backward dependencies"]
    #[doc = " @return an alpm_list_t* of alpm_depmissing_t pointers."]
    pub unsafe fn alpm_checkdeps(
        &self,
        handle: *mut alpm_handle_t,
        pkglist: *mut alpm_list_t,
        remove: *mut alpm_list_t,
        upgrade: *mut alpm_list_t,
        reversedeps: ::std::os::raw::c_int,
    ) -> *mut alpm_list_t {
        (self.alpm_checkdeps)(handle, pkglist, remove, upgrade, reversedeps)
    }
    #[doc = " Find a package satisfying a specified dependency."]
    #[doc = " The dependency can include versions with depmod operators."]
    #[doc = " @param pkgs an alpm_list_t* of alpm_pkg_t where the satisfyer will be searched"]
    #[doc = " @param depstring package or provision name, versioned or not"]
    #[doc = " @return a alpm_pkg_t* satisfying depstring"]
    pub unsafe fn alpm_find_satisfier(
        &self,
        pkgs: *mut alpm_list_t,
        depstring: *const ::std::os::raw::c_char,
    ) -> *mut alpm_pkg_t {
        (self.alpm_find_satisfier)(pkgs, depstring)
    }
    #[doc = " Find a package satisfying a specified dependency."]
    #[doc = " First look for a literal, going through each db one by one. Then look for"]
    #[doc = " providers. The first satisfyer that belongs to an installed package is"]
    #[doc = " returned. If no providers belong to an installed package then an"]
    #[doc = " alpm_question_select_provider_t is created to select the provider."]
    #[doc = " The dependency can include versions with depmod operators."]
    #[doc = ""]
    #[doc = " @param handle the context handle"]
    #[doc = " @param dbs an alpm_list_t* of alpm_db_t where the satisfyer will be searched"]
    #[doc = " @param depstring package or provision name, versioned or not"]
    #[doc = " @return a alpm_pkg_t* satisfying depstring"]
    pub unsafe fn alpm_find_dbs_satisfier(
        &self,
        handle: *mut alpm_handle_t,
        dbs: *mut alpm_list_t,
        depstring: *const ::std::os::raw::c_char,
    ) -> *mut alpm_pkg_t {
        (self.alpm_find_dbs_satisfier)(handle, dbs, depstring)
    }
    #[doc = " Check the package conflicts in a database"]
    #[doc = ""]
    #[doc = " @param handle the context handle"]
    #[doc = " @param pkglist the list of packages to check"]
    #[doc = ""]
    #[doc = " @return an alpm_list_t of alpm_conflict_t"]
    pub unsafe fn alpm_checkconflicts(
        &self,
        handle: *mut alpm_handle_t,
        pkglist: *mut alpm_list_t,
    ) -> *mut alpm_list_t {
        (self.alpm_checkconflicts)(handle, pkglist)
    }
    #[doc = " Returns a newly allocated string representing the dependency information."]
    #[doc = " @param dep a dependency info structure"]
    #[doc = " @return a formatted string, e.g. \"glibc>=2.12\""]
    pub unsafe fn alpm_dep_compute_string(
        &self,
        dep: *const alpm_depend_t,
    ) -> *mut ::std::os::raw::c_char {
        (self.alpm_dep_compute_string)(dep)
    }
    #[doc = " Return a newly allocated dependency information parsed from a string"]
    #[doc = "\\link alpm_dep_free should be used to free the dependency \\endlink"]
    #[doc = " @param depstring a formatted string, e.g. \"glibc=2.12\""]
    #[doc = " @return a dependency info structure"]
    pub unsafe fn alpm_dep_from_string(
        &self,
        depstring: *const ::std::os::raw::c_char,
    ) -> *mut alpm_depend_t {
        (self.alpm_dep_from_string)(depstring)
    }
    #[doc = " Free a dependency info structure"]
    #[doc = " @param dep struct to free"]
    pub unsafe fn alpm_dep_free(&self, dep: *mut alpm_depend_t) -> () {
        (self.alpm_dep_free)(dep)
    }
    #[doc = " Free a fileconflict and its members."]
    #[doc = " @param conflict the fileconflict to free"]
    pub unsafe fn alpm_fileconflict_free(&self, conflict: *mut alpm_fileconflict_t) -> () {
        (self.alpm_fileconflict_free)(conflict)
    }
    #[doc = " Free a depmissing and its members"]
    #[doc = " @param miss the depmissing to free"]
    pub unsafe fn alpm_depmissing_free(&self, miss: *mut alpm_depmissing_t) -> () {
        (self.alpm_depmissing_free)(miss)
    }
    #[doc = " Free a conflict and its members."]
    #[doc = " @param conflict the conflict to free"]
    pub unsafe fn alpm_conflict_free(&self, conflict: *mut alpm_conflict_t) -> () {
        (self.alpm_conflict_free)(conflict)
    }
    #[doc = " Get the database of locally installed packages."]
    #[doc = " The returned pointer points to an internal structure"]
    #[doc = " of libalpm which should only be manipulated through"]
    #[doc = " libalpm functions."]
    #[doc = " @return a reference to the local database"]
    pub unsafe fn alpm_get_localdb(&self, handle: *mut alpm_handle_t) -> *mut alpm_db_t {
        (self.alpm_get_localdb)(handle)
    }
    #[doc = " Get the list of sync databases."]
    #[doc = " Returns a list of alpm_db_t structures, one for each registered"]
    #[doc = " sync database."]
    #[doc = ""]
    #[doc = " @param handle the context handle"]
    #[doc = " @return a reference to an internal list of alpm_db_t structures"]
    pub unsafe fn alpm_get_syncdbs(&self, handle: *mut alpm_handle_t) -> *mut alpm_list_t {
        (self.alpm_get_syncdbs)(handle)
    }
    #[doc = " Register a sync database of packages."]
    #[doc = " Databases can not be registered when there is an active transaction."]
    #[doc = ""]
    #[doc = " @param handle the context handle"]
    #[doc = " @param treename the name of the sync repository"]
    #[doc = " @param level what level of signature checking to perform on the"]
    #[doc = " database; note that this must be a '.sig' file type verification"]
    #[doc = " @return an alpm_db_t* on success (the value), NULL on error"]
    pub unsafe fn alpm_register_syncdb(
        &self,
        handle: *mut alpm_handle_t,
        treename: *const ::std::os::raw::c_char,
        level: ::std::os::raw::c_int,
    ) -> *mut alpm_db_t {
        (self.alpm_register_syncdb)(handle, treename, level)
    }
    #[doc = " Unregister all package databases."]
    #[doc = " Databases can not be unregistered while there is an active transaction."]
    #[doc = ""]
    #[doc = " @param handle the context handle"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_unregister_all_syncdbs(
        &self,
        handle: *mut alpm_handle_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_unregister_all_syncdbs)(handle)
    }
    #[doc = " Unregister a package database."]
    #[doc = " Databases can not be unregistered when there is an active transaction."]
    #[doc = ""]
    #[doc = " @param db pointer to the package database to unregister"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_db_unregister(&self, db: *mut alpm_db_t) -> ::std::os::raw::c_int {
        (self.alpm_db_unregister)(db)
    }
    #[doc = " Get the name of a package database."]
    #[doc = " @param db pointer to the package database"]
    #[doc = " @return the name of the package database, NULL on error"]
    pub unsafe fn alpm_db_get_name(&self, db: *const alpm_db_t) -> *const ::std::os::raw::c_char {
        (self.alpm_db_get_name)(db)
    }
    #[doc = " Get the signature verification level for a database."]
    #[doc = " Will return the default verification level if this database is set up"]
    #[doc = " with ALPM_SIG_USE_DEFAULT."]
    #[doc = " @param db pointer to the package database"]
    #[doc = " @return the signature verification level"]
    pub unsafe fn alpm_db_get_siglevel(&self, db: *mut alpm_db_t) -> ::std::os::raw::c_int {
        (self.alpm_db_get_siglevel)(db)
    }
    #[doc = " Check the validity of a database."]
    #[doc = " This is most useful for sync databases and verifying signature status."]
    #[doc = " If invalid, the handle error code will be set accordingly."]
    #[doc = " @param db pointer to the package database"]
    #[doc = " @return 0 if valid, -1 if invalid (pm_errno is set accordingly)"]
    pub unsafe fn alpm_db_get_valid(&self, db: *mut alpm_db_t) -> ::std::os::raw::c_int {
        (self.alpm_db_get_valid)(db)
    }
    #[doc = " Get the list of servers assigned to this db."]
    #[doc = " @param db pointer to the database to get the servers from"]
    #[doc = " @return a char* list of servers"]
    pub unsafe fn alpm_db_get_servers(&self, db: *const alpm_db_t) -> *mut alpm_list_t {
        (self.alpm_db_get_servers)(db)
    }
    #[doc = " Sets the list of servers for the database to use."]
    #[doc = " @param db the database to set the servers. The list will be duped and"]
    #[doc = " the original will still need to be freed by the caller."]
    #[doc = " @param servers a char* list of servers."]
    pub unsafe fn alpm_db_set_servers(
        &self,
        db: *mut alpm_db_t,
        servers: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_db_set_servers)(db, servers)
    }
    #[doc = " Add a download server to a database."]
    #[doc = " @param db database pointer"]
    #[doc = " @param url url of the server"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_db_add_server(
        &self,
        db: *mut alpm_db_t,
        url: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_db_add_server)(db, url)
    }
    #[doc = " Remove a download server from a database."]
    #[doc = " @param db database pointer"]
    #[doc = " @param url url of the server"]
    #[doc = " @return 0 on success, 1 on server not present,"]
    #[doc = " -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_db_remove_server(
        &self,
        db: *mut alpm_db_t,
        url: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_db_remove_server)(db, url)
    }
    #[doc = " Update package databases."]
    #[doc = ""]
    #[doc = " An update of the package databases in the list \\a dbs will be attempted."]
    #[doc = " Unless \\a force is true, the update will only be performed if the remote"]
    #[doc = " databases were modified since the last update."]
    #[doc = ""]
    #[doc = " This operation requires a database lock, and will return an applicable error"]
    #[doc = " if the lock could not be obtained."]
    #[doc = ""]
    #[doc = " Example:"]
    #[doc = " @code"]
    #[doc = " alpm_list_t *dbs = alpm_get_syncdbs(config->handle);"]
    #[doc = " ret = alpm_db_update(config->handle, dbs, force);"]
    #[doc = " if(ret < 0) {"]
    #[doc = "     pm_printf(ALPM_LOG_ERROR, _(\"failed to synchronize all databases (%s)\\n\"),"]
    #[doc = "         alpm_strerror(alpm_errno(config->handle)));"]
    #[doc = " }"]
    #[doc = " @endcode"]
    #[doc = ""]
    #[doc = " @note After a successful update, the \\link alpm_db_get_pkgcache()"]
    #[doc = " package cache \\endlink will be invalidated"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param dbs list of package databases to update"]
    #[doc = " @param force if true, then forces the update, otherwise update only in case"]
    #[doc = " the databases aren't up to date"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly),"]
    #[doc = " 1 if all databases are up to to date"]
    pub unsafe fn alpm_db_update(
        &self,
        handle: *mut alpm_handle_t,
        dbs: *mut alpm_list_t,
        force: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        (self.alpm_db_update)(handle, dbs, force)
    }
    #[doc = " Get a package entry from a package database."]
    #[doc = " Looking up a package is O(1) and will be significantly faster than"]
    #[doc = " iterating over the pkgcahe."]
    #[doc = " @param db pointer to the package database to get the package from"]
    #[doc = " @param name of the package"]
    #[doc = " @return the package entry on success, NULL on error"]
    pub unsafe fn alpm_db_get_pkg(
        &self,
        db: *mut alpm_db_t,
        name: *const ::std::os::raw::c_char,
    ) -> *mut alpm_pkg_t {
        (self.alpm_db_get_pkg)(db, name)
    }
    #[doc = " Get the package cache of a package database."]
    #[doc = " This is a list of all packages the db contains."]
    #[doc = " @param db pointer to the package database to get the package from"]
    #[doc = " @return the list of packages on success, NULL on error"]
    pub unsafe fn alpm_db_get_pkgcache(&self, db: *mut alpm_db_t) -> *mut alpm_list_t {
        (self.alpm_db_get_pkgcache)(db)
    }
    #[doc = " Get a group entry from a package database."]
    #[doc = " Looking up a group is O(1) and will be significantly faster than"]
    #[doc = " iterating over the groupcahe."]
    #[doc = " @param db pointer to the package database to get the group from"]
    #[doc = " @param name of the group"]
    #[doc = " @return the groups entry on success, NULL on error"]
    pub unsafe fn alpm_db_get_group(
        &self,
        db: *mut alpm_db_t,
        name: *const ::std::os::raw::c_char,
    ) -> *mut alpm_group_t {
        (self.alpm_db_get_group)(db, name)
    }
    #[doc = " Get the group cache of a package database."]
    #[doc = " @param db pointer to the package database to get the group from"]
    #[doc = " @return the list of groups on success, NULL on error"]
    pub unsafe fn alpm_db_get_groupcache(&self, db: *mut alpm_db_t) -> *mut alpm_list_t {
        (self.alpm_db_get_groupcache)(db)
    }
    #[doc = " Searches a database with regular expressions."]
    #[doc = " @param db pointer to the package database to search in"]
    #[doc = " @param needles a list of regular expressions to search for"]
    #[doc = " @param ret pointer to list for storing packages matching all"]
    #[doc = " regular expressions - must point to an empty (NULL) alpm_list_t *."]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_db_search(
        &self,
        db: *mut alpm_db_t,
        needles: *const alpm_list_t,
        ret: *mut *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_db_search)(db, needles, ret)
    }
    #[doc = " Sets the usage of a database."]
    #[doc = " @param db pointer to the package database to set the status for"]
    #[doc = " @param usage a bitmask of alpm_db_usage_t values"]
    #[doc = " @return 0 on success, or -1 on error"]
    pub unsafe fn alpm_db_set_usage(
        &self,
        db: *mut alpm_db_t,
        usage: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        (self.alpm_db_set_usage)(db, usage)
    }
    #[doc = " Gets the usage of a database."]
    #[doc = " @param db pointer to the package database to get the status of"]
    #[doc = " @param usage pointer to an alpm_db_usage_t to store db's status"]
    #[doc = " @return 0 on success, or -1 on error"]
    pub unsafe fn alpm_db_get_usage(
        &self,
        db: *mut alpm_db_t,
        usage: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        (self.alpm_db_get_usage)(db, usage)
    }
    #[doc = " Returns the callback used for logging."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the currently set log callback"]
    pub unsafe fn alpm_option_get_logcb(&self, handle: *mut alpm_handle_t) -> alpm_cb_log {
        (self.alpm_option_get_logcb)(handle)
    }
    #[doc = " Returns the callback used for logging."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the currently set log callback context"]
    pub unsafe fn alpm_option_get_logcb_ctx(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *mut ::std::os::raw::c_void {
        (self.alpm_option_get_logcb_ctx)(handle)
    }
    #[doc = " Sets the callback used for logging."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param cb the cb to use"]
    #[doc = " @param ctx user-provided context to pass to cb"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_logcb(
        &self,
        handle: *mut alpm_handle_t,
        cb: alpm_cb_log,
        ctx: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_logcb)(handle, cb, ctx)
    }
    #[doc = " Returns the callback used to report download progress."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the currently set download callback"]
    pub unsafe fn alpm_option_get_dlcb(&self, handle: *mut alpm_handle_t) -> alpm_cb_download {
        (self.alpm_option_get_dlcb)(handle)
    }
    #[doc = " Returns the callback used to report download progress."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the currently set download callback context"]
    pub unsafe fn alpm_option_get_dlcb_ctx(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *mut ::std::os::raw::c_void {
        (self.alpm_option_get_dlcb_ctx)(handle)
    }
    #[doc = " Sets the callback used to report download progress."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param cb the cb to use"]
    #[doc = " @param ctx user-provided context to pass to cb"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_dlcb(
        &self,
        handle: *mut alpm_handle_t,
        cb: alpm_cb_download,
        ctx: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_dlcb)(handle, cb, ctx)
    }
    #[doc = " Returns the downloading callback."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the currently set fetch callback"]
    pub unsafe fn alpm_option_get_fetchcb(&self, handle: *mut alpm_handle_t) -> alpm_cb_fetch {
        (self.alpm_option_get_fetchcb)(handle)
    }
    #[doc = " Returns the downloading callback."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the currently set fetch callback context"]
    pub unsafe fn alpm_option_get_fetchcb_ctx(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *mut ::std::os::raw::c_void {
        (self.alpm_option_get_fetchcb_ctx)(handle)
    }
    #[doc = " Sets the downloading callback."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param cb the cb to use"]
    #[doc = " @param ctx user-provided context to pass to cb"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_fetchcb(
        &self,
        handle: *mut alpm_handle_t,
        cb: alpm_cb_fetch,
        ctx: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_fetchcb)(handle, cb, ctx)
    }
    #[doc = " Returns the callback used for events."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the currently set event callback"]
    pub unsafe fn alpm_option_get_eventcb(&self, handle: *mut alpm_handle_t) -> alpm_cb_event {
        (self.alpm_option_get_eventcb)(handle)
    }
    #[doc = " Returns the callback used for events."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the currently set event callback context"]
    pub unsafe fn alpm_option_get_eventcb_ctx(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *mut ::std::os::raw::c_void {
        (self.alpm_option_get_eventcb_ctx)(handle)
    }
    #[doc = " Sets the callback used for events."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param cb the cb to use"]
    #[doc = " @param ctx user-provided context to pass to cb"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_eventcb(
        &self,
        handle: *mut alpm_handle_t,
        cb: alpm_cb_event,
        ctx: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_eventcb)(handle, cb, ctx)
    }
    #[doc = " Returns the callback used for questions."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the currently set question callback"]
    pub unsafe fn alpm_option_get_questioncb(
        &self,
        handle: *mut alpm_handle_t,
    ) -> alpm_cb_question {
        (self.alpm_option_get_questioncb)(handle)
    }
    #[doc = " Returns the callback used for questions."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the currently set question callback context"]
    pub unsafe fn alpm_option_get_questioncb_ctx(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *mut ::std::os::raw::c_void {
        (self.alpm_option_get_questioncb_ctx)(handle)
    }
    #[doc = " Sets the callback used for questions."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param cb the cb to use"]
    #[doc = " @param ctx user-provided context to pass to cb"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_questioncb(
        &self,
        handle: *mut alpm_handle_t,
        cb: alpm_cb_question,
        ctx: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_questioncb)(handle, cb, ctx)
    }
    #[doc = "Returns the callback used for operation progress."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the currently set progress callback"]
    pub unsafe fn alpm_option_get_progresscb(
        &self,
        handle: *mut alpm_handle_t,
    ) -> alpm_cb_progress {
        (self.alpm_option_get_progresscb)(handle)
    }
    #[doc = "Returns the callback used for operation progress."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the currently set progress callback context"]
    pub unsafe fn alpm_option_get_progresscb_ctx(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *mut ::std::os::raw::c_void {
        (self.alpm_option_get_progresscb_ctx)(handle)
    }
    #[doc = " Sets the callback used for operation progress."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param cb the cb to use"]
    #[doc = " @param ctx user-provided context to pass to cb"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_progresscb(
        &self,
        handle: *mut alpm_handle_t,
        cb: alpm_cb_progress,
        ctx: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_progresscb)(handle, cb, ctx)
    }
    #[doc = " Returns the root path. Read-only."]
    #[doc = " @param handle the context handle"]
    pub unsafe fn alpm_option_get_root(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *const ::std::os::raw::c_char {
        (self.alpm_option_get_root)(handle)
    }
    #[doc = " Returns the path to the database directory. Read-only."]
    #[doc = " @param handle the context handle"]
    pub unsafe fn alpm_option_get_dbpath(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *const ::std::os::raw::c_char {
        (self.alpm_option_get_dbpath)(handle)
    }
    #[doc = " Get the name of the database lock file. Read-only."]
    #[doc = " This is the name that the lockfile would have. It does not"]
    #[doc = " matter if the lockfile actually exists on disk."]
    #[doc = " @param handle the context handle"]
    pub unsafe fn alpm_option_get_lockfile(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *const ::std::os::raw::c_char {
        (self.alpm_option_get_lockfile)(handle)
    }
    #[doc = " Gets the currently configured cachedirs,"]
    #[doc = " @param handle the context handle"]
    #[doc = " @return a char* list of cache directories"]
    pub unsafe fn alpm_option_get_cachedirs(&self, handle: *mut alpm_handle_t) -> *mut alpm_list_t {
        (self.alpm_option_get_cachedirs)(handle)
    }
    #[doc = " Sets the cachedirs."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param cachedirs a char* list of cachdirs. The list will be duped and"]
    #[doc = " the original will still need to be freed by the caller."]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_cachedirs(
        &self,
        handle: *mut alpm_handle_t,
        cachedirs: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_cachedirs)(handle, cachedirs)
    }
    #[doc = " Append a cachedir to the configured cachedirs."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param cachedir the cachedir to add"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_add_cachedir(
        &self,
        handle: *mut alpm_handle_t,
        cachedir: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_add_cachedir)(handle, cachedir)
    }
    #[doc = " Remove a cachedir from the configured cachedirs."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param cachedir the cachedir to remove"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_remove_cachedir(
        &self,
        handle: *mut alpm_handle_t,
        cachedir: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_remove_cachedir)(handle, cachedir)
    }
    #[doc = " Gets the currently configured hookdirs,"]
    #[doc = " @param handle the context handle"]
    #[doc = " @return a char* list of hook directories"]
    pub unsafe fn alpm_option_get_hookdirs(&self, handle: *mut alpm_handle_t) -> *mut alpm_list_t {
        (self.alpm_option_get_hookdirs)(handle)
    }
    #[doc = " Sets the hookdirs."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param hookdirs a char* list of hookdirs. The list will be duped and"]
    #[doc = " the original will still need to be freed by the caller."]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_hookdirs(
        &self,
        handle: *mut alpm_handle_t,
        hookdirs: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_hookdirs)(handle, hookdirs)
    }
    #[doc = " Append a hookdir to the configured hookdirs."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param hookdir the hookdir to add"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_add_hookdir(
        &self,
        handle: *mut alpm_handle_t,
        hookdir: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_add_hookdir)(handle, hookdir)
    }
    #[doc = " Remove a hookdir from the configured hookdirs."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param hookdir the hookdir to remove"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_remove_hookdir(
        &self,
        handle: *mut alpm_handle_t,
        hookdir: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_remove_hookdir)(handle, hookdir)
    }
    #[doc = " Gets the currently configured overwritable files,"]
    #[doc = " @param handle the context handle"]
    #[doc = " @return a char* list of overwritable file globs"]
    pub unsafe fn alpm_option_get_overwrite_files(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *mut alpm_list_t {
        (self.alpm_option_get_overwrite_files)(handle)
    }
    #[doc = " Sets the overwritable files."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param globs a char* list of overwritable file globs. The list will be duped and"]
    #[doc = " the original will still need to be freed by the caller."]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_overwrite_files(
        &self,
        handle: *mut alpm_handle_t,
        globs: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_overwrite_files)(handle, globs)
    }
    #[doc = " Append an overwritable file to the configured overwritable files."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param glob the file glob to add"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_add_overwrite_file(
        &self,
        handle: *mut alpm_handle_t,
        glob: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_add_overwrite_file)(handle, glob)
    }
    #[doc = " Remove a file glob from the configured overwritable files globs."]
    #[doc = " @note The overwritable file list contains a list of globs. The glob to"]
    #[doc = " remove must exactly match the entry to remove. There is no glob expansion."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param glob the file glob to remove"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_remove_overwrite_file(
        &self,
        handle: *mut alpm_handle_t,
        glob: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_remove_overwrite_file)(handle, glob)
    }
    #[doc = " Gets the filepath to the currently set logfile."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the path to the logfile"]
    pub unsafe fn alpm_option_get_logfile(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *const ::std::os::raw::c_char {
        (self.alpm_option_get_logfile)(handle)
    }
    #[doc = " Sets the logfile path."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param logfile path to the new location of the logfile"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_logfile(
        &self,
        handle: *mut alpm_handle_t,
        logfile: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_logfile)(handle, logfile)
    }
    #[doc = " Returns the path to libalpm's GnuPG home directory."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the path to libalpms's GnuPG home directory"]
    pub unsafe fn alpm_option_get_gpgdir(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *const ::std::os::raw::c_char {
        (self.alpm_option_get_gpgdir)(handle)
    }
    #[doc = " Sets the path to libalpm's GnuPG home directory."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param gpgdir the gpgdir to set"]
    pub unsafe fn alpm_option_set_gpgdir(
        &self,
        handle: *mut alpm_handle_t,
        gpgdir: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_gpgdir)(handle, gpgdir)
    }
    #[doc = " Returns whether to use syslog (0 is FALSE, TRUE otherwise)."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_get_usesyslog(
        &self,
        handle: *mut alpm_handle_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_get_usesyslog)(handle)
    }
    #[doc = " Sets whether to use syslog (0 is FALSE, TRUE otherwise)."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param usesyslog whether to use the syslog (0 is FALSE, TRUE otherwise)"]
    pub unsafe fn alpm_option_set_usesyslog(
        &self,
        handle: *mut alpm_handle_t,
        usesyslog: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_usesyslog)(handle, usesyslog)
    }
    #[doc = " Get the list of no-upgrade files"]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the char* list of no-upgrade files"]
    pub unsafe fn alpm_option_get_noupgrades(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *mut alpm_list_t {
        (self.alpm_option_get_noupgrades)(handle)
    }
    #[doc = " Add a file to the no-upgrade list"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param path the path to add"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_add_noupgrade(
        &self,
        handle: *mut alpm_handle_t,
        path: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_add_noupgrade)(handle, path)
    }
    #[doc = " Sets the list of no-upgrade files"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param noupgrade a char* list of file to not upgrade."]
    #[doc = " The list will be duped and the original will still need to be freed by the caller."]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_noupgrades(
        &self,
        handle: *mut alpm_handle_t,
        noupgrade: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_noupgrades)(handle, noupgrade)
    }
    #[doc = " Remove an entry from the no-upgrade list"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param path the path to remove"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_remove_noupgrade(
        &self,
        handle: *mut alpm_handle_t,
        path: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_remove_noupgrade)(handle, path)
    }
    #[doc = " Test if a path matches any of the globs in the no-upgrade list"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param path the path to test"]
    #[doc = " @return 0 is the path matches a glob, negative if there is no match and"]
    #[doc = " positive is the  match was inverted"]
    pub unsafe fn alpm_option_match_noupgrade(
        &self,
        handle: *mut alpm_handle_t,
        path: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_match_noupgrade)(handle, path)
    }
    #[doc = " Get the list of no-extract files"]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the char* list of no-extract files"]
    pub unsafe fn alpm_option_get_noextracts(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *mut alpm_list_t {
        (self.alpm_option_get_noextracts)(handle)
    }
    #[doc = " Add a file to the no-extract list"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param path the path to add"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_add_noextract(
        &self,
        handle: *mut alpm_handle_t,
        path: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_add_noextract)(handle, path)
    }
    #[doc = " Sets the list of no-extract files"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param noextract a char* list of file to not extract."]
    #[doc = " The list will be duped and the original will still need to be freed by the caller."]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_noextracts(
        &self,
        handle: *mut alpm_handle_t,
        noextract: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_noextracts)(handle, noextract)
    }
    #[doc = " Remove an entry from the no-extract list"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param path the path to remove"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_remove_noextract(
        &self,
        handle: *mut alpm_handle_t,
        path: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_remove_noextract)(handle, path)
    }
    #[doc = " Test if a path matches any of the globs in the no-extract list"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param path the path to test"]
    #[doc = " @return 0 is the path matches a glob, negative if there is no match and"]
    #[doc = " positive is the  match was inverted"]
    pub unsafe fn alpm_option_match_noextract(
        &self,
        handle: *mut alpm_handle_t,
        path: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_match_noextract)(handle, path)
    }
    #[doc = " Get the list of ignored packages"]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the char* list of ignored packages"]
    pub unsafe fn alpm_option_get_ignorepkgs(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *mut alpm_list_t {
        (self.alpm_option_get_ignorepkgs)(handle)
    }
    #[doc = " Add a file to the ignored package list"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param pkg the package to add"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_add_ignorepkg(
        &self,
        handle: *mut alpm_handle_t,
        pkg: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_add_ignorepkg)(handle, pkg)
    }
    #[doc = " Sets the list of packages to ignore"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param ignorepkgs a char* list of packages to ignore"]
    #[doc = " The list will be duped and the original will still need to be freed by the caller."]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_ignorepkgs(
        &self,
        handle: *mut alpm_handle_t,
        ignorepkgs: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_ignorepkgs)(handle, ignorepkgs)
    }
    #[doc = " Remove an entry from the ignorepkg list"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param pkg the package to remove"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_remove_ignorepkg(
        &self,
        handle: *mut alpm_handle_t,
        pkg: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_remove_ignorepkg)(handle, pkg)
    }
    #[doc = " Get the list of ignored groups"]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the char* list of ignored groups"]
    pub unsafe fn alpm_option_get_ignoregroups(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *mut alpm_list_t {
        (self.alpm_option_get_ignoregroups)(handle)
    }
    #[doc = " Add a file to the ignored group list"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param grp the group to add"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_add_ignoregroup(
        &self,
        handle: *mut alpm_handle_t,
        grp: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_add_ignoregroup)(handle, grp)
    }
    #[doc = " Sets the list of groups to ignore"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param ignoregrps a char* list of groups to ignore"]
    #[doc = " The list will be duped and the original will still need to be freed by the caller."]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_ignoregroups(
        &self,
        handle: *mut alpm_handle_t,
        ignoregrps: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_ignoregroups)(handle, ignoregrps)
    }
    #[doc = " Remove an entry from the ignoregroup list"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param grp the group to remove"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_remove_ignoregroup(
        &self,
        handle: *mut alpm_handle_t,
        grp: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_remove_ignoregroup)(handle, grp)
    }
    #[doc = " Gets the list of dependencies that are assumed to be met"]
    #[doc = " @param handle the context handle"]
    #[doc = " @return a list of alpm_depend_t*"]
    pub unsafe fn alpm_option_get_assumeinstalled(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *mut alpm_list_t {
        (self.alpm_option_get_assumeinstalled)(handle)
    }
    #[doc = " Add a depend to the assumed installed list"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param dep the dependency to add"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_add_assumeinstalled(
        &self,
        handle: *mut alpm_handle_t,
        dep: *const alpm_depend_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_add_assumeinstalled)(handle, dep)
    }
    #[doc = " Sets the list of dependencies that are assumed to be met"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param deps a list of *alpm_depend_t"]
    #[doc = " The list will be duped and the original will still need to be freed by the caller."]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_assumeinstalled(
        &self,
        handle: *mut alpm_handle_t,
        deps: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_assumeinstalled)(handle, deps)
    }
    #[doc = " Remove an entry from the assume installed list"]
    #[doc = " @param handle the context handle"]
    #[doc = " @param dep the dep to remove"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_remove_assumeinstalled(
        &self,
        handle: *mut alpm_handle_t,
        dep: *const alpm_depend_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_remove_assumeinstalled)(handle, dep)
    }
    #[doc = " Returns the allowed package architecture."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the configured package architectures"]
    pub unsafe fn alpm_option_get_architectures(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *mut alpm_list_t {
        (self.alpm_option_get_architectures)(handle)
    }
    #[doc = " Adds an allowed package architecture."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param arch the architecture to set"]
    pub unsafe fn alpm_option_add_architecture(
        &self,
        handle: *mut alpm_handle_t,
        arch: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_add_architecture)(handle, arch)
    }
    #[doc = " Sets the allowed package architecture."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param arches the architecture to set"]
    pub unsafe fn alpm_option_set_architectures(
        &self,
        handle: *mut alpm_handle_t,
        arches: *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_architectures)(handle, arches)
    }
    #[doc = " Removes an allowed package architecture."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param arch the architecture to remove"]
    pub unsafe fn alpm_option_remove_architecture(
        &self,
        handle: *mut alpm_handle_t,
        arch: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_remove_architecture)(handle, arch)
    }
    #[doc = " Get whether or not checking for free space before installing packages is enabled."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return 0 if disabled, 1 if enabled"]
    pub unsafe fn alpm_option_get_checkspace(
        &self,
        handle: *mut alpm_handle_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_get_checkspace)(handle)
    }
    #[doc = " Enable/disable checking free space before installing packages."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param checkspace 0 for disabled, 1 for enabled"]
    pub unsafe fn alpm_option_set_checkspace(
        &self,
        handle: *mut alpm_handle_t,
        checkspace: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_checkspace)(handle, checkspace)
    }
    #[doc = " Gets the configured database extension."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the configured database extension"]
    pub unsafe fn alpm_option_get_dbext(
        &self,
        handle: *mut alpm_handle_t,
    ) -> *const ::std::os::raw::c_char {
        (self.alpm_option_get_dbext)(handle)
    }
    #[doc = " Sets the database extension."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param dbext the database extension to use"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_dbext(
        &self,
        handle: *mut alpm_handle_t,
        dbext: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_dbext)(handle, dbext)
    }
    #[doc = " Get the default siglevel."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return a \\link alpm_siglevel_t \\endlink bitfield of the siglevel"]
    pub unsafe fn alpm_option_get_default_siglevel(
        &self,
        handle: *mut alpm_handle_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_get_default_siglevel)(handle)
    }
    #[doc = " Set the default siglevel."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param level a \\link alpm_siglevel_t \\endlink bitfield of the level to set"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_default_siglevel(
        &self,
        handle: *mut alpm_handle_t,
        level: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_default_siglevel)(handle, level)
    }
    #[doc = " Get the configured local file siglevel."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return a \\link alpm_siglevel_t \\endlink bitfield of the siglevel"]
    pub unsafe fn alpm_option_get_local_file_siglevel(
        &self,
        handle: *mut alpm_handle_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_get_local_file_siglevel)(handle)
    }
    #[doc = " Set the local file siglevel."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param level a \\link alpm_siglevel_t \\endlink bitfield of the level to set"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_local_file_siglevel(
        &self,
        handle: *mut alpm_handle_t,
        level: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_local_file_siglevel)(handle, level)
    }
    #[doc = " Get the configured remote file siglevel."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return a \\link alpm_siglevel_t \\endlink bitfield of the siglevel"]
    pub unsafe fn alpm_option_get_remote_file_siglevel(
        &self,
        handle: *mut alpm_handle_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_get_remote_file_siglevel)(handle)
    }
    #[doc = " Set the remote file siglevel."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param level a \\link alpm_siglevel_t \\endlink bitfield of the level to set"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_remote_file_siglevel(
        &self,
        handle: *mut alpm_handle_t,
        level: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_remote_file_siglevel)(handle, level)
    }
    #[doc = " Enables/disables the download timeout."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param disable_dl_timeout 0 for enabled, 1 for disabled"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_option_set_disable_dl_timeout(
        &self,
        handle: *mut alpm_handle_t,
        disable_dl_timeout: ::std::os::raw::c_ushort,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_disable_dl_timeout)(handle, disable_dl_timeout)
    }
    #[doc = " Gets the number of parallel streams to download database and package files."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the number of parallel streams to download database and package files"]
    pub unsafe fn alpm_option_get_parallel_downloads(
        &self,
        handle: *mut alpm_handle_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_get_parallel_downloads)(handle)
    }
    #[doc = " Sets number of parallel streams to download database and package files."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param num_streams number of parallel download streams"]
    #[doc = " @return 0 on success, -1 on error"]
    pub unsafe fn alpm_option_set_parallel_downloads(
        &self,
        handle: *mut alpm_handle_t,
        num_streams: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int {
        (self.alpm_option_set_parallel_downloads)(handle, num_streams)
    }
    #[doc = " Create a package from a file."]
    #[doc = " If full is false, the archive is read only until all necessary"]
    #[doc = " metadata is found. If it is true, the entire archive is read, which"]
    #[doc = " serves as a verification of integrity and the filelist can be created."]
    #[doc = " The allocated structure should be freed using alpm_pkg_free()."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param filename location of the package tarball"]
    #[doc = " @param full whether to stop the load after metadata is read or continue"]
    #[doc = " through the full archive"]
    #[doc = " @param level what level of package signature checking to perform on the"]
    #[doc = " package; note that this must be a '.sig' file type verification"]
    #[doc = " @param pkg address of the package pointer"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_pkg_load(
        &self,
        handle: *mut alpm_handle_t,
        filename: *const ::std::os::raw::c_char,
        full: ::std::os::raw::c_int,
        level: ::std::os::raw::c_int,
        pkg: *mut *mut alpm_pkg_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_pkg_load)(handle, filename, full, level, pkg)
    }
    #[doc = " Fetch a list of remote packages."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param urls list of package URLs to download"]
    #[doc = " @param fetched list of filepaths to the fetched packages, each item"]
    #[doc = "    corresponds to one in `urls` list. This is an output parameter,"]
    #[doc = "    the caller should provide a pointer to an empty list"]
    #[doc = "    (*fetched === NULL) and the callee fills the list with data."]
    #[doc = " @return 0 on success or -1 on failure"]
    pub unsafe fn alpm_fetch_pkgurl(
        &self,
        handle: *mut alpm_handle_t,
        urls: *const alpm_list_t,
        fetched: *mut *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_fetch_pkgurl)(handle, urls, fetched)
    }
    #[doc = " Find a package in a list by name."]
    #[doc = " @param haystack a list of alpm_pkg_t"]
    #[doc = " @param needle the package name"]
    #[doc = " @return a pointer to the package if found or NULL"]
    pub unsafe fn alpm_pkg_find(
        &self,
        haystack: *mut alpm_list_t,
        needle: *const ::std::os::raw::c_char,
    ) -> *mut alpm_pkg_t {
        (self.alpm_pkg_find)(haystack, needle)
    }
    #[doc = " Free a package."]
    #[doc = " Only packages loaded with \\link alpm_pkg_load \\endlink can be freed."]
    #[doc = " Packages from databases will be freed by libalpm when they are unregistered."]
    #[doc = " @param pkg package pointer to free"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_pkg_free(&self, pkg: *mut alpm_pkg_t) -> ::std::os::raw::c_int {
        (self.alpm_pkg_free)(pkg)
    }
    #[doc = " Check the integrity (with md5) of a package from the sync cache."]
    #[doc = " @param pkg package pointer"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_pkg_checkmd5sum(&self, pkg: *mut alpm_pkg_t) -> ::std::os::raw::c_int {
        (self.alpm_pkg_checkmd5sum)(pkg)
    }
    #[doc = " Compare two version strings and determine which one is 'newer'."]
    #[doc = " Returns a value comparable to the way strcmp works. Returns 1"]
    #[doc = " if a is newer than b, 0 if a and b are the same version, or -1"]
    #[doc = " if b is newer than a."]
    #[doc = ""]
    #[doc = " Different epoch values for version strings will override any further"]
    #[doc = " comparison. If no epoch is provided, 0 is assumed."]
    #[doc = ""]
    #[doc = " Keep in mind that the pkgrel is only compared if it is available"]
    #[doc = " on both versions handed to this function. For example, comparing"]
    #[doc = " 1.5-1 and 1.5 will yield 0; comparing 1.5-1 and 1.5-2 will yield"]
    #[doc = " -1 as expected. This is mainly for supporting versioned dependencies"]
    #[doc = " that do not include the pkgrel."]
    pub unsafe fn alpm_pkg_vercmp(
        &self,
        a: *const ::std::os::raw::c_char,
        b: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.alpm_pkg_vercmp)(a, b)
    }
    #[doc = " Computes the list of packages requiring a given package."]
    #[doc = " The return value of this function is a newly allocated"]
    #[doc = " list of package names (char*), it should be freed by the caller."]
    #[doc = " @param pkg a package"]
    #[doc = " @return the list of packages requiring pkg"]
    pub unsafe fn alpm_pkg_compute_requiredby(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_list_t {
        (self.alpm_pkg_compute_requiredby)(pkg)
    }
    #[doc = " Computes the list of packages optionally requiring a given package."]
    #[doc = " The return value of this function is a newly allocated"]
    #[doc = " list of package names (char*), it should be freed by the caller."]
    #[doc = " @param pkg a package"]
    #[doc = " @return the list of packages optionally requiring pkg"]
    pub unsafe fn alpm_pkg_compute_optionalfor(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_list_t {
        (self.alpm_pkg_compute_optionalfor)(pkg)
    }
    #[doc = " Test if a package should be ignored."]
    #[doc = " Checks if the package is ignored via IgnorePkg, or if the package is"]
    #[doc = " in a group ignored via IgnoreGroup."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param pkg the package to test"]
    #[doc = " @return 1 if the package should be ignored, 0 otherwise"]
    pub unsafe fn alpm_pkg_should_ignore(
        &self,
        handle: *mut alpm_handle_t,
        pkg: *mut alpm_pkg_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_pkg_should_ignore)(handle, pkg)
    }
    #[doc = " Gets the name of the file from which the package was loaded."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal string"]
    pub unsafe fn alpm_pkg_get_filename(
        &self,
        pkg: *mut alpm_pkg_t,
    ) -> *const ::std::os::raw::c_char {
        (self.alpm_pkg_get_filename)(pkg)
    }
    #[doc = " Returns the package base name."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal string"]
    pub unsafe fn alpm_pkg_get_base(&self, pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char {
        (self.alpm_pkg_get_base)(pkg)
    }
    #[doc = " Returns the package name."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal string"]
    pub unsafe fn alpm_pkg_get_name(&self, pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char {
        (self.alpm_pkg_get_name)(pkg)
    }
    #[doc = " Returns the package version as a string."]
    #[doc = " This includes all available epoch, version, and pkgrel components. Use"]
    #[doc = " alpm_pkg_vercmp() to compare version strings if necessary."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal string"]
    pub unsafe fn alpm_pkg_get_version(
        &self,
        pkg: *mut alpm_pkg_t,
    ) -> *const ::std::os::raw::c_char {
        (self.alpm_pkg_get_version)(pkg)
    }
    #[doc = " Returns the origin of the package."]
    #[doc = " @return an alpm_pkgfrom_t constant, -1 on error"]
    pub unsafe fn alpm_pkg_get_origin(&self, pkg: *mut alpm_pkg_t) -> alpm_pkgfrom_t {
        (self.alpm_pkg_get_origin)(pkg)
    }
    #[doc = " Returns the package description."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal string"]
    pub unsafe fn alpm_pkg_get_desc(&self, pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char {
        (self.alpm_pkg_get_desc)(pkg)
    }
    #[doc = " Returns the package URL."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal string"]
    pub unsafe fn alpm_pkg_get_url(&self, pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char {
        (self.alpm_pkg_get_url)(pkg)
    }
    #[doc = " Returns the build timestamp of the package."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return the timestamp of the build time"]
    pub unsafe fn alpm_pkg_get_builddate(&self, pkg: *mut alpm_pkg_t) -> alpm_time_t {
        (self.alpm_pkg_get_builddate)(pkg)
    }
    #[doc = " Returns the install timestamp of the package."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return the timestamp of the install time"]
    pub unsafe fn alpm_pkg_get_installdate(&self, pkg: *mut alpm_pkg_t) -> alpm_time_t {
        (self.alpm_pkg_get_installdate)(pkg)
    }
    #[doc = " Returns the packager's name."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal string"]
    pub unsafe fn alpm_pkg_get_packager(
        &self,
        pkg: *mut alpm_pkg_t,
    ) -> *const ::std::os::raw::c_char {
        (self.alpm_pkg_get_packager)(pkg)
    }
    #[doc = " Returns the package's MD5 checksum as a string."]
    #[doc = " The returned string is a sequence of 32 lowercase hexadecimal digits."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal string"]
    pub unsafe fn alpm_pkg_get_md5sum(
        &self,
        pkg: *mut alpm_pkg_t,
    ) -> *const ::std::os::raw::c_char {
        (self.alpm_pkg_get_md5sum)(pkg)
    }
    #[doc = " Returns the package's SHA256 checksum as a string."]
    #[doc = " The returned string is a sequence of 64 lowercase hexadecimal digits."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal string"]
    pub unsafe fn alpm_pkg_get_sha256sum(
        &self,
        pkg: *mut alpm_pkg_t,
    ) -> *const ::std::os::raw::c_char {
        (self.alpm_pkg_get_sha256sum)(pkg)
    }
    #[doc = " Returns the architecture for which the package was built."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal string"]
    pub unsafe fn alpm_pkg_get_arch(&self, pkg: *mut alpm_pkg_t) -> *const ::std::os::raw::c_char {
        (self.alpm_pkg_get_arch)(pkg)
    }
    #[doc = " Returns the size of the package. This is only available for sync database"]
    #[doc = " packages and package files, not those loaded from the local database."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return the size of the package in bytes."]
    pub unsafe fn alpm_pkg_get_size(&self, pkg: *mut alpm_pkg_t) -> off_t {
        (self.alpm_pkg_get_size)(pkg)
    }
    #[doc = " Returns the installed size of the package."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return the total size of files installed by the package."]
    pub unsafe fn alpm_pkg_get_isize(&self, pkg: *mut alpm_pkg_t) -> off_t {
        (self.alpm_pkg_get_isize)(pkg)
    }
    #[doc = " Returns the package installation reason."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return an enum member giving the install reason."]
    pub unsafe fn alpm_pkg_get_reason(&self, pkg: *mut alpm_pkg_t) -> alpm_pkgreason_t {
        (self.alpm_pkg_get_reason)(pkg)
    }
    #[doc = " Returns the list of package licenses."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a pointer to an internal list of strings."]
    pub unsafe fn alpm_pkg_get_licenses(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_list_t {
        (self.alpm_pkg_get_licenses)(pkg)
    }
    #[doc = " Returns the list of package groups."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a pointer to an internal list of strings."]
    pub unsafe fn alpm_pkg_get_groups(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_list_t {
        (self.alpm_pkg_get_groups)(pkg)
    }
    #[doc = " Returns the list of package dependencies as alpm_depend_t."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal list of alpm_depend_t structures."]
    pub unsafe fn alpm_pkg_get_depends(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_list_t {
        (self.alpm_pkg_get_depends)(pkg)
    }
    #[doc = " Returns the list of package optional dependencies."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal list of alpm_depend_t structures."]
    pub unsafe fn alpm_pkg_get_optdepends(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_list_t {
        (self.alpm_pkg_get_optdepends)(pkg)
    }
    #[doc = " Returns a list of package check dependencies"]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal list of alpm_depend_t structures."]
    pub unsafe fn alpm_pkg_get_checkdepends(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_list_t {
        (self.alpm_pkg_get_checkdepends)(pkg)
    }
    #[doc = " Returns a list of package make dependencies"]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal list of alpm_depend_t structures."]
    pub unsafe fn alpm_pkg_get_makedepends(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_list_t {
        (self.alpm_pkg_get_makedepends)(pkg)
    }
    #[doc = " Returns the list of packages conflicting with pkg."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal list of alpm_depend_t structures."]
    pub unsafe fn alpm_pkg_get_conflicts(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_list_t {
        (self.alpm_pkg_get_conflicts)(pkg)
    }
    #[doc = " Returns the list of packages provided by pkg."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal list of alpm_depend_t structures."]
    pub unsafe fn alpm_pkg_get_provides(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_list_t {
        (self.alpm_pkg_get_provides)(pkg)
    }
    #[doc = " Returns the list of packages to be replaced by pkg."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal list of alpm_depend_t structures."]
    pub unsafe fn alpm_pkg_get_replaces(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_list_t {
        (self.alpm_pkg_get_replaces)(pkg)
    }
    #[doc = " Returns the list of files installed by pkg."]
    #[doc = " The filenames are relative to the install root,"]
    #[doc = " and do not include leading slashes."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a pointer to a filelist object containing a count and an array of"]
    #[doc = " package file objects"]
    pub unsafe fn alpm_pkg_get_files(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_filelist_t {
        (self.alpm_pkg_get_files)(pkg)
    }
    #[doc = " Returns the list of files backed up when installing pkg."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to a list of alpm_backup_t objects"]
    pub unsafe fn alpm_pkg_get_backup(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_list_t {
        (self.alpm_pkg_get_backup)(pkg)
    }
    #[doc = " Returns the database containing pkg."]
    #[doc = " Returns a pointer to the alpm_db_t structure the package is"]
    #[doc = " originating from, or NULL if the package was loaded from a file."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a pointer to the DB containing pkg, or NULL."]
    pub unsafe fn alpm_pkg_get_db(&self, pkg: *mut alpm_pkg_t) -> *mut alpm_db_t {
        (self.alpm_pkg_get_db)(pkg)
    }
    #[doc = " Returns the base64 encoded package signature."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return a reference to an internal string"]
    pub unsafe fn alpm_pkg_get_base64_sig(
        &self,
        pkg: *mut alpm_pkg_t,
    ) -> *const ::std::os::raw::c_char {
        (self.alpm_pkg_get_base64_sig)(pkg)
    }
    #[doc = " Extracts package signature either from embedded package signature"]
    #[doc = " or if it is absent then reads data from detached signature file."]
    #[doc = " @param pkg a pointer to package."]
    #[doc = " @param sig output parameter for signature data. Callee function allocates"]
    #[doc = " a buffer needed for the signature data. Caller is responsible for"]
    #[doc = " freeing this buffer."]
    #[doc = " @param sig_len output parameter for the signature data length."]
    #[doc = " @return 0 on success, negative number on error."]
    pub unsafe fn alpm_pkg_get_sig(
        &self,
        pkg: *mut alpm_pkg_t,
        sig: *mut *mut ::std::os::raw::c_uchar,
        sig_len: *mut usize,
    ) -> ::std::os::raw::c_int {
        (self.alpm_pkg_get_sig)(pkg, sig, sig_len)
    }
    #[doc = " Returns the method used to validate a package during install."]
    #[doc = " @param pkg a pointer to package"]
    #[doc = " @return an enum member giving the validation method"]
    pub unsafe fn alpm_pkg_get_validation(&self, pkg: *mut alpm_pkg_t) -> ::std::os::raw::c_int {
        (self.alpm_pkg_get_validation)(pkg)
    }
    #[doc = " Returns whether the package has an install scriptlet."]
    #[doc = " @return 0 if FALSE, TRUE otherwise"]
    pub unsafe fn alpm_pkg_has_scriptlet(&self, pkg: *mut alpm_pkg_t) -> ::std::os::raw::c_int {
        (self.alpm_pkg_has_scriptlet)(pkg)
    }
    #[doc = " Returns the size of the files that will be downloaded to install a"]
    #[doc = " package."]
    #[doc = " @param newpkg the new package to upgrade to"]
    #[doc = " @return the size of the download"]
    pub unsafe fn alpm_pkg_download_size(&self, newpkg: *mut alpm_pkg_t) -> off_t {
        (self.alpm_pkg_download_size)(newpkg)
    }
    #[doc = " Set install reason for a package in the local database."]
    #[doc = " The provided package object must be from the local database or this method"]
    #[doc = " will fail. The write to the local database is performed immediately."]
    #[doc = " @param pkg the package to update"]
    #[doc = " @param reason the new install reason"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_pkg_set_reason(
        &self,
        pkg: *mut alpm_pkg_t,
        reason: alpm_pkgreason_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_pkg_set_reason)(pkg, reason)
    }
    #[doc = " Open a package changelog for reading."]
    #[doc = " Similar to fopen in functionality, except that the returned 'file"]
    #[doc = " stream' could really be from an archive as well as from the database."]
    #[doc = " @param pkg the package to read the changelog of (either file or db)"]
    #[doc = " @return a 'file stream' to the package changelog"]
    pub unsafe fn alpm_pkg_changelog_open(
        &self,
        pkg: *mut alpm_pkg_t,
    ) -> *mut ::std::os::raw::c_void {
        (self.alpm_pkg_changelog_open)(pkg)
    }
    #[doc = " Read data from an open changelog 'file stream'."]
    #[doc = " Similar to fread in functionality, this function takes a buffer and"]
    #[doc = " amount of data to read. If an error occurs pm_errno will be set."]
    #[doc = " @param ptr a buffer to fill with raw changelog data"]
    #[doc = " @param size the size of the buffer"]
    #[doc = " @param pkg the package that the changelog is being read from"]
    #[doc = " @param fp a 'file stream' to the package changelog"]
    #[doc = " @return the number of characters read, or 0 if there is no more data or an"]
    #[doc = " error occurred."]
    pub unsafe fn alpm_pkg_changelog_read(
        &self,
        ptr: *mut ::std::os::raw::c_void,
        size: usize,
        pkg: *const alpm_pkg_t,
        fp: *mut ::std::os::raw::c_void,
    ) -> usize {
        (self.alpm_pkg_changelog_read)(ptr, size, pkg, fp)
    }
    #[doc = " Close a package changelog for reading."]
    #[doc = " @param pkg the package to close the changelog of (either file or db)"]
    #[doc = " @param fp the 'file stream' to the package changelog to close"]
    #[doc = " @return 0 on success, -1 on error"]
    pub unsafe fn alpm_pkg_changelog_close(
        &self,
        pkg: *const alpm_pkg_t,
        fp: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int {
        (self.alpm_pkg_changelog_close)(pkg, fp)
    }
    #[doc = " Open a package mtree file for reading."]
    #[doc = " @param pkg the local package to read the mtree of"]
    #[doc = " @return an archive structure for the package mtree file"]
    pub unsafe fn alpm_pkg_mtree_open(&self, pkg: *mut alpm_pkg_t) -> *mut archive {
        (self.alpm_pkg_mtree_open)(pkg)
    }
    #[doc = " Read next entry from a package mtree file."]
    #[doc = " @param pkg the package that the mtree file is being read from"]
    #[doc = " @param archive the archive structure reading from the mtree file"]
    #[doc = " @param entry an archive_entry to store the entry header information"]
    #[doc = " @return 0 on success, 1 if end of archive is reached, -1 otherwise."]
    pub unsafe fn alpm_pkg_mtree_next(
        &self,
        pkg: *const alpm_pkg_t,
        archive: *mut archive,
        entry: *mut *mut archive_entry,
    ) -> ::std::os::raw::c_int {
        (self.alpm_pkg_mtree_next)(pkg, archive, entry)
    }
    #[doc = " Close a package mtree file."]
    #[doc = " @param pkg the local package to close the mtree of"]
    #[doc = " @param archive the archive to close"]
    pub unsafe fn alpm_pkg_mtree_close(
        &self,
        pkg: *const alpm_pkg_t,
        archive: *mut archive,
    ) -> ::std::os::raw::c_int {
        (self.alpm_pkg_mtree_close)(pkg, archive)
    }
    #[doc = " Returns the bitfield of flags for the current transaction."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return the bitfield of transaction flags"]
    pub unsafe fn alpm_trans_get_flags(&self, handle: *mut alpm_handle_t) -> ::std::os::raw::c_int {
        (self.alpm_trans_get_flags)(handle)
    }
    #[doc = " Returns a list of packages added by the transaction."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return a list of alpm_pkg_t structures"]
    pub unsafe fn alpm_trans_get_add(&self, handle: *mut alpm_handle_t) -> *mut alpm_list_t {
        (self.alpm_trans_get_add)(handle)
    }
    #[doc = " Returns the list of packages removed by the transaction."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return a list of alpm_pkg_t structures"]
    pub unsafe fn alpm_trans_get_remove(&self, handle: *mut alpm_handle_t) -> *mut alpm_list_t {
        (self.alpm_trans_get_remove)(handle)
    }
    #[doc = " Initialize the transaction."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param flags flags of the transaction (like nodeps, etc; see alpm_transflag_t)"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_trans_init(
        &self,
        handle: *mut alpm_handle_t,
        flags: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        (self.alpm_trans_init)(handle, flags)
    }
    #[doc = " Prepare a transaction."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param data the address of an alpm_list where a list"]
    #[doc = " of alpm_depmissing_t objects is dumped (conflicting packages)"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_trans_prepare(
        &self,
        handle: *mut alpm_handle_t,
        data: *mut *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_trans_prepare)(handle, data)
    }
    #[doc = " Commit a transaction."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param data the address of an alpm_list where detailed description"]
    #[doc = " of an error can be dumped (i.e. list of conflicting files)"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_trans_commit(
        &self,
        handle: *mut alpm_handle_t,
        data: *mut *mut alpm_list_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_trans_commit)(handle, data)
    }
    #[doc = " Interrupt a transaction."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_trans_interrupt(&self, handle: *mut alpm_handle_t) -> ::std::os::raw::c_int {
        (self.alpm_trans_interrupt)(handle)
    }
    #[doc = " Release a transaction."]
    #[doc = " @param handle the context handle"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_trans_release(&self, handle: *mut alpm_handle_t) -> ::std::os::raw::c_int {
        (self.alpm_trans_release)(handle)
    }
    #[doc = " Search for packages to upgrade and add them to the transaction."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param enable_downgrade allow downgrading of packages if the remote version is lower"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_sync_sysupgrade(
        &self,
        handle: *mut alpm_handle_t,
        enable_downgrade: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        (self.alpm_sync_sysupgrade)(handle, enable_downgrade)
    }
    #[doc = " Add a package to the transaction."]
    #[doc = " If the package was loaded by alpm_pkg_load(), it will be freed upon"]
    #[doc = " \\link alpm_trans_release \\endlink invocation."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param pkg the package to add"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_add_pkg(
        &self,
        handle: *mut alpm_handle_t,
        pkg: *mut alpm_pkg_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_add_pkg)(handle, pkg)
    }
    #[doc = " Add a package removal to the transaction."]
    #[doc = " @param handle the context handle"]
    #[doc = " @param pkg the package to uninstall"]
    #[doc = " @return 0 on success, -1 on error (pm_errno is set accordingly)"]
    pub unsafe fn alpm_remove_pkg(
        &self,
        handle: *mut alpm_handle_t,
        pkg: *mut alpm_pkg_t,
    ) -> ::std::os::raw::c_int {
        (self.alpm_remove_pkg)(handle, pkg)
    }
    #[doc = " Check for new version of pkg in syncdbs."]
    #[doc = ""]
    #[doc = " If the same package appears multiple dbs only the first will be checked"]
    #[doc = ""]
    #[doc = " This only checks the syncdb for a newer version. It does not access the network at all."]
    #[doc = " See \\link alpm_db_update \\endlink to update a database."]
    pub unsafe fn alpm_sync_get_new_version(
        &self,
        pkg: *mut alpm_pkg_t,
        dbs_sync: *mut alpm_list_t,
    ) -> *mut alpm_pkg_t {
        (self.alpm_sync_get_new_version)(pkg, dbs_sync)
    }
    #[doc = " Get the md5 sum of file."]
    #[doc = " @param filename name of the file"]
    #[doc = " @return the checksum on success, NULL on error"]
    pub unsafe fn alpm_compute_md5sum(
        &self,
        filename: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char {
        (self.alpm_compute_md5sum)(filename)
    }
    #[doc = " Get the sha256 sum of file."]
    #[doc = " @param filename name of the file"]
    #[doc = " @return the checksum on success, NULL on error"]
    pub unsafe fn alpm_compute_sha256sum(
        &self,
        filename: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char {
        (self.alpm_compute_sha256sum)(filename)
    }
    #[doc = " Remove the database lock file"]
    #[doc = " @param handle the context handle"]
    #[doc = " @return 0 on success, -1 on error"]
    #[doc = ""]
    #[doc = " @note Safe to call from inside signal handlers."]
    pub unsafe fn alpm_unlock(&self, handle: *mut alpm_handle_t) -> ::std::os::raw::c_int {
        (self.alpm_unlock)(handle)
    }
    #[doc = " Get the version of library."]
    #[doc = " @return the library version, e.g. \"6.0.4\""]
    pub unsafe fn alpm_version(&self) -> *const ::std::os::raw::c_char {
        (self.alpm_version)()
    }
    #[doc = " Get the capabilities of the library."]
    #[doc = " @return a bitmask of the capabilities"]
    pub unsafe fn alpm_capabilities(&self) -> ::std::os::raw::c_int {
        (self.alpm_capabilities)()
    }
}