goa-sys 0.0.3

// This file was generated by gir (https://github.com/gtk-rs/gir @ 0ab7700)
// from gir-files (https://github.com/gtk-rs/gir-files @ ???)
// 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)]

extern crate libc;
extern crate gio_sys as gio;
extern crate glib_sys as glib;
extern crate gobject_sys as gobject;

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

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

// Enums
pub type GoaError = c_int;
pub const GOA_ERROR_FAILED: GoaError = 0;
pub const GOA_ERROR_NOT_SUPPORTED: GoaError = 1;
pub const GOA_ERROR_DIALOG_DISMISSED: GoaError = 2;
pub const GOA_ERROR_ACCOUNT_EXISTS: GoaError = 3;
pub const GOA_ERROR_NOT_AUTHORIZED: GoaError = 4;
pub const GOA_ERROR_SSL: GoaError = 5;

// Constants
pub const GOA_ERROR_NUM_ENTRIES: c_int = 6;

// Records
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaAccountIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_ensure_credentials: Option<unsafe extern "C" fn(*mut GoaAccount, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub handle_remove: Option<unsafe extern "C" fn(*mut GoaAccount, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub get_attention_needed: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_calendar_disabled: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_chat_disabled: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_contacts_disabled: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_documents_disabled: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_id: Option<unsafe extern "C" fn(*mut GoaAccount) -> *const c_char>,
    pub get_identity: Option<unsafe extern "C" fn(*mut GoaAccount) -> *const c_char>,
    pub get_is_temporary: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_mail_disabled: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_presentation_identity: Option<unsafe extern "C" fn(*mut GoaAccount) -> *const c_char>,
    pub get_provider_icon: Option<unsafe extern "C" fn(*mut GoaAccount) -> *const c_char>,
    pub get_provider_name: Option<unsafe extern "C" fn(*mut GoaAccount) -> *const c_char>,
    pub get_provider_type: Option<unsafe extern "C" fn(*mut GoaAccount) -> *const c_char>,
    pub get_ticketing_disabled: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_files_disabled: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_photos_disabled: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_printers_disabled: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_read_later_disabled: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_maps_disabled: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_is_locked: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_music_disabled: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
    pub get_todo_disabled: Option<unsafe extern "C" fn(*mut GoaAccount) -> gboolean>,
}

impl ::std::fmt::Debug for GoaAccountIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaAccountIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .field("handle_ensure_credentials", &self.handle_ensure_credentials)
         .field("handle_remove", &self.handle_remove)
         .field("get_attention_needed", &self.get_attention_needed)
         .field("get_calendar_disabled", &self.get_calendar_disabled)
         .field("get_chat_disabled", &self.get_chat_disabled)
         .field("get_contacts_disabled", &self.get_contacts_disabled)
         .field("get_documents_disabled", &self.get_documents_disabled)
         .field("get_id", &self.get_id)
         .field("get_identity", &self.get_identity)
         .field("get_is_temporary", &self.get_is_temporary)
         .field("get_mail_disabled", &self.get_mail_disabled)
         .field("get_presentation_identity", &self.get_presentation_identity)
         .field("get_provider_icon", &self.get_provider_icon)
         .field("get_provider_name", &self.get_provider_name)
         .field("get_provider_type", &self.get_provider_type)
         .field("get_ticketing_disabled", &self.get_ticketing_disabled)
         .field("get_files_disabled", &self.get_files_disabled)
         .field("get_photos_disabled", &self.get_photos_disabled)
         .field("get_printers_disabled", &self.get_printers_disabled)
         .field("get_read_later_disabled", &self.get_read_later_disabled)
         .field("get_maps_disabled", &self.get_maps_disabled)
         .field("get_is_locked", &self.get_is_locked)
         .field("get_music_disabled", &self.get_music_disabled)
         .field("get_todo_disabled", &self.get_todo_disabled)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaAccountProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaAccountProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaAccountProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaAccountProxyPrivate(c_void);

pub type GoaAccountProxyPrivate = *mut _GoaAccountProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaAccountSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaAccountSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaAccountSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaAccountSkeletonPrivate(c_void);

pub type GoaAccountSkeletonPrivate = *mut _GoaAccountSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaCalendarIface {
    pub parent_iface: gobject::GTypeInterface,
    pub get_accept_ssl_errors: Option<unsafe extern "C" fn(*mut GoaCalendar) -> gboolean>,
    pub get_uri: Option<unsafe extern "C" fn(*mut GoaCalendar) -> *const c_char>,
}

impl ::std::fmt::Debug for GoaCalendarIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaCalendarIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .field("get_accept_ssl_errors", &self.get_accept_ssl_errors)
         .field("get_uri", &self.get_uri)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaCalendarProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaCalendarProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaCalendarProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaCalendarProxyPrivate(c_void);

pub type GoaCalendarProxyPrivate = *mut _GoaCalendarProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaCalendarSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaCalendarSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaCalendarSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaCalendarSkeletonPrivate(c_void);

pub type GoaCalendarSkeletonPrivate = *mut _GoaCalendarSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaChatIface {
    pub parent_iface: gobject::GTypeInterface,
}

impl ::std::fmt::Debug for GoaChatIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaChatIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaChatProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaChatProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaChatProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaChatProxyPrivate(c_void);

pub type GoaChatProxyPrivate = *mut _GoaChatProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaChatSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaChatSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaChatSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaChatSkeletonPrivate(c_void);

pub type GoaChatSkeletonPrivate = *mut _GoaChatSkeletonPrivate;

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

impl ::std::fmt::Debug for GoaClientClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaClientClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaContactsIface {
    pub parent_iface: gobject::GTypeInterface,
    pub get_accept_ssl_errors: Option<unsafe extern "C" fn(*mut GoaContacts) -> gboolean>,
    pub get_uri: Option<unsafe extern "C" fn(*mut GoaContacts) -> *const c_char>,
}

impl ::std::fmt::Debug for GoaContactsIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaContactsIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .field("get_accept_ssl_errors", &self.get_accept_ssl_errors)
         .field("get_uri", &self.get_uri)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaContactsProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaContactsProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaContactsProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaContactsProxyPrivate(c_void);

pub type GoaContactsProxyPrivate = *mut _GoaContactsProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaContactsSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaContactsSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaContactsSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaContactsSkeletonPrivate(c_void);

pub type GoaContactsSkeletonPrivate = *mut _GoaContactsSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaDocumentsIface {
    pub parent_iface: gobject::GTypeInterface,
}

impl ::std::fmt::Debug for GoaDocumentsIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaDocumentsIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaDocumentsProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaDocumentsProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaDocumentsProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaDocumentsProxyPrivate(c_void);

pub type GoaDocumentsProxyPrivate = *mut _GoaDocumentsProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaDocumentsSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaDocumentsSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaDocumentsSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaDocumentsSkeletonPrivate(c_void);

pub type GoaDocumentsSkeletonPrivate = *mut _GoaDocumentsSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaExchangeIface {
    pub parent_iface: gobject::GTypeInterface,
    pub get_host: Option<unsafe extern "C" fn(*mut GoaExchange) -> *const c_char>,
    pub get_accept_ssl_errors: Option<unsafe extern "C" fn(*mut GoaExchange) -> gboolean>,
}

impl ::std::fmt::Debug for GoaExchangeIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaExchangeIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .field("get_host", &self.get_host)
         .field("get_accept_ssl_errors", &self.get_accept_ssl_errors)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaExchangeProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaExchangeProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaExchangeProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaExchangeProxyPrivate(c_void);

pub type GoaExchangeProxyPrivate = *mut _GoaExchangeProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaExchangeSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaExchangeSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaExchangeSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaExchangeSkeletonPrivate(c_void);

pub type GoaExchangeSkeletonPrivate = *mut _GoaExchangeSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaFilesIface {
    pub parent_iface: gobject::GTypeInterface,
    pub get_accept_ssl_errors: Option<unsafe extern "C" fn(*mut GoaFiles) -> gboolean>,
    pub get_uri: Option<unsafe extern "C" fn(*mut GoaFiles) -> *const c_char>,
}

impl ::std::fmt::Debug for GoaFilesIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaFilesIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .field("get_accept_ssl_errors", &self.get_accept_ssl_errors)
         .field("get_uri", &self.get_uri)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaFilesProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaFilesProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaFilesProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaFilesProxyPrivate(c_void);

pub type GoaFilesProxyPrivate = *mut _GoaFilesProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaFilesSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaFilesSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaFilesSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaFilesSkeletonPrivate(c_void);

pub type GoaFilesSkeletonPrivate = *mut _GoaFilesSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMailIface {
    pub parent_iface: gobject::GTypeInterface,
    pub get_email_address: Option<unsafe extern "C" fn(*mut GoaMail) -> *const c_char>,
    pub get_imap_host: Option<unsafe extern "C" fn(*mut GoaMail) -> *const c_char>,
    pub get_imap_supported: Option<unsafe extern "C" fn(*mut GoaMail) -> gboolean>,
    pub get_imap_use_tls: Option<unsafe extern "C" fn(*mut GoaMail) -> gboolean>,
    pub get_imap_user_name: Option<unsafe extern "C" fn(*mut GoaMail) -> *const c_char>,
    pub get_smtp_host: Option<unsafe extern "C" fn(*mut GoaMail) -> *const c_char>,
    pub get_smtp_supported: Option<unsafe extern "C" fn(*mut GoaMail) -> gboolean>,
    pub get_smtp_use_tls: Option<unsafe extern "C" fn(*mut GoaMail) -> gboolean>,
    pub get_smtp_user_name: Option<unsafe extern "C" fn(*mut GoaMail) -> *const c_char>,
    pub get_imap_accept_ssl_errors: Option<unsafe extern "C" fn(*mut GoaMail) -> gboolean>,
    pub get_imap_use_ssl: Option<unsafe extern "C" fn(*mut GoaMail) -> gboolean>,
    pub get_name: Option<unsafe extern "C" fn(*mut GoaMail) -> *const c_char>,
    pub get_smtp_accept_ssl_errors: Option<unsafe extern "C" fn(*mut GoaMail) -> gboolean>,
    pub get_smtp_use_auth: Option<unsafe extern "C" fn(*mut GoaMail) -> gboolean>,
    pub get_smtp_use_ssl: Option<unsafe extern "C" fn(*mut GoaMail) -> gboolean>,
    pub get_smtp_auth_login: Option<unsafe extern "C" fn(*mut GoaMail) -> gboolean>,
    pub get_smtp_auth_plain: Option<unsafe extern "C" fn(*mut GoaMail) -> gboolean>,
    pub get_smtp_auth_xoauth2: Option<unsafe extern "C" fn(*mut GoaMail) -> gboolean>,
}

impl ::std::fmt::Debug for GoaMailIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMailIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .field("get_email_address", &self.get_email_address)
         .field("get_imap_host", &self.get_imap_host)
         .field("get_imap_supported", &self.get_imap_supported)
         .field("get_imap_use_tls", &self.get_imap_use_tls)
         .field("get_imap_user_name", &self.get_imap_user_name)
         .field("get_smtp_host", &self.get_smtp_host)
         .field("get_smtp_supported", &self.get_smtp_supported)
         .field("get_smtp_use_tls", &self.get_smtp_use_tls)
         .field("get_smtp_user_name", &self.get_smtp_user_name)
         .field("get_imap_accept_ssl_errors", &self.get_imap_accept_ssl_errors)
         .field("get_imap_use_ssl", &self.get_imap_use_ssl)
         .field("get_name", &self.get_name)
         .field("get_smtp_accept_ssl_errors", &self.get_smtp_accept_ssl_errors)
         .field("get_smtp_use_auth", &self.get_smtp_use_auth)
         .field("get_smtp_use_ssl", &self.get_smtp_use_ssl)
         .field("get_smtp_auth_login", &self.get_smtp_auth_login)
         .field("get_smtp_auth_plain", &self.get_smtp_auth_plain)
         .field("get_smtp_auth_xoauth2", &self.get_smtp_auth_xoauth2)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMailProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaMailProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMailProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaMailProxyPrivate(c_void);

pub type GoaMailProxyPrivate = *mut _GoaMailProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMailSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaMailSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMailSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaMailSkeletonPrivate(c_void);

pub type GoaMailSkeletonPrivate = *mut _GoaMailSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaManagerIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_add_account: Option<unsafe extern "C" fn(*mut GoaManager, *mut gio::GDBusMethodInvocation, *const c_char, *const c_char, *const c_char, *mut glib::GVariant, *mut glib::GVariant) -> gboolean>,
}

impl ::std::fmt::Debug for GoaManagerIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaManagerIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .field("handle_add_account", &self.handle_add_account)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaManagerProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaManagerProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaManagerProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaManagerProxyPrivate(c_void);

pub type GoaManagerProxyPrivate = *mut _GoaManagerProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaManagerSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaManagerSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaManagerSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaManagerSkeletonPrivate(c_void);

pub type GoaManagerSkeletonPrivate = *mut _GoaManagerSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMapsIface {
    pub parent_iface: gobject::GTypeInterface,
}

impl ::std::fmt::Debug for GoaMapsIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMapsIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMapsProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaMapsProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMapsProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaMapsProxyPrivate(c_void);

pub type GoaMapsProxyPrivate = *mut _GoaMapsProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMapsSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaMapsSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMapsSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaMapsSkeletonPrivate(c_void);

pub type GoaMapsSkeletonPrivate = *mut _GoaMapsSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMediaServerIface {
    pub parent_iface: gobject::GTypeInterface,
    pub get_dlna_supported: Option<unsafe extern "C" fn(*mut GoaMediaServer) -> gboolean>,
    pub get_udn: Option<unsafe extern "C" fn(*mut GoaMediaServer) -> *const c_char>,
}

impl ::std::fmt::Debug for GoaMediaServerIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMediaServerIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .field("get_dlna_supported", &self.get_dlna_supported)
         .field("get_udn", &self.get_udn)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMediaServerProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaMediaServerProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMediaServerProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaMediaServerProxyPrivate(c_void);

pub type GoaMediaServerProxyPrivate = *mut _GoaMediaServerProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMediaServerSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaMediaServerSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMediaServerSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaMediaServerSkeletonPrivate(c_void);

pub type GoaMediaServerSkeletonPrivate = *mut _GoaMediaServerSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMusicIface {
    pub parent_iface: gobject::GTypeInterface,
}

impl ::std::fmt::Debug for GoaMusicIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMusicIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMusicProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaMusicProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMusicProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaMusicProxyPrivate(c_void);

pub type GoaMusicProxyPrivate = *mut _GoaMusicProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMusicSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaMusicSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMusicSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaMusicSkeletonPrivate(c_void);

pub type GoaMusicSkeletonPrivate = *mut _GoaMusicSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaOAuth2BasedIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_get_access_token: Option<unsafe extern "C" fn(*mut GoaOAuth2Based, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub get_client_id: Option<unsafe extern "C" fn(*mut GoaOAuth2Based) -> *const c_char>,
    pub get_client_secret: Option<unsafe extern "C" fn(*mut GoaOAuth2Based) -> *const c_char>,
}

impl ::std::fmt::Debug for GoaOAuth2BasedIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaOAuth2BasedIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .field("handle_get_access_token", &self.handle_get_access_token)
         .field("get_client_id", &self.get_client_id)
         .field("get_client_secret", &self.get_client_secret)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaOAuth2BasedProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaOAuth2BasedProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaOAuth2BasedProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaOAuth2BasedProxyPrivate(c_void);

pub type GoaOAuth2BasedProxyPrivate = *mut _GoaOAuth2BasedProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaOAuth2BasedSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaOAuth2BasedSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaOAuth2BasedSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaOAuth2BasedSkeletonPrivate(c_void);

pub type GoaOAuth2BasedSkeletonPrivate = *mut _GoaOAuth2BasedSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaOAuthBasedIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_get_access_token: Option<unsafe extern "C" fn(*mut GoaOAuthBased, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub get_consumer_key: Option<unsafe extern "C" fn(*mut GoaOAuthBased) -> *const c_char>,
    pub get_consumer_secret: Option<unsafe extern "C" fn(*mut GoaOAuthBased) -> *const c_char>,
}

impl ::std::fmt::Debug for GoaOAuthBasedIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaOAuthBasedIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .field("handle_get_access_token", &self.handle_get_access_token)
         .field("get_consumer_key", &self.get_consumer_key)
         .field("get_consumer_secret", &self.get_consumer_secret)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaOAuthBasedProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaOAuthBasedProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaOAuthBasedProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaOAuthBasedProxyPrivate(c_void);

pub type GoaOAuthBasedProxyPrivate = *mut _GoaOAuthBasedProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaOAuthBasedSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaOAuthBasedSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaOAuthBasedSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaOAuthBasedSkeletonPrivate(c_void);

pub type GoaOAuthBasedSkeletonPrivate = *mut _GoaOAuthBasedSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaObjectIface {
    pub parent_iface: gobject::GTypeInterface,
}

impl ::std::fmt::Debug for GoaObjectIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaObjectIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaObjectManagerClientClass {
    pub parent_class: gio::GDBusObjectManagerClientClass,
}

impl ::std::fmt::Debug for GoaObjectManagerClientClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaObjectManagerClientClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaObjectManagerClientPrivate(c_void);

pub type GoaObjectManagerClientPrivate = *mut _GoaObjectManagerClientPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaObjectProxyClass {
    pub parent_class: gio::GDBusObjectProxyClass,
}

impl ::std::fmt::Debug for GoaObjectProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaObjectProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaObjectProxyPrivate(c_void);

pub type GoaObjectProxyPrivate = *mut _GoaObjectProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaObjectSkeletonClass {
    pub parent_class: gio::GDBusObjectSkeletonClass,
}

impl ::std::fmt::Debug for GoaObjectSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaObjectSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaObjectSkeletonPrivate(c_void);

pub type GoaObjectSkeletonPrivate = *mut _GoaObjectSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPasswordBasedIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_get_password: Option<unsafe extern "C" fn(*mut GoaPasswordBased, *mut gio::GDBusMethodInvocation, *const c_char) -> gboolean>,
}

impl ::std::fmt::Debug for GoaPasswordBasedIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPasswordBasedIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .field("handle_get_password", &self.handle_get_password)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPasswordBasedProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaPasswordBasedProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPasswordBasedProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaPasswordBasedProxyPrivate(c_void);

pub type GoaPasswordBasedProxyPrivate = *mut _GoaPasswordBasedProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPasswordBasedSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaPasswordBasedSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPasswordBasedSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaPasswordBasedSkeletonPrivate(c_void);

pub type GoaPasswordBasedSkeletonPrivate = *mut _GoaPasswordBasedSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPhotosIface {
    pub parent_iface: gobject::GTypeInterface,
}

impl ::std::fmt::Debug for GoaPhotosIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPhotosIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPhotosProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaPhotosProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPhotosProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaPhotosProxyPrivate(c_void);

pub type GoaPhotosProxyPrivate = *mut _GoaPhotosProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPhotosSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaPhotosSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPhotosSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaPhotosSkeletonPrivate(c_void);

pub type GoaPhotosSkeletonPrivate = *mut _GoaPhotosSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPrintersIface {
    pub parent_iface: gobject::GTypeInterface,
}

impl ::std::fmt::Debug for GoaPrintersIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPrintersIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPrintersProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaPrintersProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPrintersProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaPrintersProxyPrivate(c_void);

pub type GoaPrintersProxyPrivate = *mut _GoaPrintersProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPrintersSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaPrintersSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPrintersSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaPrintersSkeletonPrivate(c_void);

pub type GoaPrintersSkeletonPrivate = *mut _GoaPrintersSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaReadLaterIface {
    pub parent_iface: gobject::GTypeInterface,
}

impl ::std::fmt::Debug for GoaReadLaterIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaReadLaterIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaReadLaterProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaReadLaterProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaReadLaterProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaReadLaterProxyPrivate(c_void);

pub type GoaReadLaterProxyPrivate = *mut _GoaReadLaterProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaReadLaterSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaReadLaterSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaReadLaterSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaReadLaterSkeletonPrivate(c_void);

pub type GoaReadLaterSkeletonPrivate = *mut _GoaReadLaterSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaTicketingIface {
    pub parent_iface: gobject::GTypeInterface,
    pub handle_get_ticket: Option<unsafe extern "C" fn(*mut GoaTicketing, *mut gio::GDBusMethodInvocation) -> gboolean>,
    pub get_details: Option<unsafe extern "C" fn(*mut GoaTicketing) -> *mut glib::GVariant>,
}

impl ::std::fmt::Debug for GoaTicketingIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaTicketingIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .field("handle_get_ticket", &self.handle_get_ticket)
         .field("get_details", &self.get_details)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaTicketingProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaTicketingProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaTicketingProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaTicketingProxyPrivate(c_void);

pub type GoaTicketingProxyPrivate = *mut _GoaTicketingProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaTicketingSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaTicketingSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaTicketingSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaTicketingSkeletonPrivate(c_void);

pub type GoaTicketingSkeletonPrivate = *mut _GoaTicketingSkeletonPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaTodoIface {
    pub parent_iface: gobject::GTypeInterface,
}

impl ::std::fmt::Debug for GoaTodoIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaTodoIface @ {:?}", self as *const _))
         .field("parent_iface", &self.parent_iface)
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaTodoProxyClass {
    pub parent_class: gio::GDBusProxyClass,
}

impl ::std::fmt::Debug for GoaTodoProxyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaTodoProxyClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaTodoProxyPrivate(c_void);

pub type GoaTodoProxyPrivate = *mut _GoaTodoProxyPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaTodoSkeletonClass {
    pub parent_class: gio::GDBusInterfaceSkeletonClass,
}

impl ::std::fmt::Debug for GoaTodoSkeletonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaTodoSkeletonClass @ {:?}", self as *const _))
         .field("parent_class", &self.parent_class)
         .finish()
    }
}

#[repr(C)]
pub struct _GoaTodoSkeletonPrivate(c_void);

pub type GoaTodoSkeletonPrivate = *mut _GoaTodoSkeletonPrivate;

// Classes
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaAccountProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaAccountProxyPrivate,
}

impl ::std::fmt::Debug for GoaAccountProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaAccountProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaAccountSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaAccountSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaAccountSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaAccountSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaCalendarProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaCalendarProxyPrivate,
}

impl ::std::fmt::Debug for GoaCalendarProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaCalendarProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaCalendarSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaCalendarSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaCalendarSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaCalendarSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaChatProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaChatProxyPrivate,
}

impl ::std::fmt::Debug for GoaChatProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaChatProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaChatSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaChatSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaChatSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaChatSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
pub struct GoaClient(c_void);

impl ::std::fmt::Debug for GoaClient {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaClient @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaContactsProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaContactsProxyPrivate,
}

impl ::std::fmt::Debug for GoaContactsProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaContactsProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaContactsSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaContactsSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaContactsSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaContactsSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaDocumentsProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaDocumentsProxyPrivate,
}

impl ::std::fmt::Debug for GoaDocumentsProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaDocumentsProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaDocumentsSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaDocumentsSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaDocumentsSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaDocumentsSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaExchangeProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaExchangeProxyPrivate,
}

impl ::std::fmt::Debug for GoaExchangeProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaExchangeProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaExchangeSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaExchangeSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaExchangeSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaExchangeSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaFilesProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaFilesProxyPrivate,
}

impl ::std::fmt::Debug for GoaFilesProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaFilesProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaFilesSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaFilesSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaFilesSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaFilesSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMailProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaMailProxyPrivate,
}

impl ::std::fmt::Debug for GoaMailProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMailProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMailSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaMailSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaMailSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMailSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaManagerProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaManagerProxyPrivate,
}

impl ::std::fmt::Debug for GoaManagerProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaManagerProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaManagerSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaManagerSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaManagerSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaManagerSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMapsProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaMapsProxyPrivate,
}

impl ::std::fmt::Debug for GoaMapsProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMapsProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMapsSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaMapsSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaMapsSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMapsSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMediaServerProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaMediaServerProxyPrivate,
}

impl ::std::fmt::Debug for GoaMediaServerProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMediaServerProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMediaServerSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaMediaServerSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaMediaServerSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMediaServerSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMusicProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaMusicProxyPrivate,
}

impl ::std::fmt::Debug for GoaMusicProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMusicProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaMusicSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaMusicSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaMusicSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaMusicSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaOAuth2BasedProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaOAuth2BasedProxyPrivate,
}

impl ::std::fmt::Debug for GoaOAuth2BasedProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaOAuth2BasedProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaOAuth2BasedSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaOAuth2BasedSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaOAuth2BasedSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaOAuth2BasedSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaOAuthBasedProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaOAuthBasedProxyPrivate,
}

impl ::std::fmt::Debug for GoaOAuthBasedProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaOAuthBasedProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaOAuthBasedSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaOAuthBasedSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaOAuthBasedSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaOAuthBasedSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaObjectManagerClient {
    pub parent_instance: gio::GDBusObjectManagerClient,
    pub priv_: *mut GoaObjectManagerClientPrivate,
}

impl ::std::fmt::Debug for GoaObjectManagerClient {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaObjectManagerClient @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaObjectProxy {
    pub parent_instance: gio::GDBusObjectProxy,
    pub priv_: *mut GoaObjectProxyPrivate,
}

impl ::std::fmt::Debug for GoaObjectProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaObjectProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaObjectSkeleton {
    pub parent_instance: gio::GDBusObjectSkeleton,
    pub priv_: *mut GoaObjectSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaObjectSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaObjectSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPasswordBasedProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaPasswordBasedProxyPrivate,
}

impl ::std::fmt::Debug for GoaPasswordBasedProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPasswordBasedProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPasswordBasedSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaPasswordBasedSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaPasswordBasedSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPasswordBasedSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPhotosProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaPhotosProxyPrivate,
}

impl ::std::fmt::Debug for GoaPhotosProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPhotosProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPhotosSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaPhotosSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaPhotosSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPhotosSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPrintersProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaPrintersProxyPrivate,
}

impl ::std::fmt::Debug for GoaPrintersProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPrintersProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaPrintersSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaPrintersSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaPrintersSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaPrintersSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaReadLaterProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaReadLaterProxyPrivate,
}

impl ::std::fmt::Debug for GoaReadLaterProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaReadLaterProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaReadLaterSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaReadLaterSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaReadLaterSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaReadLaterSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaTicketingProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaTicketingProxyPrivate,
}

impl ::std::fmt::Debug for GoaTicketingProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaTicketingProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaTicketingSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaTicketingSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaTicketingSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaTicketingSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaTodoProxy {
    pub parent_instance: gio::GDBusProxy,
    pub priv_: *mut GoaTodoProxyPrivate,
}

impl ::std::fmt::Debug for GoaTodoProxy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaTodoProxy @ {:?}", self as *const _))
         .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GoaTodoSkeleton {
    pub parent_instance: gio::GDBusInterfaceSkeleton,
    pub priv_: *mut GoaTodoSkeletonPrivate,
}

impl ::std::fmt::Debug for GoaTodoSkeleton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GoaTodoSkeleton @ {:?}", self as *const _))
         .finish()
    }
}

// Interfaces
#[repr(C)]
pub struct GoaAccount(c_void);

impl ::std::fmt::Debug for GoaAccount {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaAccount @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaCalendar(c_void);

impl ::std::fmt::Debug for GoaCalendar {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaCalendar @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaChat(c_void);

impl ::std::fmt::Debug for GoaChat {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaChat @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaContacts(c_void);

impl ::std::fmt::Debug for GoaContacts {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaContacts @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaDocuments(c_void);

impl ::std::fmt::Debug for GoaDocuments {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaDocuments @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaExchange(c_void);

impl ::std::fmt::Debug for GoaExchange {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaExchange @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaFiles(c_void);

impl ::std::fmt::Debug for GoaFiles {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaFiles @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaMail(c_void);

impl ::std::fmt::Debug for GoaMail {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaMail @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaManager(c_void);

impl ::std::fmt::Debug for GoaManager {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaManager @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaMaps(c_void);

impl ::std::fmt::Debug for GoaMaps {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaMaps @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaMediaServer(c_void);

impl ::std::fmt::Debug for GoaMediaServer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaMediaServer @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaMusic(c_void);

impl ::std::fmt::Debug for GoaMusic {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaMusic @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaOAuth2Based(c_void);

impl ::std::fmt::Debug for GoaOAuth2Based {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaOAuth2Based @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaOAuthBased(c_void);

impl ::std::fmt::Debug for GoaOAuthBased {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaOAuthBased @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaObject(c_void);

impl ::std::fmt::Debug for GoaObject {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaObject @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaPasswordBased(c_void);

impl ::std::fmt::Debug for GoaPasswordBased {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaPasswordBased @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaPhotos(c_void);

impl ::std::fmt::Debug for GoaPhotos {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaPhotos @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaPrinters(c_void);

impl ::std::fmt::Debug for GoaPrinters {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaPrinters @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaReadLater(c_void);

impl ::std::fmt::Debug for GoaReadLater {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaReadLater @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaTicketing(c_void);

impl ::std::fmt::Debug for GoaTicketing {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaTicketing @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GoaTodo(c_void);

impl ::std::fmt::Debug for GoaTodo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GoaTodo @ {:?}", self as *const _)
    }
}


extern "C" {

    //=========================================================================
    // GoaError
    //=========================================================================
    pub fn goa_error_get_type() -> GType;
    pub fn goa_error_quark() -> glib::GQuark;

    //=========================================================================
    // GoaAccountProxy
    //=========================================================================
    pub fn goa_account_proxy_get_type() -> GType;
    pub fn goa_account_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaAccountProxy;
    pub fn goa_account_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaAccountProxy;
    pub fn goa_account_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaAccountProxy;
    pub fn goa_account_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaAccountProxy;
    pub fn goa_account_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_account_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaAccountSkeleton
    //=========================================================================
    pub fn goa_account_skeleton_get_type() -> GType;
    pub fn goa_account_skeleton_new() -> *mut GoaAccountSkeleton;

    //=========================================================================
    // GoaCalendarProxy
    //=========================================================================
    pub fn goa_calendar_proxy_get_type() -> GType;
    pub fn goa_calendar_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaCalendarProxy;
    pub fn goa_calendar_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaCalendarProxy;
    pub fn goa_calendar_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaCalendarProxy;
    pub fn goa_calendar_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaCalendarProxy;
    pub fn goa_calendar_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_calendar_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaCalendarSkeleton
    //=========================================================================
    pub fn goa_calendar_skeleton_get_type() -> GType;
    pub fn goa_calendar_skeleton_new() -> *mut GoaCalendarSkeleton;

    //=========================================================================
    // GoaChatProxy
    //=========================================================================
    pub fn goa_chat_proxy_get_type() -> GType;
    pub fn goa_chat_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaChatProxy;
    pub fn goa_chat_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaChatProxy;
    pub fn goa_chat_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaChatProxy;
    pub fn goa_chat_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaChatProxy;
    pub fn goa_chat_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_chat_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaChatSkeleton
    //=========================================================================
    pub fn goa_chat_skeleton_get_type() -> GType;
    pub fn goa_chat_skeleton_new() -> *mut GoaChatSkeleton;

    //=========================================================================
    // GoaClient
    //=========================================================================
    pub fn goa_client_get_type() -> GType;
    pub fn goa_client_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaClient;
    pub fn goa_client_new_sync(cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaClient;
    pub fn goa_client_new(cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_client_get_accounts(self_: *mut GoaClient) -> *mut glib::GList;
    pub fn goa_client_get_manager(self_: *mut GoaClient) -> *mut GoaManager;
    pub fn goa_client_get_object_manager(self_: *mut GoaClient) -> *mut gio::GDBusObjectManager;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_client_lookup_by_id(self_: *mut GoaClient, id: *const c_char) -> *mut GoaObject;

    //=========================================================================
    // GoaContactsProxy
    //=========================================================================
    pub fn goa_contacts_proxy_get_type() -> GType;
    pub fn goa_contacts_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaContactsProxy;
    pub fn goa_contacts_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaContactsProxy;
    pub fn goa_contacts_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaContactsProxy;
    pub fn goa_contacts_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaContactsProxy;
    pub fn goa_contacts_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_contacts_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaContactsSkeleton
    //=========================================================================
    pub fn goa_contacts_skeleton_get_type() -> GType;
    pub fn goa_contacts_skeleton_new() -> *mut GoaContactsSkeleton;

    //=========================================================================
    // GoaDocumentsProxy
    //=========================================================================
    pub fn goa_documents_proxy_get_type() -> GType;
    pub fn goa_documents_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaDocumentsProxy;
    pub fn goa_documents_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaDocumentsProxy;
    pub fn goa_documents_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaDocumentsProxy;
    pub fn goa_documents_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaDocumentsProxy;
    pub fn goa_documents_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_documents_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaDocumentsSkeleton
    //=========================================================================
    pub fn goa_documents_skeleton_get_type() -> GType;
    pub fn goa_documents_skeleton_new() -> *mut GoaDocumentsSkeleton;

    //=========================================================================
    // GoaExchangeProxy
    //=========================================================================
    pub fn goa_exchange_proxy_get_type() -> GType;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_exchange_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaExchangeProxy;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_exchange_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaExchangeProxy;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_exchange_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaExchangeProxy;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_exchange_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaExchangeProxy;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_exchange_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_exchange_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaExchangeSkeleton
    //=========================================================================
    pub fn goa_exchange_skeleton_get_type() -> GType;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_exchange_skeleton_new() -> *mut GoaExchangeSkeleton;

    //=========================================================================
    // GoaFilesProxy
    //=========================================================================
    pub fn goa_files_proxy_get_type() -> GType;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaFilesProxy;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaFilesProxy;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaFilesProxy;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaFilesProxy;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaFilesSkeleton
    //=========================================================================
    pub fn goa_files_skeleton_get_type() -> GType;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_skeleton_new() -> *mut GoaFilesSkeleton;

    //=========================================================================
    // GoaMailProxy
    //=========================================================================
    pub fn goa_mail_proxy_get_type() -> GType;
    pub fn goa_mail_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaMailProxy;
    pub fn goa_mail_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaMailProxy;
    pub fn goa_mail_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaMailProxy;
    pub fn goa_mail_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaMailProxy;
    pub fn goa_mail_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_mail_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaMailSkeleton
    //=========================================================================
    pub fn goa_mail_skeleton_get_type() -> GType;
    pub fn goa_mail_skeleton_new() -> *mut GoaMailSkeleton;

    //=========================================================================
    // GoaManagerProxy
    //=========================================================================
    pub fn goa_manager_proxy_get_type() -> GType;
    pub fn goa_manager_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaManagerProxy;
    pub fn goa_manager_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaManagerProxy;
    pub fn goa_manager_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaManagerProxy;
    pub fn goa_manager_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaManagerProxy;
    pub fn goa_manager_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_manager_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaManagerSkeleton
    //=========================================================================
    pub fn goa_manager_skeleton_get_type() -> GType;
    pub fn goa_manager_skeleton_new() -> *mut GoaManagerSkeleton;

    //=========================================================================
    // GoaMapsProxy
    //=========================================================================
    pub fn goa_maps_proxy_get_type() -> GType;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_maps_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaMapsProxy;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_maps_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaMapsProxy;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_maps_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaMapsProxy;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_maps_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaMapsProxy;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_maps_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_maps_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaMapsSkeleton
    //=========================================================================
    pub fn goa_maps_skeleton_get_type() -> GType;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_maps_skeleton_new() -> *mut GoaMapsSkeleton;

    //=========================================================================
    // GoaMediaServerProxy
    //=========================================================================
    pub fn goa_media_server_proxy_get_type() -> GType;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaMediaServerProxy;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaMediaServerProxy;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaMediaServerProxy;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaMediaServerProxy;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaMediaServerSkeleton
    //=========================================================================
    pub fn goa_media_server_skeleton_get_type() -> GType;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_skeleton_new() -> *mut GoaMediaServerSkeleton;

    //=========================================================================
    // GoaMusicProxy
    //=========================================================================
    pub fn goa_music_proxy_get_type() -> GType;
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_music_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaMusicProxy;
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_music_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaMusicProxy;
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_music_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaMusicProxy;
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_music_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaMusicProxy;
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_music_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_music_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaMusicSkeleton
    //=========================================================================
    pub fn goa_music_skeleton_get_type() -> GType;
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_music_skeleton_new() -> *mut GoaMusicSkeleton;

    //=========================================================================
    // GoaOAuth2BasedProxy
    //=========================================================================
    pub fn goa_oauth2_based_proxy_get_type() -> GType;
    pub fn goa_oauth2_based_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaOAuth2BasedProxy;
    pub fn goa_oauth2_based_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaOAuth2BasedProxy;
    pub fn goa_oauth2_based_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaOAuth2BasedProxy;
    pub fn goa_oauth2_based_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaOAuth2BasedProxy;
    pub fn goa_oauth2_based_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_oauth2_based_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaOAuth2BasedSkeleton
    //=========================================================================
    pub fn goa_oauth2_based_skeleton_get_type() -> GType;
    pub fn goa_oauth2_based_skeleton_new() -> *mut GoaOAuth2BasedSkeleton;

    //=========================================================================
    // GoaOAuthBasedProxy
    //=========================================================================
    pub fn goa_oauth_based_proxy_get_type() -> GType;
    pub fn goa_oauth_based_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaOAuthBasedProxy;
    pub fn goa_oauth_based_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaOAuthBasedProxy;
    pub fn goa_oauth_based_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaOAuthBasedProxy;
    pub fn goa_oauth_based_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaOAuthBasedProxy;
    pub fn goa_oauth_based_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_oauth_based_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaOAuthBasedSkeleton
    //=========================================================================
    pub fn goa_oauth_based_skeleton_get_type() -> GType;
    pub fn goa_oauth_based_skeleton_new() -> *mut GoaOAuthBasedSkeleton;

    //=========================================================================
    // GoaObjectManagerClient
    //=========================================================================
    pub fn goa_object_manager_client_get_type() -> GType;
    pub fn goa_object_manager_client_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaObjectManagerClient;
    pub fn goa_object_manager_client_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaObjectManagerClient;
    pub fn goa_object_manager_client_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaObjectManagerClient;
    pub fn goa_object_manager_client_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaObjectManagerClient;
    pub fn goa_object_manager_client_get_proxy_type(manager: *mut gio::GDBusObjectManagerClient, object_path: *const c_char, interface_name: *const c_char, user_data: gpointer) -> GType;
    pub fn goa_object_manager_client_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_object_manager_client_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusObjectManagerClientFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaObjectProxy
    //=========================================================================
    pub fn goa_object_proxy_get_type() -> GType;
    pub fn goa_object_proxy_new(connection: *mut gio::GDBusConnection, object_path: *const c_char) -> *mut GoaObjectProxy;

    //=========================================================================
    // GoaObjectSkeleton
    //=========================================================================
    pub fn goa_object_skeleton_get_type() -> GType;
    pub fn goa_object_skeleton_new(object_path: *const c_char) -> *mut GoaObjectSkeleton;
    pub fn goa_object_skeleton_set_account(object: *mut GoaObjectSkeleton, interface_: *mut GoaAccount);
    pub fn goa_object_skeleton_set_calendar(object: *mut GoaObjectSkeleton, interface_: *mut GoaCalendar);
    pub fn goa_object_skeleton_set_chat(object: *mut GoaObjectSkeleton, interface_: *mut GoaChat);
    pub fn goa_object_skeleton_set_contacts(object: *mut GoaObjectSkeleton, interface_: *mut GoaContacts);
    pub fn goa_object_skeleton_set_documents(object: *mut GoaObjectSkeleton, interface_: *mut GoaDocuments);
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_object_skeleton_set_exchange(object: *mut GoaObjectSkeleton, interface_: *mut GoaExchange);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_object_skeleton_set_files(object: *mut GoaObjectSkeleton, interface_: *mut GoaFiles);
    pub fn goa_object_skeleton_set_mail(object: *mut GoaObjectSkeleton, interface_: *mut GoaMail);
    pub fn goa_object_skeleton_set_manager(object: *mut GoaObjectSkeleton, interface_: *mut GoaManager);
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_object_skeleton_set_maps(object: *mut GoaObjectSkeleton, interface_: *mut GoaMaps);
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_object_skeleton_set_media_server(object: *mut GoaObjectSkeleton, interface_: *mut GoaMediaServer);
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_object_skeleton_set_music(object: *mut GoaObjectSkeleton, interface_: *mut GoaMusic);
    pub fn goa_object_skeleton_set_oauth2_based(object: *mut GoaObjectSkeleton, interface_: *mut GoaOAuth2Based);
    pub fn goa_object_skeleton_set_oauth_based(object: *mut GoaObjectSkeleton, interface_: *mut GoaOAuthBased);
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_object_skeleton_set_password_based(object: *mut GoaObjectSkeleton, interface_: *mut GoaPasswordBased);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_object_skeleton_set_photos(object: *mut GoaObjectSkeleton, interface_: *mut GoaPhotos);
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_object_skeleton_set_printers(object: *mut GoaObjectSkeleton, interface_: *mut GoaPrinters);
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_object_skeleton_set_read_later(object: *mut GoaObjectSkeleton, interface_: *mut GoaReadLater);
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_object_skeleton_set_ticketing(object: *mut GoaObjectSkeleton, interface_: *mut GoaTicketing);
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_object_skeleton_set_todo(object: *mut GoaObjectSkeleton, interface_: *mut GoaTodo);

    //=========================================================================
    // GoaPasswordBasedProxy
    //=========================================================================
    pub fn goa_password_based_proxy_get_type() -> GType;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_password_based_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaPasswordBasedProxy;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_password_based_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaPasswordBasedProxy;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_password_based_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaPasswordBasedProxy;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_password_based_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaPasswordBasedProxy;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_password_based_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_password_based_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaPasswordBasedSkeleton
    //=========================================================================
    pub fn goa_password_based_skeleton_get_type() -> GType;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_password_based_skeleton_new() -> *mut GoaPasswordBasedSkeleton;

    //=========================================================================
    // GoaPhotosProxy
    //=========================================================================
    pub fn goa_photos_proxy_get_type() -> GType;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_photos_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaPhotosProxy;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_photos_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaPhotosProxy;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_photos_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaPhotosProxy;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_photos_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaPhotosProxy;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_photos_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_photos_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaPhotosSkeleton
    //=========================================================================
    pub fn goa_photos_skeleton_get_type() -> GType;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_photos_skeleton_new() -> *mut GoaPhotosSkeleton;

    //=========================================================================
    // GoaPrintersProxy
    //=========================================================================
    pub fn goa_printers_proxy_get_type() -> GType;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_printers_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaPrintersProxy;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_printers_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaPrintersProxy;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_printers_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaPrintersProxy;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_printers_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaPrintersProxy;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_printers_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_printers_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaPrintersSkeleton
    //=========================================================================
    pub fn goa_printers_skeleton_get_type() -> GType;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_printers_skeleton_new() -> *mut GoaPrintersSkeleton;

    //=========================================================================
    // GoaReadLaterProxy
    //=========================================================================
    pub fn goa_read_later_proxy_get_type() -> GType;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_read_later_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaReadLaterProxy;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_read_later_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaReadLaterProxy;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_read_later_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaReadLaterProxy;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_read_later_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaReadLaterProxy;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_read_later_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_read_later_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaReadLaterSkeleton
    //=========================================================================
    pub fn goa_read_later_skeleton_get_type() -> GType;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_read_later_skeleton_new() -> *mut GoaReadLaterSkeleton;

    //=========================================================================
    // GoaTicketingProxy
    //=========================================================================
    pub fn goa_ticketing_proxy_get_type() -> GType;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_ticketing_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaTicketingProxy;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_ticketing_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaTicketingProxy;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_ticketing_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaTicketingProxy;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_ticketing_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaTicketingProxy;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_ticketing_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_ticketing_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaTicketingSkeleton
    //=========================================================================
    pub fn goa_ticketing_skeleton_get_type() -> GType;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_ticketing_skeleton_new() -> *mut GoaTicketingSkeleton;

    //=========================================================================
    // GoaTodoProxy
    //=========================================================================
    pub fn goa_todo_proxy_get_type() -> GType;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_todo_proxy_new_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaTodoProxy;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_todo_proxy_new_for_bus_finish(res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut GoaTodoProxy;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_todo_proxy_new_for_bus_sync(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaTodoProxy;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_todo_proxy_new_sync(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut GoaTodoProxy;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_todo_proxy_new(connection: *mut gio::GDBusConnection, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_todo_proxy_new_for_bus(bus_type: gio::GBusType, flags: gio::GDBusProxyFlags, name: *const c_char, object_path: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);

    //=========================================================================
    // GoaTodoSkeleton
    //=========================================================================
    pub fn goa_todo_skeleton_get_type() -> GType;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_todo_skeleton_new() -> *mut GoaTodoSkeleton;

    //=========================================================================
    // GoaAccount
    //=========================================================================
    pub fn goa_account_get_type() -> GType;
    pub fn goa_account_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn goa_account_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn goa_account_call_ensure_credentials(proxy: *mut GoaAccount, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_account_call_ensure_credentials_finish(proxy: *mut GoaAccount, out_expires_in: *mut c_int, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn goa_account_call_ensure_credentials_sync(proxy: *mut GoaAccount, out_expires_in: *mut c_int, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn goa_account_call_remove(proxy: *mut GoaAccount, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_account_call_remove_finish(proxy: *mut GoaAccount, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn goa_account_call_remove_sync(proxy: *mut GoaAccount, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn goa_account_complete_ensure_credentials(object: *mut GoaAccount, invocation: *mut gio::GDBusMethodInvocation, expires_in: c_int);
    pub fn goa_account_complete_remove(object: *mut GoaAccount, invocation: *mut gio::GDBusMethodInvocation);
    pub fn goa_account_dup_id(object: *mut GoaAccount) -> *mut c_char;
    pub fn goa_account_dup_identity(object: *mut GoaAccount) -> *mut c_char;
    pub fn goa_account_dup_presentation_identity(object: *mut GoaAccount) -> *mut c_char;
    pub fn goa_account_dup_provider_icon(object: *mut GoaAccount) -> *mut c_char;
    pub fn goa_account_dup_provider_name(object: *mut GoaAccount) -> *mut c_char;
    pub fn goa_account_dup_provider_type(object: *mut GoaAccount) -> *mut c_char;
    pub fn goa_account_get_attention_needed(object: *mut GoaAccount) -> gboolean;
    pub fn goa_account_get_calendar_disabled(object: *mut GoaAccount) -> gboolean;
    pub fn goa_account_get_chat_disabled(object: *mut GoaAccount) -> gboolean;
    pub fn goa_account_get_contacts_disabled(object: *mut GoaAccount) -> gboolean;
    pub fn goa_account_get_documents_disabled(object: *mut GoaAccount) -> gboolean;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_account_get_files_disabled(object: *mut GoaAccount) -> gboolean;
    pub fn goa_account_get_id(object: *mut GoaAccount) -> *const c_char;
    pub fn goa_account_get_identity(object: *mut GoaAccount) -> *const c_char;
    #[cfg(any(feature = "v3_16", feature = "dox"))]
    pub fn goa_account_get_is_locked(object: *mut GoaAccount) -> gboolean;
    pub fn goa_account_get_is_temporary(object: *mut GoaAccount) -> gboolean;
    pub fn goa_account_get_mail_disabled(object: *mut GoaAccount) -> gboolean;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_account_get_maps_disabled(object: *mut GoaAccount) -> gboolean;
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_account_get_music_disabled(object: *mut GoaAccount) -> gboolean;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_account_get_photos_disabled(object: *mut GoaAccount) -> gboolean;
    pub fn goa_account_get_presentation_identity(object: *mut GoaAccount) -> *const c_char;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_account_get_printers_disabled(object: *mut GoaAccount) -> gboolean;
    pub fn goa_account_get_provider_icon(object: *mut GoaAccount) -> *const c_char;
    pub fn goa_account_get_provider_name(object: *mut GoaAccount) -> *const c_char;
    pub fn goa_account_get_provider_type(object: *mut GoaAccount) -> *const c_char;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_account_get_read_later_disabled(object: *mut GoaAccount) -> gboolean;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_account_get_ticketing_disabled(object: *mut GoaAccount) -> gboolean;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_account_get_todo_disabled(object: *mut GoaAccount) -> gboolean;
    pub fn goa_account_set_attention_needed(object: *mut GoaAccount, value: gboolean);
    pub fn goa_account_set_calendar_disabled(object: *mut GoaAccount, value: gboolean);
    pub fn goa_account_set_chat_disabled(object: *mut GoaAccount, value: gboolean);
    pub fn goa_account_set_contacts_disabled(object: *mut GoaAccount, value: gboolean);
    pub fn goa_account_set_documents_disabled(object: *mut GoaAccount, value: gboolean);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_account_set_files_disabled(object: *mut GoaAccount, value: gboolean);
    pub fn goa_account_set_id(object: *mut GoaAccount, value: *const c_char);
    pub fn goa_account_set_identity(object: *mut GoaAccount, value: *const c_char);
    #[cfg(any(feature = "v3_16", feature = "dox"))]
    pub fn goa_account_set_is_locked(object: *mut GoaAccount, value: gboolean);
    pub fn goa_account_set_is_temporary(object: *mut GoaAccount, value: gboolean);
    pub fn goa_account_set_mail_disabled(object: *mut GoaAccount, value: gboolean);
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_account_set_maps_disabled(object: *mut GoaAccount, value: gboolean);
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_account_set_music_disabled(object: *mut GoaAccount, value: gboolean);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_account_set_photos_disabled(object: *mut GoaAccount, value: gboolean);
    pub fn goa_account_set_presentation_identity(object: *mut GoaAccount, value: *const c_char);
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_account_set_printers_disabled(object: *mut GoaAccount, value: gboolean);
    pub fn goa_account_set_provider_icon(object: *mut GoaAccount, value: *const c_char);
    pub fn goa_account_set_provider_name(object: *mut GoaAccount, value: *const c_char);
    pub fn goa_account_set_provider_type(object: *mut GoaAccount, value: *const c_char);
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_account_set_read_later_disabled(object: *mut GoaAccount, value: gboolean);
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_account_set_ticketing_disabled(object: *mut GoaAccount, value: gboolean);
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_account_set_todo_disabled(object: *mut GoaAccount, value: gboolean);

    //=========================================================================
    // GoaCalendar
    //=========================================================================
    pub fn goa_calendar_get_type() -> GType;
    pub fn goa_calendar_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn goa_calendar_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_calendar_dup_uri(object: *mut GoaCalendar) -> *mut c_char;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_calendar_get_accept_ssl_errors(object: *mut GoaCalendar) -> gboolean;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_calendar_get_uri(object: *mut GoaCalendar) -> *const c_char;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_calendar_set_accept_ssl_errors(object: *mut GoaCalendar, value: gboolean);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_calendar_set_uri(object: *mut GoaCalendar, value: *const c_char);

    //=========================================================================
    // GoaChat
    //=========================================================================
    pub fn goa_chat_get_type() -> GType;
    pub fn goa_chat_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn goa_chat_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;

    //=========================================================================
    // GoaContacts
    //=========================================================================
    pub fn goa_contacts_get_type() -> GType;
    pub fn goa_contacts_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn goa_contacts_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_contacts_dup_uri(object: *mut GoaContacts) -> *mut c_char;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_contacts_get_accept_ssl_errors(object: *mut GoaContacts) -> gboolean;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_contacts_get_uri(object: *mut GoaContacts) -> *const c_char;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_contacts_set_accept_ssl_errors(object: *mut GoaContacts, value: gboolean);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_contacts_set_uri(object: *mut GoaContacts, value: *const c_char);

    //=========================================================================
    // GoaDocuments
    //=========================================================================
    pub fn goa_documents_get_type() -> GType;
    pub fn goa_documents_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn goa_documents_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;

    //=========================================================================
    // GoaExchange
    //=========================================================================
    pub fn goa_exchange_get_type() -> GType;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_exchange_interface_info() -> *mut gio::GDBusInterfaceInfo;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_exchange_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_exchange_dup_host(object: *mut GoaExchange) -> *mut c_char;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_exchange_get_accept_ssl_errors(object: *mut GoaExchange) -> gboolean;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_exchange_get_host(object: *mut GoaExchange) -> *const c_char;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_exchange_set_accept_ssl_errors(object: *mut GoaExchange, value: gboolean);
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_exchange_set_host(object: *mut GoaExchange, value: *const c_char);

    //=========================================================================
    // GoaFiles
    //=========================================================================
    pub fn goa_files_get_type() -> GType;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_interface_info() -> *mut gio::GDBusInterfaceInfo;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_dup_uri(object: *mut GoaFiles) -> *mut c_char;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_get_accept_ssl_errors(object: *mut GoaFiles) -> gboolean;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_get_uri(object: *mut GoaFiles) -> *const c_char;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_set_accept_ssl_errors(object: *mut GoaFiles, value: gboolean);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_files_set_uri(object: *mut GoaFiles, value: *const c_char);

    //=========================================================================
    // GoaMail
    //=========================================================================
    pub fn goa_mail_get_type() -> GType;
    pub fn goa_mail_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn goa_mail_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn goa_mail_dup_email_address(object: *mut GoaMail) -> *mut c_char;
    pub fn goa_mail_dup_imap_host(object: *mut GoaMail) -> *mut c_char;
    pub fn goa_mail_dup_imap_user_name(object: *mut GoaMail) -> *mut c_char;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_mail_dup_name(object: *mut GoaMail) -> *mut c_char;
    pub fn goa_mail_dup_smtp_host(object: *mut GoaMail) -> *mut c_char;
    pub fn goa_mail_dup_smtp_user_name(object: *mut GoaMail) -> *mut c_char;
    pub fn goa_mail_get_email_address(object: *mut GoaMail) -> *const c_char;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_mail_get_imap_accept_ssl_errors(object: *mut GoaMail) -> gboolean;
    pub fn goa_mail_get_imap_host(object: *mut GoaMail) -> *const c_char;
    pub fn goa_mail_get_imap_supported(object: *mut GoaMail) -> gboolean;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_mail_get_imap_use_ssl(object: *mut GoaMail) -> gboolean;
    pub fn goa_mail_get_imap_use_tls(object: *mut GoaMail) -> gboolean;
    pub fn goa_mail_get_imap_user_name(object: *mut GoaMail) -> *const c_char;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_mail_get_name(object: *mut GoaMail) -> *const c_char;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_mail_get_smtp_accept_ssl_errors(object: *mut GoaMail) -> gboolean;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_mail_get_smtp_auth_login(object: *mut GoaMail) -> gboolean;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_mail_get_smtp_auth_plain(object: *mut GoaMail) -> gboolean;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_mail_get_smtp_auth_xoauth2(object: *mut GoaMail) -> gboolean;
    pub fn goa_mail_get_smtp_host(object: *mut GoaMail) -> *const c_char;
    pub fn goa_mail_get_smtp_supported(object: *mut GoaMail) -> gboolean;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_mail_get_smtp_use_auth(object: *mut GoaMail) -> gboolean;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_mail_get_smtp_use_ssl(object: *mut GoaMail) -> gboolean;
    pub fn goa_mail_get_smtp_use_tls(object: *mut GoaMail) -> gboolean;
    pub fn goa_mail_get_smtp_user_name(object: *mut GoaMail) -> *const c_char;
    pub fn goa_mail_set_email_address(object: *mut GoaMail, value: *const c_char);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_mail_set_imap_accept_ssl_errors(object: *mut GoaMail, value: gboolean);
    pub fn goa_mail_set_imap_host(object: *mut GoaMail, value: *const c_char);
    pub fn goa_mail_set_imap_supported(object: *mut GoaMail, value: gboolean);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_mail_set_imap_use_ssl(object: *mut GoaMail, value: gboolean);
    pub fn goa_mail_set_imap_use_tls(object: *mut GoaMail, value: gboolean);
    pub fn goa_mail_set_imap_user_name(object: *mut GoaMail, value: *const c_char);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_mail_set_name(object: *mut GoaMail, value: *const c_char);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_mail_set_smtp_accept_ssl_errors(object: *mut GoaMail, value: gboolean);
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_mail_set_smtp_auth_login(object: *mut GoaMail, value: gboolean);
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_mail_set_smtp_auth_plain(object: *mut GoaMail, value: gboolean);
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_mail_set_smtp_auth_xoauth2(object: *mut GoaMail, value: gboolean);
    pub fn goa_mail_set_smtp_host(object: *mut GoaMail, value: *const c_char);
    pub fn goa_mail_set_smtp_supported(object: *mut GoaMail, value: gboolean);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_mail_set_smtp_use_auth(object: *mut GoaMail, value: gboolean);
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_mail_set_smtp_use_ssl(object: *mut GoaMail, value: gboolean);
    pub fn goa_mail_set_smtp_use_tls(object: *mut GoaMail, value: gboolean);
    pub fn goa_mail_set_smtp_user_name(object: *mut GoaMail, value: *const c_char);

    //=========================================================================
    // GoaManager
    //=========================================================================
    pub fn goa_manager_get_type() -> GType;
    pub fn goa_manager_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn goa_manager_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn goa_manager_call_add_account(proxy: *mut GoaManager, arg_provider: *const c_char, arg_identity: *const c_char, arg_presentation_identity: *const c_char, arg_credentials: *mut glib::GVariant, arg_details: *mut glib::GVariant, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_manager_call_add_account_finish(proxy: *mut GoaManager, out_account_object_path: *mut *mut c_char, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn goa_manager_call_add_account_sync(proxy: *mut GoaManager, arg_provider: *const c_char, arg_identity: *const c_char, arg_presentation_identity: *const c_char, arg_credentials: *mut glib::GVariant, arg_details: *mut glib::GVariant, out_account_object_path: *mut *mut c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn goa_manager_complete_add_account(object: *mut GoaManager, invocation: *mut gio::GDBusMethodInvocation, account_object_path: *const c_char);

    //=========================================================================
    // GoaMaps
    //=========================================================================
    pub fn goa_maps_get_type() -> GType;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_maps_interface_info() -> *mut gio::GDBusInterfaceInfo;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_maps_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;

    //=========================================================================
    // GoaMediaServer
    //=========================================================================
    pub fn goa_media_server_get_type() -> GType;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_interface_info() -> *mut gio::GDBusInterfaceInfo;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_dup_udn(object: *mut GoaMediaServer) -> *mut c_char;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_get_dlna_supported(object: *mut GoaMediaServer) -> gboolean;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_get_udn(object: *mut GoaMediaServer) -> *const c_char;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_set_dlna_supported(object: *mut GoaMediaServer, value: gboolean);
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_media_server_set_udn(object: *mut GoaMediaServer, value: *const c_char);

    //=========================================================================
    // GoaMusic
    //=========================================================================
    pub fn goa_music_get_type() -> GType;
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_music_interface_info() -> *mut gio::GDBusInterfaceInfo;
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_music_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;

    //=========================================================================
    // GoaOAuth2Based
    //=========================================================================
    pub fn goa_oauth2_based_get_type() -> GType;
    pub fn goa_oauth2_based_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn goa_oauth2_based_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn goa_oauth2_based_call_get_access_token(proxy: *mut GoaOAuth2Based, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_oauth2_based_call_get_access_token_finish(proxy: *mut GoaOAuth2Based, out_access_token: *mut *mut c_char, out_expires_in: *mut c_int, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn goa_oauth2_based_call_get_access_token_sync(proxy: *mut GoaOAuth2Based, out_access_token: *mut *mut c_char, out_expires_in: *mut c_int, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn goa_oauth2_based_complete_get_access_token(object: *mut GoaOAuth2Based, invocation: *mut gio::GDBusMethodInvocation, access_token: *const c_char, expires_in: c_int);
    pub fn goa_oauth2_based_dup_client_id(object: *mut GoaOAuth2Based) -> *mut c_char;
    pub fn goa_oauth2_based_dup_client_secret(object: *mut GoaOAuth2Based) -> *mut c_char;
    pub fn goa_oauth2_based_get_client_id(object: *mut GoaOAuth2Based) -> *const c_char;
    pub fn goa_oauth2_based_get_client_secret(object: *mut GoaOAuth2Based) -> *const c_char;
    pub fn goa_oauth2_based_set_client_id(object: *mut GoaOAuth2Based, value: *const c_char);
    pub fn goa_oauth2_based_set_client_secret(object: *mut GoaOAuth2Based, value: *const c_char);

    //=========================================================================
    // GoaOAuthBased
    //=========================================================================
    pub fn goa_oauth_based_get_type() -> GType;
    pub fn goa_oauth_based_interface_info() -> *mut gio::GDBusInterfaceInfo;
    pub fn goa_oauth_based_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    pub fn goa_oauth_based_call_get_access_token(proxy: *mut GoaOAuthBased, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    pub fn goa_oauth_based_call_get_access_token_finish(proxy: *mut GoaOAuthBased, out_access_token: *mut *mut c_char, out_access_token_secret: *mut *mut c_char, out_expires_in: *mut c_int, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    pub fn goa_oauth_based_call_get_access_token_sync(proxy: *mut GoaOAuthBased, out_access_token: *mut *mut c_char, out_access_token_secret: *mut *mut c_char, out_expires_in: *mut c_int, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    pub fn goa_oauth_based_complete_get_access_token(object: *mut GoaOAuthBased, invocation: *mut gio::GDBusMethodInvocation, access_token: *const c_char, access_token_secret: *const c_char, expires_in: c_int);
    pub fn goa_oauth_based_dup_consumer_key(object: *mut GoaOAuthBased) -> *mut c_char;
    pub fn goa_oauth_based_dup_consumer_secret(object: *mut GoaOAuthBased) -> *mut c_char;
    pub fn goa_oauth_based_get_consumer_key(object: *mut GoaOAuthBased) -> *const c_char;
    pub fn goa_oauth_based_get_consumer_secret(object: *mut GoaOAuthBased) -> *const c_char;
    pub fn goa_oauth_based_set_consumer_key(object: *mut GoaOAuthBased, value: *const c_char);
    pub fn goa_oauth_based_set_consumer_secret(object: *mut GoaOAuthBased, value: *const c_char);

    //=========================================================================
    // GoaObject
    //=========================================================================
    pub fn goa_object_get_type() -> GType;
    pub fn goa_object_get_account(object: *mut GoaObject) -> *mut GoaAccount;
    pub fn goa_object_get_calendar(object: *mut GoaObject) -> *mut GoaCalendar;
    pub fn goa_object_get_chat(object: *mut GoaObject) -> *mut GoaChat;
    pub fn goa_object_get_contacts(object: *mut GoaObject) -> *mut GoaContacts;
    pub fn goa_object_get_documents(object: *mut GoaObject) -> *mut GoaDocuments;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_object_get_exchange(object: *mut GoaObject) -> *mut GoaExchange;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_object_get_files(object: *mut GoaObject) -> *mut GoaFiles;
    pub fn goa_object_get_mail(object: *mut GoaObject) -> *mut GoaMail;
    pub fn goa_object_get_manager(object: *mut GoaObject) -> *mut GoaManager;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_object_get_maps(object: *mut GoaObject) -> *mut GoaMaps;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_object_get_media_server(object: *mut GoaObject) -> *mut GoaMediaServer;
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_object_get_music(object: *mut GoaObject) -> *mut GoaMusic;
    pub fn goa_object_get_oauth2_based(object: *mut GoaObject) -> *mut GoaOAuth2Based;
    pub fn goa_object_get_oauth_based(object: *mut GoaObject) -> *mut GoaOAuthBased;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_object_get_password_based(object: *mut GoaObject) -> *mut GoaPasswordBased;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_object_get_photos(object: *mut GoaObject) -> *mut GoaPhotos;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_object_get_printers(object: *mut GoaObject) -> *mut GoaPrinters;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_object_get_read_later(object: *mut GoaObject) -> *mut GoaReadLater;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_object_get_ticketing(object: *mut GoaObject) -> *mut GoaTicketing;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_object_get_todo(object: *mut GoaObject) -> *mut GoaTodo;
    pub fn goa_object_peek_account(object: *mut GoaObject) -> *mut GoaAccount;
    pub fn goa_object_peek_calendar(object: *mut GoaObject) -> *mut GoaCalendar;
    pub fn goa_object_peek_chat(object: *mut GoaObject) -> *mut GoaChat;
    pub fn goa_object_peek_contacts(object: *mut GoaObject) -> *mut GoaContacts;
    pub fn goa_object_peek_documents(object: *mut GoaObject) -> *mut GoaDocuments;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_object_peek_exchange(object: *mut GoaObject) -> *mut GoaExchange;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_object_peek_files(object: *mut GoaObject) -> *mut GoaFiles;
    pub fn goa_object_peek_mail(object: *mut GoaObject) -> *mut GoaMail;
    pub fn goa_object_peek_manager(object: *mut GoaObject) -> *mut GoaManager;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_object_peek_maps(object: *mut GoaObject) -> *mut GoaMaps;
    #[cfg(any(feature = "v3_14", feature = "dox"))]
    pub fn goa_object_peek_media_server(object: *mut GoaObject) -> *mut GoaMediaServer;
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_object_peek_music(object: *mut GoaObject) -> *mut GoaMusic;
    pub fn goa_object_peek_oauth2_based(object: *mut GoaObject) -> *mut GoaOAuth2Based;
    pub fn goa_object_peek_oauth_based(object: *mut GoaObject) -> *mut GoaOAuthBased;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_object_peek_password_based(object: *mut GoaObject) -> *mut GoaPasswordBased;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_object_peek_photos(object: *mut GoaObject) -> *mut GoaPhotos;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_object_peek_printers(object: *mut GoaObject) -> *mut GoaPrinters;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_object_peek_read_later(object: *mut GoaObject) -> *mut GoaReadLater;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_object_peek_ticketing(object: *mut GoaObject) -> *mut GoaTicketing;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_object_peek_todo(object: *mut GoaObject) -> *mut GoaTodo;

    //=========================================================================
    // GoaPasswordBased
    //=========================================================================
    pub fn goa_password_based_get_type() -> GType;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_password_based_interface_info() -> *mut gio::GDBusInterfaceInfo;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_password_based_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_password_based_call_get_password(proxy: *mut GoaPasswordBased, arg_id: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_password_based_call_get_password_finish(proxy: *mut GoaPasswordBased, out_password: *mut *mut c_char, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_password_based_call_get_password_sync(proxy: *mut GoaPasswordBased, arg_id: *const c_char, out_password: *mut *mut c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_password_based_complete_get_password(object: *mut GoaPasswordBased, invocation: *mut gio::GDBusMethodInvocation, password: *const c_char);

    //=========================================================================
    // GoaPhotos
    //=========================================================================
    pub fn goa_photos_get_type() -> GType;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_photos_interface_info() -> *mut gio::GDBusInterfaceInfo;
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_photos_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;

    //=========================================================================
    // GoaPrinters
    //=========================================================================
    pub fn goa_printers_get_type() -> GType;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_printers_interface_info() -> *mut gio::GDBusInterfaceInfo;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_printers_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;

    //=========================================================================
    // GoaReadLater
    //=========================================================================
    pub fn goa_read_later_get_type() -> GType;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_read_later_interface_info() -> *mut gio::GDBusInterfaceInfo;
    #[cfg(any(feature = "v3_12", feature = "dox"))]
    pub fn goa_read_later_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;

    //=========================================================================
    // GoaTicketing
    //=========================================================================
    pub fn goa_ticketing_get_type() -> GType;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_ticketing_interface_info() -> *mut gio::GDBusInterfaceInfo;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_ticketing_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_ticketing_call_get_ticket(proxy: *mut GoaTicketing, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_ticketing_call_get_ticket_finish(proxy: *mut GoaTicketing, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_ticketing_call_get_ticket_sync(proxy: *mut GoaTicketing, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
    #[cfg(any(feature = "v3_6", feature = "dox"))]
    pub fn goa_ticketing_complete_get_ticket(object: *mut GoaTicketing, invocation: *mut gio::GDBusMethodInvocation);
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_ticketing_dup_details(object: *mut GoaTicketing) -> *mut glib::GVariant;
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_ticketing_get_details(object: *mut GoaTicketing) -> *mut glib::GVariant;
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn goa_ticketing_set_details(object: *mut GoaTicketing, value: *mut glib::GVariant);

    //=========================================================================
    // GoaTodo
    //=========================================================================
    pub fn goa_todo_get_type() -> GType;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_todo_interface_info() -> *mut gio::GDBusInterfaceInfo;
    #[cfg(any(feature = "v3_26", feature = "dox"))]
    pub fn goa_todo_override_properties(klass: *mut gobject::GObjectClass, property_id_begin: c_uint) -> c_uint;

    //=========================================================================
    // Other functions
    //=========================================================================
    #[cfg(any(feature = "v3_8", feature = "dox"))]
    pub fn goa_check_version(required_major: c_uint, required_minor: c_uint, required_micro: c_uint) -> *const c_char;

}