// Generated by gir (https://github.com/gtk-rs/gir @ 9d38245d1165)
// from .. (@ f5605560cc4d+)
// from ../gir-files (@ 7ebd4478b4a5)
// DO NOT EDIT

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

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

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

// Enums
pub type TrackerNotifierEventType = c_int;
pub const TRACKER_NOTIFIER_EVENT_CREATE: TrackerNotifierEventType = 0;
pub const TRACKER_NOTIFIER_EVENT_DELETE: TrackerNotifierEventType = 1;
pub const TRACKER_NOTIFIER_EVENT_UPDATE: TrackerNotifierEventType = 2;

pub type TrackerRdfFormat = c_int;
pub const TRACKER_RDF_FORMAT_TURTLE: TrackerRdfFormat = 0;
pub const TRACKER_RDF_FORMAT_TRIG: TrackerRdfFormat = 1;
pub const TRACKER_N_RDF_FORMATS: TrackerRdfFormat = 2;

pub type TrackerSerializeFlags = c_int;
pub const TRACKER_SERIALIZE_FLAGS_NONE: TrackerSerializeFlags = 0;

pub type TrackerSparqlError = c_int;
pub const TRACKER_SPARQL_ERROR_CONSTRAINT: TrackerSparqlError = 0;
pub const TRACKER_SPARQL_ERROR_INTERNAL: TrackerSparqlError = 1;
pub const TRACKER_SPARQL_ERROR_NO_SPACE: TrackerSparqlError = 2;
pub const TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND: TrackerSparqlError = 3;
pub const TRACKER_SPARQL_ERROR_OPEN_ERROR: TrackerSparqlError = 4;
pub const TRACKER_SPARQL_ERROR_PARSE: TrackerSparqlError = 5;
pub const TRACKER_SPARQL_ERROR_QUERY_FAILED: TrackerSparqlError = 6;
pub const TRACKER_SPARQL_ERROR_TYPE: TrackerSparqlError = 7;
pub const TRACKER_SPARQL_ERROR_UNKNOWN_CLASS: TrackerSparqlError = 8;
pub const TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH: TrackerSparqlError = 9;
pub const TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY: TrackerSparqlError = 10;
pub const TRACKER_SPARQL_ERROR_UNSUPPORTED: TrackerSparqlError = 11;
pub const TRACKER_SPARQL_ERROR_MISSING_LAST_MODIFIED_HEADER: TrackerSparqlError = 12;
pub const TRACKER_SPARQL_ERROR_INCOMPLETE_PROPERTY_DEFINITION: TrackerSparqlError = 13;
pub const TRACKER_SPARQL_N_ERRORS: TrackerSparqlError = 14;

pub type TrackerSparqlValueType = c_int;
pub const TRACKER_SPARQL_VALUE_TYPE_UNBOUND: TrackerSparqlValueType = 0;
pub const TRACKER_SPARQL_VALUE_TYPE_URI: TrackerSparqlValueType = 1;
pub const TRACKER_SPARQL_VALUE_TYPE_STRING: TrackerSparqlValueType = 2;
pub const TRACKER_SPARQL_VALUE_TYPE_INTEGER: TrackerSparqlValueType = 3;
pub const TRACKER_SPARQL_VALUE_TYPE_DOUBLE: TrackerSparqlValueType = 4;
pub const TRACKER_SPARQL_VALUE_TYPE_DATETIME: TrackerSparqlValueType = 5;
pub const TRACKER_SPARQL_VALUE_TYPE_BLANK_NODE: TrackerSparqlValueType = 6;
pub const TRACKER_SPARQL_VALUE_TYPE_BOOLEAN: TrackerSparqlValueType = 7;

// Constants
pub const TRACKER_PREFIX_DC: *const c_char =
    b"http://purl.org/dc/elements/1.1/\0" as *const u8 as *const c_char;
pub const TRACKER_PREFIX_MFO: *const c_char =
    b"http://tracker.api.gnome.org/ontology/v3/mfo#\0" as *const u8 as *const c_char;
pub const TRACKER_PREFIX_NAO: *const c_char =
    b"http://tracker.api.gnome.org/ontology/v3/nao#\0" as *const u8 as *const c_char;
pub const TRACKER_PREFIX_NCO: *const c_char =
    b"http://tracker.api.gnome.org/ontology/v3/nco#\0" as *const u8 as *const c_char;
pub const TRACKER_PREFIX_NFO: *const c_char =
    b"http://tracker.api.gnome.org/ontology/v3/nfo#\0" as *const u8 as *const c_char;
pub const TRACKER_PREFIX_NIE: *const c_char =
    b"http://tracker.api.gnome.org/ontology/v3/nie#\0" as *const u8 as *const c_char;
pub const TRACKER_PREFIX_NMM: *const c_char =
    b"http://tracker.api.gnome.org/ontology/v3/nmm#\0" as *const u8 as *const c_char;
pub const TRACKER_PREFIX_NRL: *const c_char =
    b"http://tracker.api.gnome.org/ontology/v3/nrl#\0" as *const u8 as *const c_char;
pub const TRACKER_PREFIX_OSINFO: *const c_char =
    b"http://tracker.api.gnome.org/ontology/v3/osinfo#\0" as *const u8 as *const c_char;
pub const TRACKER_PREFIX_RDF: *const c_char =
    b"http://www.w3.org/1999/02/22-rdf-syntax-ns#\0" as *const u8 as *const c_char;
pub const TRACKER_PREFIX_RDFS: *const c_char =
    b"http://www.w3.org/2000/01/rdf-schema#\0" as *const u8 as *const c_char;
pub const TRACKER_PREFIX_SLO: *const c_char =
    b"http://tracker.api.gnome.org/ontology/v3/slo#\0" as *const u8 as *const c_char;
pub const TRACKER_PREFIX_TRACKER: *const c_char =
    b"http://tracker.api.gnome.org/ontology/v3/tracker#\0" as *const u8 as *const c_char;
pub const TRACKER_PREFIX_XSD: *const c_char =
    b"http://www.w3.org/2001/XMLSchema#\0" as *const u8 as *const c_char;

// Flags
pub type TrackerSparqlConnectionFlags = c_uint;
pub const TRACKER_SPARQL_CONNECTION_FLAGS_NONE: TrackerSparqlConnectionFlags = 0;
pub const TRACKER_SPARQL_CONNECTION_FLAGS_READONLY: TrackerSparqlConnectionFlags = 1;
pub const TRACKER_SPARQL_CONNECTION_FLAGS_FTS_ENABLE_STEMMER: TrackerSparqlConnectionFlags = 2;
pub const TRACKER_SPARQL_CONNECTION_FLAGS_FTS_ENABLE_UNACCENT: TrackerSparqlConnectionFlags = 4;
pub const TRACKER_SPARQL_CONNECTION_FLAGS_FTS_ENABLE_STOP_WORDS: TrackerSparqlConnectionFlags = 8;
pub const TRACKER_SPARQL_CONNECTION_FLAGS_FTS_IGNORE_NUMBERS: TrackerSparqlConnectionFlags = 16;
pub const TRACKER_SPARQL_CONNECTION_FLAGS_ANONYMOUS_BNODES: TrackerSparqlConnectionFlags = 32;

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

pub type TrackerBatchClass = *mut _TrackerBatchClass;

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

pub type TrackerEndpointClass = *mut _TrackerEndpointClass;

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

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

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

pub type TrackerNotifierClass = *mut _TrackerNotifierClass;

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

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

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

pub type TrackerResourceClass = *mut _TrackerResourceClass;

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

pub type TrackerSparqlConnectionClass = *mut _TrackerSparqlConnectionClass;

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

pub type TrackerSparqlCursorClass = *mut _TrackerSparqlCursorClass;

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

pub type TrackerSparqlStatementClass = *mut _TrackerSparqlStatementClass;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[link(name = "tracker-sparql-3.0")]
extern "C" {

    //=========================================================================
    // TrackerNotifierEvent
    //=========================================================================
    pub fn tracker_notifier_event_get_type() -> GType;
    pub fn tracker_notifier_event_get_event_type(
        event: *mut TrackerNotifierEvent,
    ) -> TrackerNotifierEventType;
    pub fn tracker_notifier_event_get_id(event: *mut TrackerNotifierEvent) -> i64;
    pub fn tracker_notifier_event_get_urn(event: *mut TrackerNotifierEvent) -> *const c_char;

    //=========================================================================
    // TrackerBatch
    //=========================================================================
    pub fn tracker_batch_get_type() -> GType;
    #[cfg(any(feature = "v3_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_1")))]
    pub fn tracker_batch_add_resource(
        batch: *mut TrackerBatch,
        graph: *const c_char,
        resource: *mut TrackerResource,
    );
    #[cfg(any(feature = "v3_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_1")))]
    pub fn tracker_batch_add_sparql(batch: *mut TrackerBatch, sparql: *const c_char);
    #[cfg(any(feature = "v3_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_1")))]
    pub fn tracker_batch_execute(
        batch: *mut TrackerBatch,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    #[cfg(any(feature = "v3_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_1")))]
    pub fn tracker_batch_execute_async(
        batch: *mut TrackerBatch,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    #[cfg(any(feature = "v3_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_1")))]
    pub fn tracker_batch_execute_finish(
        batch: *mut TrackerBatch,
        res: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn tracker_batch_get_connection(batch: *mut TrackerBatch) -> *mut TrackerSparqlConnection;

    //=========================================================================
    // TrackerEndpoint
    //=========================================================================
    pub fn tracker_endpoint_get_type() -> GType;
    pub fn tracker_endpoint_get_sparql_connection(
        endpoint: *mut TrackerEndpoint,
    ) -> *mut TrackerSparqlConnection;

    //=========================================================================
    // TrackerEndpointDBus
    //=========================================================================
    pub fn tracker_endpoint_dbus_get_type() -> GType;
    pub fn tracker_endpoint_dbus_new(
        sparql_connection: *mut TrackerSparqlConnection,
        dbus_connection: *mut gio::GDBusConnection,
        object_path: *const c_char,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> *mut TrackerEndpointDBus;

    //=========================================================================
    // TrackerEndpointHttp
    //=========================================================================
    pub fn tracker_endpoint_http_get_type() -> GType;
    pub fn tracker_endpoint_http_new(
        sparql_connection: *mut TrackerSparqlConnection,
        port: c_uint,
        certificate: *mut gio::GTlsCertificate,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> *mut TrackerEndpointHttp;

    //=========================================================================
    // TrackerNamespaceManager
    //=========================================================================
    pub fn tracker_namespace_manager_get_type() -> GType;
    pub fn tracker_namespace_manager_new() -> *mut TrackerNamespaceManager;
    pub fn tracker_namespace_manager_get_default() -> *mut TrackerNamespaceManager;
    pub fn tracker_namespace_manager_add_prefix(
        self_: *mut TrackerNamespaceManager,
        prefix: *const c_char,
        ns: *const c_char,
    );
    #[cfg(any(feature = "v3_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_3")))]
    pub fn tracker_namespace_manager_compress_uri(
        self_: *mut TrackerNamespaceManager,
        uri: *const c_char,
    ) -> *mut c_char;
    pub fn tracker_namespace_manager_expand_uri(
        self_: *mut TrackerNamespaceManager,
        compact_uri: *const c_char,
    ) -> *mut c_char;
    pub fn tracker_namespace_manager_foreach(
        self_: *mut TrackerNamespaceManager,
        func: glib::GHFunc,
        user_data: gpointer,
    );
    pub fn tracker_namespace_manager_has_prefix(
        self_: *mut TrackerNamespaceManager,
        prefix: *const c_char,
    ) -> gboolean;
    pub fn tracker_namespace_manager_lookup_prefix(
        self_: *mut TrackerNamespaceManager,
        prefix: *const c_char,
    ) -> *const c_char;
    pub fn tracker_namespace_manager_print_turtle(
        self_: *mut TrackerNamespaceManager,
    ) -> *mut c_char;

    //=========================================================================
    // TrackerNotifier
    //=========================================================================
    pub fn tracker_notifier_get_type() -> GType;
    pub fn tracker_notifier_signal_subscribe(
        notifier: *mut TrackerNotifier,
        connection: *mut gio::GDBusConnection,
        service: *const c_char,
        object_path: *const c_char,
        graph: *const c_char,
    ) -> c_uint;
    pub fn tracker_notifier_signal_unsubscribe(notifier: *mut TrackerNotifier, handler_id: c_uint);

    //=========================================================================
    // TrackerResource
    //=========================================================================
    pub fn tracker_resource_get_type() -> GType;
    pub fn tracker_resource_new(identifier: *const c_char) -> *mut TrackerResource;
    pub fn tracker_resource_deserialize(variant: *mut glib::GVariant) -> *mut TrackerResource;
    pub fn tracker_resource_add_boolean(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: gboolean,
    );
    #[cfg(any(feature = "v3_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_2")))]
    pub fn tracker_resource_add_datetime(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: *mut glib::GDateTime,
    );
    pub fn tracker_resource_add_double(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: c_double,
    );
    pub fn tracker_resource_add_gvalue(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: *const gobject::GValue,
    );
    pub fn tracker_resource_add_int(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: c_int,
    );
    pub fn tracker_resource_add_int64(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: i64,
    );
    pub fn tracker_resource_add_relation(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        resource: *mut TrackerResource,
    );
    pub fn tracker_resource_add_string(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: *const c_char,
    );
    pub fn tracker_resource_add_take_relation(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        resource: *mut TrackerResource,
    );
    pub fn tracker_resource_add_uri(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: *const c_char,
    );
    pub fn tracker_resource_get_first_boolean(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
    ) -> gboolean;
    #[cfg(any(feature = "v3_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_2")))]
    pub fn tracker_resource_get_first_datetime(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
    ) -> *mut glib::GDateTime;
    pub fn tracker_resource_get_first_double(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
    ) -> c_double;
    pub fn tracker_resource_get_first_int(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
    ) -> c_int;
    pub fn tracker_resource_get_first_int64(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
    ) -> i64;
    pub fn tracker_resource_get_first_relation(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
    ) -> *mut TrackerResource;
    pub fn tracker_resource_get_first_string(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
    ) -> *const c_char;
    pub fn tracker_resource_get_first_uri(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
    ) -> *const c_char;
    pub fn tracker_resource_get_identifier(self_: *mut TrackerResource) -> *const c_char;
    pub fn tracker_resource_get_properties(resource: *mut TrackerResource) -> *mut glib::GList;
    #[cfg(any(feature = "v3_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_1")))]
    pub fn tracker_resource_get_property_overwrite(
        resource: *mut TrackerResource,
        property_uri: *const c_char,
    ) -> gboolean;
    pub fn tracker_resource_get_values(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
    ) -> *mut glib::GList;
    pub fn tracker_resource_identifier_compare_func(
        resource: *mut TrackerResource,
        identifier: *const c_char,
    ) -> c_int;
    pub fn tracker_resource_print_jsonld(
        self_: *mut TrackerResource,
        namespaces: *mut TrackerNamespaceManager,
    ) -> *mut c_char;
    pub fn tracker_resource_print_sparql_update(
        self_: *mut TrackerResource,
        namespaces: *mut TrackerNamespaceManager,
        graph_id: *const c_char,
    ) -> *mut c_char;
    pub fn tracker_resource_print_turtle(
        self_: *mut TrackerResource,
        namespaces: *mut TrackerNamespaceManager,
    ) -> *mut c_char;
    pub fn tracker_resource_serialize(resource: *mut TrackerResource) -> *mut glib::GVariant;
    pub fn tracker_resource_set_boolean(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: gboolean,
    );
    #[cfg(any(feature = "v3_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_2")))]
    pub fn tracker_resource_set_datetime(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: *mut glib::GDateTime,
    );
    pub fn tracker_resource_set_double(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: c_double,
    );
    pub fn tracker_resource_set_gvalue(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: *const gobject::GValue,
    );
    pub fn tracker_resource_set_identifier(self_: *mut TrackerResource, identifier: *const c_char);
    pub fn tracker_resource_set_int(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: c_int,
    );
    pub fn tracker_resource_set_int64(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: i64,
    );
    pub fn tracker_resource_set_relation(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        resource: *mut TrackerResource,
    );
    pub fn tracker_resource_set_string(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: *const c_char,
    );
    pub fn tracker_resource_set_take_relation(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        resource: *mut TrackerResource,
    );
    pub fn tracker_resource_set_uri(
        self_: *mut TrackerResource,
        property_uri: *const c_char,
        value: *const c_char,
    );

    //=========================================================================
    // TrackerSparqlConnection
    //=========================================================================
    pub fn tracker_sparql_connection_get_type() -> GType;
    pub fn tracker_sparql_connection_bus_new(
        service_name: *const c_char,
        object_path: *const c_char,
        dbus_connection: *mut gio::GDBusConnection,
        error: *mut *mut glib::GError,
    ) -> *mut TrackerSparqlConnection;
    #[cfg(any(feature = "v3_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_1")))]
    pub fn tracker_sparql_connection_bus_new_finish(
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> *mut TrackerSparqlConnection;
    pub fn tracker_sparql_connection_new(
        flags: TrackerSparqlConnectionFlags,
        store: *mut gio::GFile,
        ontology: *mut gio::GFile,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> *mut TrackerSparqlConnection;
    pub fn tracker_sparql_connection_new_finish(
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> *mut TrackerSparqlConnection;
    pub fn tracker_sparql_connection_remote_new(
        uri_base: *const c_char,
    ) -> *mut TrackerSparqlConnection;
    #[cfg(any(feature = "v3_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_1")))]
    pub fn tracker_sparql_connection_bus_new_async(
        service_name: *const c_char,
        object_path: *const c_char,
        dbus_connection: *mut gio::GDBusConnection,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn tracker_sparql_connection_new_async(
        flags: TrackerSparqlConnectionFlags,
        store: *mut gio::GFile,
        ontology: *mut gio::GFile,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn tracker_sparql_connection_close(connection: *mut TrackerSparqlConnection);
    pub fn tracker_sparql_connection_close_async(
        connection: *mut TrackerSparqlConnection,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn tracker_sparql_connection_close_finish(
        connection: *mut TrackerSparqlConnection,
        res: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn tracker_sparql_connection_create_batch(
        connection: *mut TrackerSparqlConnection,
    ) -> *mut TrackerBatch;
    pub fn tracker_sparql_connection_create_notifier(
        connection: *mut TrackerSparqlConnection,
    ) -> *mut TrackerNotifier;
    pub fn tracker_sparql_connection_get_namespace_manager(
        connection: *mut TrackerSparqlConnection,
    ) -> *mut TrackerNamespaceManager;
    #[cfg(any(feature = "v3_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_3")))]
    pub fn tracker_sparql_connection_load_statement_from_gresource(
        connection: *mut TrackerSparqlConnection,
        resource_path: *const c_char,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> *mut TrackerSparqlStatement;
    #[cfg(any(feature = "v3_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_3")))]
    pub fn tracker_sparql_connection_map_connection(
        connection: *mut TrackerSparqlConnection,
        handle_name: *const c_char,
        service_connection: *mut TrackerSparqlConnection,
    );
    pub fn tracker_sparql_connection_query(
        connection: *mut TrackerSparqlConnection,
        sparql: *const c_char,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> *mut TrackerSparqlCursor;
    pub fn tracker_sparql_connection_query_async(
        connection: *mut TrackerSparqlConnection,
        sparql: *const c_char,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn tracker_sparql_connection_query_finish(
        connection: *mut TrackerSparqlConnection,
        res: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> *mut TrackerSparqlCursor;
    pub fn tracker_sparql_connection_query_statement(
        connection: *mut TrackerSparqlConnection,
        sparql: *const c_char,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> *mut TrackerSparqlStatement;
    #[cfg(any(feature = "v3_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_3")))]
    pub fn tracker_sparql_connection_serialize_async(
        connection: *mut TrackerSparqlConnection,
        flags: TrackerSerializeFlags,
        format: TrackerRdfFormat,
        query: *const c_char,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    #[cfg(any(feature = "v3_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_3")))]
    pub fn tracker_sparql_connection_serialize_finish(
        connection: *mut TrackerSparqlConnection,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> *mut gio::GInputStream;
    pub fn tracker_sparql_connection_update(
        connection: *mut TrackerSparqlConnection,
        sparql: *const c_char,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    );
    pub fn tracker_sparql_connection_update_array_async(
        connection: *mut TrackerSparqlConnection,
        sparql: *mut *mut c_char,
        sparql_length: c_int,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn tracker_sparql_connection_update_array_finish(
        connection: *mut TrackerSparqlConnection,
        res: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn tracker_sparql_connection_update_async(
        connection: *mut TrackerSparqlConnection,
        sparql: *const c_char,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn tracker_sparql_connection_update_blank(
        connection: *mut TrackerSparqlConnection,
        sparql: *const c_char,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> *mut glib::GVariant;
    pub fn tracker_sparql_connection_update_blank_async(
        connection: *mut TrackerSparqlConnection,
        sparql: *const c_char,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn tracker_sparql_connection_update_blank_finish(
        connection: *mut TrackerSparqlConnection,
        res: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> *mut glib::GVariant;
    pub fn tracker_sparql_connection_update_finish(
        connection: *mut TrackerSparqlConnection,
        res: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    );
    #[cfg(any(feature = "v3_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_1")))]
    pub fn tracker_sparql_connection_update_resource(
        connection: *mut TrackerSparqlConnection,
        graph: *const c_char,
        resource: *mut TrackerResource,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    #[cfg(any(feature = "v3_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_1")))]
    pub fn tracker_sparql_connection_update_resource_async(
        connection: *mut TrackerSparqlConnection,
        graph: *const c_char,
        resource: *mut TrackerResource,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    #[cfg(any(feature = "v3_1", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_1")))]
    pub fn tracker_sparql_connection_update_resource_finish(
        connection: *mut TrackerSparqlConnection,
        res: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // TrackerSparqlCursor
    //=========================================================================
    pub fn tracker_sparql_cursor_get_type() -> GType;
    pub fn tracker_sparql_cursor_close(cursor: *mut TrackerSparqlCursor);
    pub fn tracker_sparql_cursor_get_boolean(
        cursor: *mut TrackerSparqlCursor,
        column: c_int,
    ) -> gboolean;
    pub fn tracker_sparql_cursor_get_connection(
        cursor: *mut TrackerSparqlCursor,
    ) -> *mut TrackerSparqlConnection;
    #[cfg(any(feature = "v3_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_2")))]
    pub fn tracker_sparql_cursor_get_datetime(
        cursor: *mut TrackerSparqlCursor,
        column: c_int,
    ) -> *mut glib::GDateTime;
    pub fn tracker_sparql_cursor_get_double(
        cursor: *mut TrackerSparqlCursor,
        column: c_int,
    ) -> c_double;
    pub fn tracker_sparql_cursor_get_integer(
        cursor: *mut TrackerSparqlCursor,
        column: c_int,
    ) -> i64;
    pub fn tracker_sparql_cursor_get_n_columns(cursor: *mut TrackerSparqlCursor) -> c_int;
    pub fn tracker_sparql_cursor_get_string(
        cursor: *mut TrackerSparqlCursor,
        column: c_int,
        length: *mut c_long,
    ) -> *const c_char;
    pub fn tracker_sparql_cursor_get_value_type(
        cursor: *mut TrackerSparqlCursor,
        column: c_int,
    ) -> TrackerSparqlValueType;
    pub fn tracker_sparql_cursor_get_variable_name(
        cursor: *mut TrackerSparqlCursor,
        column: c_int,
    ) -> *const c_char;
    pub fn tracker_sparql_cursor_is_bound(
        cursor: *mut TrackerSparqlCursor,
        column: c_int,
    ) -> gboolean;
    pub fn tracker_sparql_cursor_next(
        cursor: *mut TrackerSparqlCursor,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn tracker_sparql_cursor_next_async(
        cursor: *mut TrackerSparqlCursor,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn tracker_sparql_cursor_next_finish(
        cursor: *mut TrackerSparqlCursor,
        res: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn tracker_sparql_cursor_rewind(cursor: *mut TrackerSparqlCursor);

    //=========================================================================
    // TrackerSparqlStatement
    //=========================================================================
    pub fn tracker_sparql_statement_get_type() -> GType;
    pub fn tracker_sparql_statement_bind_boolean(
        stmt: *mut TrackerSparqlStatement,
        name: *const c_char,
        value: gboolean,
    );
    #[cfg(any(feature = "v3_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_2")))]
    pub fn tracker_sparql_statement_bind_datetime(
        stmt: *mut TrackerSparqlStatement,
        name: *const c_char,
        value: *mut glib::GDateTime,
    );
    pub fn tracker_sparql_statement_bind_double(
        stmt: *mut TrackerSparqlStatement,
        name: *const c_char,
        value: c_double,
    );
    pub fn tracker_sparql_statement_bind_int(
        stmt: *mut TrackerSparqlStatement,
        name: *const c_char,
        value: i64,
    );
    pub fn tracker_sparql_statement_bind_string(
        stmt: *mut TrackerSparqlStatement,
        name: *const c_char,
        value: *const c_char,
    );
    pub fn tracker_sparql_statement_clear_bindings(stmt: *mut TrackerSparqlStatement);
    pub fn tracker_sparql_statement_execute(
        stmt: *mut TrackerSparqlStatement,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> *mut TrackerSparqlCursor;
    pub fn tracker_sparql_statement_execute_async(
        stmt: *mut TrackerSparqlStatement,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn tracker_sparql_statement_execute_finish(
        stmt: *mut TrackerSparqlStatement,
        res: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> *mut TrackerSparqlCursor;
    pub fn tracker_sparql_statement_get_connection(
        stmt: *mut TrackerSparqlStatement,
    ) -> *mut TrackerSparqlConnection;
    pub fn tracker_sparql_statement_get_sparql(stmt: *mut TrackerSparqlStatement) -> *const c_char;
    #[cfg(any(feature = "v3_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_3")))]
    pub fn tracker_sparql_statement_serialize_async(
        stmt: *mut TrackerSparqlStatement,
        flags: TrackerSerializeFlags,
        format: TrackerRdfFormat,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    #[cfg(any(feature = "v3_3", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_3")))]
    pub fn tracker_sparql_statement_serialize_finish(
        stmt: *mut TrackerSparqlStatement,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> *mut gio::GInputStream;

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn tracker_check_version(
        required_major: c_uint,
        required_minor: c_uint,
        required_micro: c_uint,
    ) -> *const c_char;
    pub fn tracker_sparql_error_quark() -> glib::GQuark;
    pub fn tracker_sparql_escape_string(literal: *const c_char) -> *mut c_char;
    pub fn tracker_sparql_escape_uri(uri: *const c_char) -> *mut c_char;
    pub fn tracker_sparql_escape_uri_printf(format: *const c_char, ...) -> *mut c_char;
    //pub fn tracker_sparql_escape_uri_vprintf(format: *const c_char, args: /*Unimplemented*/va_list) -> *mut c_char;
    pub fn tracker_sparql_get_ontology_nepomuk() -> *mut gio::GFile;
    pub fn tracker_sparql_get_uuid_urn() -> *mut c_char;

}