object-introspection-1.30.0 support.

[girtod.git] / gtk2 / gio2.d

// *** DO NOT EDIT ***
// Automatically generated from "/usr/share/gir-1.0/Gio-2.0.gir"

module Gio2;
public import gtk2.glib2;
alias gtk2.glib2 GLib2;
public import gtk2.gobject2;
alias gtk2.gobject2 GObject2;

// package: "gio-2.0";

// package: "gio-unix-2.0";
// C header: "/sw/x86/gtk2/glib-2.30.2/include/gio-unix-2.0/gio/gdesktopappinfo.h";
// C header: "/sw/x86/gtk2/glib-2.30.2/include/gio-unix-2.0/gio/gfiledescriptorbased.h";
// C header: "/sw/x86/gtk2/glib-2.30.2/include/gio-unix-2.0/gio/gunixconnection.h";
// C header: "/sw/x86/gtk2/glib-2.30.2/include/gio-unix-2.0/gio/gunixcredentialsmessage.h";
// C header: "/sw/x86/gtk2/glib-2.30.2/include/gio-unix-2.0/gio/gunixfdlist.h";
// C header: "/sw/x86/gtk2/glib-2.30.2/include/gio-unix-2.0/gio/gunixfdmessage.h";
// C header: "/sw/x86/gtk2/glib-2.30.2/include/gio-unix-2.0/gio/gunixinputstream.h";
// C header: "/sw/x86/gtk2/glib-2.30.2/include/gio-unix-2.0/gio/gunixmounts.h";
// C header: "/sw/x86/gtk2/glib-2.30.2/include/gio-unix-2.0/gio/gunixoutputstream.h";
// C header: "/sw/x86/gtk2/glib-2.30.2/include/gio-unix-2.0/gio/gunixsocketaddress.h";
// C header: "gio/gio.h";

// c:symbol-prefixes: ["g"]
// c:identifier-prefixes: ["G"]

// module Gio2;


// #GAction represents a single named action.
// 
// The main interface to an action is that it can be activated with
// g_action_activate().  This results in the 'activate' signal being
// emitted.  An activation has a #GVariant parameter (which may be
// %NULL).  The correct type for the parameter is determined by a static
// parameter type (which is given at construction time).
// 
// An action may optionally have a state, in which case the state may be
// set with g_action_change_state().  This call takes a #GVariant.  The
// correct type for the state is determined by a static state type
// (which is given at construction time).
// 
// The state may have a hint associated with it, specifying its valid
// range.
// 
// #GAction is merely the interface to the concept of an action, as
// described above.  Various implementations of actions exist, including
// #GSimpleAction and #GtkAction.
// 
// In all cases, the implementing class is responsible for storing the
// name of the action, the parameter type, the enabled state, the
// optional state type and the state and emitting the appropriate
// signals when these change.  The implementor responsible for filtering
// calls to g_action_activate() and g_action_change_state() for type
// safety and for the state being enabled.
// 
// Probably the only useful thing to do with a #GAction is to put it
// inside of a #GSimpleActionGroup.
struct Action {

   // Activates the action.
   // 
   // @parameter must be the correct type of parameter for the action (ie:
   // the parameter type given at construction time).  If the parameter
   // type was %NULL then @parameter must also be %NULL.
   // <parameter>: the parameter to the activation
   void activate(GLib2.Variant* parameter=null) {
      g_action_activate(&this, parameter);
   }

   // Request for the state of @action to be changed to @value.
   // 
   // The action must be stateful and @value must be of the correct type.
   // See g_action_get_state_type().
   // 
   // This call merely requests a change.  The action may refuse to change
   // its state or may change its state to something other than @value.
   // See g_action_get_state_hint().
   // 
   // If the @value GVariant is floating, it is consumed.
   // <value>: the new state
   void change_state(GLib2.Variant* value) {
      g_action_change_state(&this, value);
   }

   // Checks if @action is currently enabled.
   // 
   // An action must be enabled in order to be activated or in order to
   // have its state changed from outside callers.
   // RETURNS: whether the action is enabled
   int get_enabled() {
      return g_action_get_enabled(&this);
   }

   // Queries the name of @action.
   // RETURNS: the name of the action
   char* get_name() {
      return g_action_get_name(&this);
   }

   // Queries the type of the parameter that must be given when activating
   // @action.
   // 
   // When activating the action using g_action_activate(), the #GVariant
   // given to that function must be of the type returned by this function.
   // 
   // In the case that this function returns %NULL, you must not give any
   // #GVariant, but %NULL instead.
   // RETURNS: the parameter type
   GLib2.VariantType* get_parameter_type() {
      return g_action_get_parameter_type(&this);
   }

   // Queries the current state of @action.
   // 
   // If the action is not stateful then %NULL will be returned.  If the
   // action is stateful then the type of the return value is the type
   // given by g_action_get_state_type().
   // 
   // The return value (if non-%NULL) should be freed with
   // g_variant_unref() when it is no longer required.
   // RETURNS: the current state of the action
   GLib2.Variant* /*new*/ get_state() {
      return g_action_get_state(&this);
   }

   // Requests a hint about the valid range of values for the state of
   // @action.
   // 
   // If %NULL is returned it either means that the action is not stateful
   // or that there is no hint about the valid range of values for the
   // state of the action.
   // 
   // If a #GVariant array is returned then each item in the array is a
   // possible value for the state.  If a #GVariant pair (ie: two-tuple) is
   // returned then the tuple specifies the inclusive lower and upper bound
   // of valid values for the state.
   // 
   // In any case, the information is merely a hint.  It may be possible to
   // have a state value outside of the hinted range and setting a value
   // within the range may fail.
   // 
   // The return value (if non-%NULL) should be freed with
   // g_variant_unref() when it is no longer required.
   // RETURNS: the state range hint
   GLib2.Variant* /*new*/ get_state_hint() {
      return g_action_get_state_hint(&this);
   }

   // Queries the type of the state of @action.
   // 
   // If the action is stateful (e.g. created with
   // g_simple_action_new_stateful()) then this function returns the
   // #GVariantType of the state.  This is the type of the initial value
   // given as the state. All calls to g_action_change_state() must give a
   // #GVariant of this type and g_action_get_state() will return a
   // #GVariant of the same type.
   // 
   // If the action is not stateful (e.g. created with g_simple_action_new())
   // then this function will return %NULL. In that case, g_action_get_state()
   // will return %NULL and you must not call g_action_change_state().
   // RETURNS: the state type, if the action is stateful
   GLib2.VariantType* get_state_type() {
      return g_action_get_state_type(&this);
   }
}


// This struct defines a single action.  It is for use with
// g_simple_action_group_add_entries().
// 
// The order of the items in the structure are intended to reflect
// frequency of use.  It is permissible to use an incomplete initialiser
// in order to leave some of the later values as %NULL.  All values
// after @name are optional.  Additional optional fields may be added in
// the future.
// 
// See g_simple_action_group_add_entries() for an example.
struct ActionEntry {
   char* name;
   extern (C) void function (SimpleAction* action, GLib2.Variant* parameter, void* user_data) activate;
   char* parameter_type, state;
   extern (C) void function (SimpleAction* action, GLib2.Variant* value, void* user_data) change_state;
   private size_t[3] padding;
}


// #GActionGroup represents a group of actions.
// 
// Each action in the group has a unique name (which is a string).  All
// method calls, except g_action_group_list_actions() take the name of
// an action as an argument.
// 
// The #GActionGroup API is meant to be the 'public' API to the action
// group.  The calls here are exactly the interaction that 'external
// forces' (eg: UI, incoming D-Bus messages, etc.) are supposed to have
// with actions.  'Internal' APIs (ie: ones meant only to be accessed by
// the action group implementation) are found on subclasses.  This is
// why you will find -- for example -- g_action_group_get_action_enabled()
// but not an equivalent <function>set()</function> call.
// 
// Signals are emitted on the action group in response to state changes
// on individual actions.
struct ActionGroup {

   // Emits the #GActionGroup::action-added signal on @action_group.
   // 
   // This function should only be called by #GActionGroup implementations.
   // <action_name>: the name of an action in the group
   void action_added(char* action_name) {
      g_action_group_action_added(&this, action_name);
   }

   // Emits the #GActionGroup::action-enabled-changed signal on @action_group.
   // 
   // This function should only be called by #GActionGroup implementations.
   // <action_name>: the name of an action in the group
   // <enabled>: whether or not the action is now enabled
   void action_enabled_changed(char* action_name, int enabled) {
      g_action_group_action_enabled_changed(&this, action_name, enabled);
   }

   // Emits the #GActionGroup::action-removed signal on @action_group.
   // 
   // This function should only be called by #GActionGroup implementations.
   // <action_name>: the name of an action in the group
   void action_removed(char* action_name) {
      g_action_group_action_removed(&this, action_name);
   }

   // Emits the #GActionGroup::action-state-changed signal on @action_group.
   // 
   // This function should only be called by #GActionGroup implementations.
   // <action_name>: the name of an action in the group
   // <state>: the new state of the named action
   void action_state_changed(char* action_name, GLib2.Variant* state) {
      g_action_group_action_state_changed(&this, action_name, state);
   }

   // Activate the named action within @action_group.
   // 
   // If the action is expecting a parameter, then the correct type of
   // parameter must be given as @parameter.  If the action is expecting no
   // parameters then @parameter must be %NULL.  See
   // g_action_group_get_action_parameter_type().
   // <action_name>: the name of the action to activate
   // <parameter>: parameters to the activation
   void activate_action(char* action_name, GLib2.Variant* parameter=null) {
      g_action_group_activate_action(&this, action_name, parameter);
   }

   // Request for the state of the named action within @action_group to be
   // changed to @value.
   // 
   // The action must be stateful and @value must be of the correct type.
   // See g_action_group_get_action_state_type().
   // 
   // This call merely requests a change.  The action may refuse to change
   // its state or may change its state to something other than @value.
   // See g_action_group_get_action_state_hint().
   // 
   // If the @value GVariant is floating, it is consumed.
   // <action_name>: the name of the action to request the change on
   // <value>: the new state
   void change_action_state(char* action_name, GLib2.Variant* value) {
      g_action_group_change_action_state(&this, action_name, value);
   }

   // Checks if the named action within @action_group is currently enabled.
   // 
   // An action must be enabled in order to be activated or in order to
   // have its state changed from outside callers.
   // RETURNS: whether or not the action is currently enabled
   // <action_name>: the name of the action to query
   int get_action_enabled(char* action_name) {
      return g_action_group_get_action_enabled(&this, action_name);
   }

   // Queries the type of the parameter that must be given when activating
   // the named action within @action_group.
   // 
   // When activating the action using g_action_group_activate_action(),
   // the #GVariant given to that function must be of the type returned
   // by this function.
   // 
   // In the case that this function returns %NULL, you must not give any
   // #GVariant, but %NULL instead.
   // 
   // The parameter type of a particular action will never change but it is
   // possible for an action to be removed and for a new action to be added
   // with the same name but a different parameter type.
   // RETURNS: the parameter type
   // <action_name>: the name of the action to query
   GLib2.VariantType* get_action_parameter_type(char* action_name) {
      return g_action_group_get_action_parameter_type(&this, action_name);
   }

   // Queries the current state of the named action within @action_group.
   // 
   // If the action is not stateful then %NULL will be returned.  If the
   // action is stateful then the type of the return value is the type
   // given by g_action_group_get_action_state_type().
   // 
   // The return value (if non-%NULL) should be freed with
   // g_variant_unref() when it is no longer required.
   // RETURNS: the current state of the action
   // <action_name>: the name of the action to query
   GLib2.Variant* /*new*/ get_action_state(char* action_name) {
      return g_action_group_get_action_state(&this, action_name);
   }

   // Requests a hint about the valid range of values for the state of the
   // named action within @action_group.
   // 
   // If %NULL is returned it either means that the action is not stateful
   // or that there is no hint about the valid range of values for the
   // state of the action.
   // 
   // If a #GVariant array is returned then each item in the array is a
   // possible value for the state.  If a #GVariant pair (ie: two-tuple) is
   // returned then the tuple specifies the inclusive lower and upper bound
   // of valid values for the state.
   // 
   // In any case, the information is merely a hint.  It may be possible to
   // have a state value outside of the hinted range and setting a value
   // within the range may fail.
   // 
   // The return value (if non-%NULL) should be freed with
   // g_variant_unref() when it is no longer required.
   // RETURNS: the state range hint
   // <action_name>: the name of the action to query
   GLib2.Variant* /*new*/ get_action_state_hint(char* action_name) {
      return g_action_group_get_action_state_hint(&this, action_name);
   }

   // Queries the type of the state of the named action within
   // @action_group.
   // 
   // If the action is stateful then this function returns the
   // #GVariantType of the state.  All calls to
   // g_action_group_change_action_state() must give a #GVariant of this
   // type and g_action_group_get_action_state() will return a #GVariant
   // of the same type.
   // 
   // If the action is not stateful then this function will return %NULL.
   // In that case, g_action_group_get_action_state() will return %NULL
   // and you must not call g_action_group_change_action_state().
   // 
   // The state type of a particular action will never change but it is
   // possible for an action to be removed and for a new action to be added
   // with the same name but a different state type.
   // RETURNS: the state type, if the action is stateful
   // <action_name>: the name of the action to query
   GLib2.VariantType* /*new*/ get_action_state_type(char* action_name) {
      return g_action_group_get_action_state_type(&this, action_name);
   }

   // Checks if the named action exists within @action_group.
   // RETURNS: whether the named action exists
   // <action_name>: the name of the action to check for
   int has_action(char* action_name) {
      return g_action_group_has_action(&this, action_name);
   }

   // Lists the actions contained within @action_group.
   // 
   // The caller is responsible for freeing the list with g_strfreev() when
   // it is no longer required.
   // 
   // actions in the groupb
   // RETURNS: a %NULL-terminated array of the names of the
   char** /*new*/ list_actions() {
      return g_action_group_list_actions(&this);
   }

   // Signals that a new action was just added to the group.
   // This signal is emitted after the action has been added
   // and is now visible.
   // <action_name>: the name of the action in @action_group
   extern (C) alias static void function (ActionGroup* this_, char* action_name, void* user_data=null) signal_action_added;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"action-added", CB:signal_action_added)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"action-added",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Signals that the enabled status of the named action has changed.
   // <action_name>: the name of the action in @action_group
   // <enabled>: whether the action is enabled or not
   extern (C) alias static void function (ActionGroup* this_, char* action_name, c_int enabled, void* user_data=null) signal_action_enabled_changed;
   ulong signal_connect(string name:"action-enabled-changed", CB:signal_action_enabled_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"action-enabled-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Signals that an action is just about to be removed from the group.
   // This signal is emitted before the action is removed, so the action
   // is still visible and can be queried from the signal handler.
   // <action_name>: the name of the action in @action_group
   extern (C) alias static void function (ActionGroup* this_, char* action_name, void* user_data=null) signal_action_removed;
   ulong signal_connect(string name:"action-removed", CB:signal_action_removed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"action-removed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Signals that the state of the named action has changed.
   // <action_name>: the name of the action in @action_group
   // <value>: the new value of the state
   extern (C) alias static void function (ActionGroup* this_, char* action_name, GLib2.Variant* value, void* user_data=null) signal_action_state_changed;
   ulong signal_connect(string name:"action-state-changed", CB:signal_action_state_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"action-state-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

// The virtual function table for #GActionGroup.
struct ActionGroupInterface /* Version 2.28 */ {
   GObject2.TypeInterface g_iface;

   // RETURNS: whether the named action exists
   // <action_name>: the name of the action to check for
   extern (C) int function (ActionGroup* action_group, char* action_name) has_action;
   // RETURNS: a %NULL-terminated array of the names of the
   extern (C) char** /*new*/ function (ActionGroup* action_group) list_actions;

   // RETURNS: whether or not the action is currently enabled
   // <action_name>: the name of the action to query
   extern (C) int function (ActionGroup* action_group, char* action_name) get_action_enabled;

   // RETURNS: the parameter type
   // <action_name>: the name of the action to query
   extern (C) GLib2.VariantType* function (ActionGroup* action_group, char* action_name) get_action_parameter_type;

   // RETURNS: the state type, if the action is stateful
   // <action_name>: the name of the action to query
   extern (C) GLib2.VariantType* /*new*/ function (ActionGroup* action_group, char* action_name) get_action_state_type;

   // RETURNS: the state range hint
   // <action_name>: the name of the action to query
   extern (C) GLib2.Variant* /*new*/ function (ActionGroup* action_group, char* action_name) get_action_state_hint;

   // RETURNS: the current state of the action
   // <action_name>: the name of the action to query
   extern (C) GLib2.Variant* /*new*/ function (ActionGroup* action_group, char* action_name) get_action_state;

   // <action_name>: the name of the action to request the change on
   // <value>: the new state
   extern (C) void function (ActionGroup* action_group, char* action_name, GLib2.Variant* value) change_action_state;

   // <action_name>: the name of the action to activate
   // <parameter>: parameters to the activation
   extern (C) void function (ActionGroup* action_group, char* action_name, GLib2.Variant* parameter=null) activate_action;
   // <action_name>: the name of an action in the group
   extern (C) void function (ActionGroup* action_group, char* action_name) action_added;
   // <action_name>: the name of an action in the group
   extern (C) void function (ActionGroup* action_group, char* action_name) action_removed;

   // <action_name>: the name of an action in the group
   // <enabled>: whether or not the action is now enabled
   extern (C) void function (ActionGroup* action_group, char* action_name, int enabled) action_enabled_changed;

   // <action_name>: the name of an action in the group
   // <state>: the new state of the named action
   extern (C) void function (ActionGroup* action_group, char* action_name, GLib2.Variant* state) action_state_changed;
}

struct ActionInterface /* Version 2.28 */ {
   GObject2.TypeInterface g_iface;
   // RETURNS: the name of the action
   extern (C) char* function (Action* action) get_name;
   // RETURNS: the parameter type
   extern (C) GLib2.VariantType* function (Action* action) get_parameter_type;
   // RETURNS: the state type, if the action is stateful
   extern (C) GLib2.VariantType* function (Action* action) get_state_type;
   // RETURNS: the state range hint
   extern (C) GLib2.Variant* /*new*/ function (Action* action) get_state_hint;
   // RETURNS: whether the action is enabled
   extern (C) int function (Action* action) get_enabled;
   // RETURNS: the current state of the action
   extern (C) GLib2.Variant* /*new*/ function (Action* action) get_state;
   // <value>: the new state
   extern (C) void function (Action* action, GLib2.Variant* value) change_state;
   // <parameter>: the parameter to the activation
   extern (C) void function (Action* action, GLib2.Variant* parameter=null) activate;
}


// #GAppInfo and #GAppLaunchContext are used for describing and launching
// applications installed on the system.
// 
// As of GLib 2.20, URIs will always be converted to POSIX paths
// (using g_file_get_path()) when using g_app_info_launch() even if
// the application requested an URI and not a POSIX path. For example
// for an desktop-file based application with Exec key <literal>totem
// &percnt;U</literal> and a single URI,
// <literal>sftp://foo/file.avi</literal>, then
// <literal>/home/user/.gvfs/sftp on foo/file.avi</literal> will be
// passed. This will only work if a set of suitable GIO extensions
// (such as gvfs 2.26 compiled with FUSE support), is available and
// operational; if this is not the case, the URI will be passed
// unmodified to the application. Some URIs, such as
// <literal>mailto:</literal>, of course cannot be mapped to a POSIX
// path (in gvfs there's no FUSE mount for it); such URIs will be
// passed unmodified to the application.
// 
// Specifically for gvfs 2.26 and later, the POSIX URI will be mapped
// back to the GIO URI in the #GFile constructors (since gvfs
// implements the #GVfs extension point). As such, if the application
// needs to examine the URI, it needs to use g_file_get_uri() or
// similar on #GFile. In other words, an application cannot assume
// that the URI passed to e.g. g_file_new_for_commandline_arg() is
// equal to the result of g_file_get_uri(). The following snippet
// illustrates this:
// 
// <programlisting>
// GFile *f;
// char *uri;
// 
// file = g_file_new_for_commandline_arg (uri_from_commandline);
// 
// uri = g_file_get_uri (file);
// strcmp (uri, uri_from_commandline) == 0; // FALSE
// g_free (uri);
// 
// if (g_file_has_uri_scheme (file, "cdda"))
// {
// // do something special with uri
// }
// g_object_unref (file);
// </programlisting>
// 
// This code will work when both <literal>cdda://sr0/Track
// 1.wav</literal> and <literal>/home/user/.gvfs/cdda on sr0/Track
// 1.wav</literal> is passed to the application. It should be noted
// that it's generally not safe for applications to rely on the format
// of a particular URIs. Different launcher applications (e.g. file
// managers) may have different ideas of what a given URI means.
struct AppInfo {

   // Creates a new #GAppInfo from the given information.
   // RETURNS: new #GAppInfo for given command.
   // <commandline>: the commandline to use
   // <application_name>: the application name, or %NULL to use @commandline
   // <flags>: flags that can specify details of the created #GAppInfo
   static AppInfo* /*new*/ create_from_commandline(char* commandline, char* application_name, AppInfoCreateFlags flags, GLib2.Error** error=null) {
      return g_app_info_create_from_commandline(commandline, application_name, flags, error);
   }

   // Gets a list of all of the applications currently registered
   // on this system.
   // 
   // For desktop files, this includes applications that have
   // <literal>NoDisplay=true</literal> set or are excluded from
   // display by means of <literal>OnlyShowIn</literal> or
   // <literal>NotShowIn</literal>. See g_app_info_should_show().
   // The returned list does not include applications which have
   // the <literal>Hidden</literal> key set.
   // RETURNS: a newly allocated #GList of references to #GAppInfo<!---->s.
   static GLib2.List* /*new*/ get_all() {
      return g_app_info_get_all();
   }

   // Gets a list of all #GAppInfos for a given content type.
   // 
   // for given @content_type or %NULL on error.
   // RETURNS: #GList of #GAppInfos
   // <content_type>: the content type to find a #GAppInfo for
   static GLib2.List* /*new*/ get_all_for_type(char* content_type) {
      return g_app_info_get_all_for_type(content_type);
   }

   // Gets the #GAppInfo that corresponds to a given content type.
   // 
   // %NULL on error.
   // RETURNS: #GAppInfo for given @content_type or
   // <content_type>: the content type to find a #GAppInfo for
   // <must_support_uris>: if %TRUE, the #GAppInfo is expected to support URIs
   static AppInfo* /*new*/ get_default_for_type(char* content_type, int must_support_uris) {
      return g_app_info_get_default_for_type(content_type, must_support_uris);
   }

   // Gets the default application for launching applications
   // using this URI scheme. A URI scheme is the initial part
   // of the URI, up to but not including the ':', e.g. "http",
   // "ftp" or "sip".
   // RETURNS: #GAppInfo for given @uri_scheme or %NULL on error.
   // <uri_scheme>: a string containing a URI scheme.
   static AppInfo* /*new*/ get_default_for_uri_scheme(char* uri_scheme) {
      return g_app_info_get_default_for_uri_scheme(uri_scheme);
   }

   // Gets a list of fallback #GAppInfos for a given content type, i.e.
   // those applications which claim to support the given content type
   // by MIME type subclassing and not directly.
   // 
   // for given @content_type or %NULL on error.
   // RETURNS: #GList of #GAppInfos
   // <content_type>: the content type to find a #GAppInfo for
   static GLib2.List* /*new*/ get_fallback_for_type(char* content_type) {
      return g_app_info_get_fallback_for_type(content_type);
   }

   // Gets a list of recommended #GAppInfos for a given content type, i.e.
   // those applications which claim to support the given content type exactly,
   // and not by MIME type subclassing.
   // Note that the first application of the list is the last used one, i.e.
   // the last one for which #g_app_info_set_as_last_used_for_type has been
   // called.
   // 
   // for given @content_type or %NULL on error.
   // RETURNS: #GList of #GAppInfos
   // <content_type>: the content type to find a #GAppInfo for
   static GLib2.List* /*new*/ get_recommended_for_type(char* content_type) {
      return g_app_info_get_recommended_for_type(content_type);
   }

   // Utility function that launches the default application
   // registered to handle the specified uri. Synchronous I/O
   // is done on the uri to detect the type of the file if
   // required.
   // RETURNS: %TRUE on success, %FALSE on error.
   // <uri>: the uri to show
   // <launch_context>: an optional #GAppLaunchContext.
   static int launch_default_for_uri(char* uri, AppLaunchContext* launch_context, GLib2.Error** error=null) {
      return g_app_info_launch_default_for_uri(uri, launch_context, error);
   }

   // Removes all changes to the type associations done by
   // g_app_info_set_as_default_for_type(),
   // g_app_info_set_as_default_for_extension(),
   // g_app_info_add_supports_type() or g_app_info_remove_supports_type().
   // <content_type>: a content type
   static void reset_type_associations(char* content_type) {
      g_app_info_reset_type_associations(content_type);
   }

   // Adds a content type to the application information to indicate the
   // application is capable of opening files with the given content type.
   // RETURNS: %TRUE on success, %FALSE on error.
   // <content_type>: a string.
   int add_supports_type(char* content_type, GLib2.Error** error=null) {
      return g_app_info_add_supports_type(&this, content_type, error);
   }

   // Obtains the information whether the #GAppInfo can be deleted.
   // See g_app_info_delete().
   // RETURNS: %TRUE if @appinfo can be deleted
   int can_delete() {
      return g_app_info_can_delete(&this);
   }

   // Checks if a supported content type can be removed from an application.
   // 
   // content types from a given @appinfo, %FALSE if not.
   // RETURNS: %TRUE if it is possible to remove supported
   int can_remove_supports_type() {
      return g_app_info_can_remove_supports_type(&this);
   }

   // Tries to delete a #GAppInfo.
   // 
   // On some platforms, there may be a difference between user-defined
   // #GAppInfo<!-- -->s which can be deleted, and system-wide ones which
   // cannot. See g_app_info_can_delete().
   // RETURNS: %TRUE if @appinfo has been deleted
   int delete_() {
      return g_app_info_delete(&this);
   }

   // Creates a duplicate of a #GAppInfo.
   // RETURNS: a duplicate of @appinfo.
   AppInfo* /*new*/ dup() {
      return g_app_info_dup(&this);
   }

   // Checks if two #GAppInfo<!-- -->s are equal.
   // RETURNS: %TRUE if @appinfo1 is equal to @appinfo2. %FALSE otherwise.
   // <appinfo2>: the second #GAppInfo.
   int equal(AppInfo* appinfo2) {
      return g_app_info_equal(&this, appinfo2);
   }

   // Gets the commandline with which the application will be
   // started.
   // 
   // or %NULL if this information is not available
   // RETURNS: a string containing the @appinfo's commandline,
   char* get_commandline() {
      return g_app_info_get_commandline(&this);
   }

   // Gets a human-readable description of an installed application.
   // 
   // application @appinfo, or %NULL if none.
   // RETURNS: a string containing a description of the
   char* get_description() {
      return g_app_info_get_description(&this);
   }

   // Gets the display name of the application. The display name is often more
   // descriptive to the user than the name itself.
   // 
   // no display name is available.
   // RETURNS: the display name of the application for @appinfo, or the name if
   char* get_display_name() {
      return g_app_info_get_display_name(&this);
   }

   // Gets the executable's name for the installed application.
   // 
   // binaries name
   // RETURNS: a string containing the @appinfo's application
   char* get_executable() {
      return g_app_info_get_executable(&this);
   }

   // Gets the icon for the application.
   // RETURNS: the default #GIcon for @appinfo.
   Icon* get_icon() {
      return g_app_info_get_icon(&this);
   }

   // Gets the ID of an application. An id is a string that
   // identifies the application. The exact format of the id is
   // platform dependent. For instance, on Unix this is the
   // desktop file id from the xdg menu specification.
   // 
   // Note that the returned ID may be %NULL, depending on how
   // the @appinfo has been constructed.
   // RETURNS: a string containing the application's ID.
   char* get_id() {
      return g_app_info_get_id(&this);
   }

   // Gets the installed name of the application.
   // RETURNS: the name of the application for @appinfo.
   char* get_name() {
      return g_app_info_get_name(&this);
   }

   // Launches the application. Passes @files to the launched application
   // as arguments, using the optional @launch_context to get information
   // about the details of the launcher (like what screen it is on).
   // On error, @error will be set accordingly.
   // 
   // To launch the application without arguments pass a %NULL @files list.
   // 
   // Note that even if the launch is successful the application launched
   // can fail to start if it runs into problems during startup. There is
   // no way to detect this.
   // 
   // Some URIs can be changed when passed through a GFile (for instance
   // unsupported uris with strange formats like mailto:), so if you have
   // a textual uri you want to pass in as argument, consider using
   // g_app_info_launch_uris() instead.
   // 
   // On UNIX, this function sets the <envar>GIO_LAUNCHED_DESKTOP_FILE</envar>
   // environment variable with the path of the launched desktop file and
   // <envar>GIO_LAUNCHED_DESKTOP_FILE_PID</envar> to the process
   // id of the launched process. This can be used to ignore
   // <envar>GIO_LAUNCHED_DESKTOP_FILE</envar>, should it be inherited
   // by further processes. The <envar>DISPLAY</envar> and
   // <envar>DESKTOP_STARTUP_ID</envar> environment variables are also
   // set, based on information provided in @launch_context.
   // RETURNS: %TRUE on successful launch, %FALSE otherwise.
   // <files>: a #GList of #GFile objects
   // <launch_context>: a #GAppLaunchContext or %NULL
   int launch(GLib2.List* files, AppLaunchContext* launch_context, GLib2.Error** error=null) {
      return g_app_info_launch(&this, files, launch_context, error);
   }

   // Launches the application. This passes the @uris to the launched application
   // as arguments, using the optional @launch_context to get information
   // about the details of the launcher (like what screen it is on).
   // On error, @error will be set accordingly.
   // 
   // To launch the application without arguments pass a %NULL @uris list.
   // 
   // Note that even if the launch is successful the application launched
   // can fail to start if it runs into problems during startup. There is
   // no way to detect this.
   // RETURNS: %TRUE on successful launch, %FALSE otherwise.
   // <uris>: a #GList containing URIs to launch.
   // <launch_context>: a #GAppLaunchContext or %NULL
   int launch_uris(GLib2.List* uris, AppLaunchContext* launch_context, GLib2.Error** error=null) {
      return g_app_info_launch_uris(&this, uris, launch_context, error);
   }

   // Removes a supported type from an application, if possible.
   // RETURNS: %TRUE on success, %FALSE on error.
   // <content_type>: a string.
   int remove_supports_type(char* content_type, GLib2.Error** error=null) {
      return g_app_info_remove_supports_type(&this, content_type, error);
   }

   // Sets the application as the default handler for the given file extension.
   // RETURNS: %TRUE on success, %FALSE on error.
   // <extension>: a string containing the file extension (without the dot).
   int set_as_default_for_extension(char* extension, GLib2.Error** error=null) {
      return g_app_info_set_as_default_for_extension(&this, extension, error);
   }

   // Sets the application as the default handler for a given type.
   // RETURNS: %TRUE on success, %FALSE on error.
   // <content_type>: the content type.
   int set_as_default_for_type(char* content_type, GLib2.Error** error=null) {
      return g_app_info_set_as_default_for_type(&this, content_type, error);
   }

   // Sets the application as the last used application for a given type.
   // This will make the application appear as first in the list returned
   // by g_app_info_get_recommended_for_type(), regardless of the default
   // application for that content type.
   // RETURNS: %TRUE on success, %FALSE on error.
   // <content_type>: the content type.
   int set_as_last_used_for_type(char* content_type, GLib2.Error** error=null) {
      return g_app_info_set_as_last_used_for_type(&this, content_type, error);
   }

   // Checks if the application info should be shown in menus that
   // list available applications.
   // RETURNS: %TRUE if the @appinfo should be shown, %FALSE otherwise.
   int should_show() {
      return g_app_info_should_show(&this);
   }

   // Checks if the application accepts files as arguments.
   // RETURNS: %TRUE if the @appinfo supports files.
   int supports_files() {
      return g_app_info_supports_files(&this);
   }

   // Checks if the application supports reading files and directories from URIs.
   // RETURNS: %TRUE if the @appinfo supports URIs.
   int supports_uris() {
      return g_app_info_supports_uris(&this);
   }
}

// Flags used when creating a #GAppInfo.
enum AppInfoCreateFlags {
   NONE = 0,
   NEEDS_TERMINAL = 1,
   SUPPORTS_URIS = 2,
   SUPPORTS_STARTUP_NOTIFICATION = 4
}
// Application Information interface, for operating system portability.
struct AppInfoIface {
   GObject2.TypeInterface g_iface;
   // RETURNS: a duplicate of @appinfo.
   extern (C) AppInfo* /*new*/ function (AppInfo* appinfo) dup;

   // RETURNS: %TRUE if @appinfo1 is equal to @appinfo2. %FALSE otherwise.
   // <appinfo2>: the second #GAppInfo.
   extern (C) int function (AppInfo* appinfo1, AppInfo* appinfo2) equal;
   // RETURNS: a string containing the application's ID.
   extern (C) char* function (AppInfo* appinfo) get_id;
   // RETURNS: the name of the application for @appinfo.
   extern (C) char* function (AppInfo* appinfo) get_name;
   // RETURNS: a string containing a description of the
   extern (C) char* function (AppInfo* appinfo) get_description;
   // RETURNS: a string containing the @appinfo's application
   extern (C) char* function (AppInfo* appinfo) get_executable;
   // RETURNS: the default #GIcon for @appinfo.
   extern (C) Icon* function (AppInfo* appinfo) get_icon;

   // RETURNS: %TRUE on successful launch, %FALSE otherwise.
   // <files>: a #GList of #GFile objects
   // <launch_context>: a #GAppLaunchContext or %NULL
   extern (C) int function (AppInfo* appinfo, GLib2.List* files, AppLaunchContext* launch_context, GLib2.Error** error=null) launch;
   // RETURNS: %TRUE if the @appinfo supports URIs.
   extern (C) int function (AppInfo* appinfo) supports_uris;
   // RETURNS: %TRUE if the @appinfo supports files.
   extern (C) int function (AppInfo* appinfo) supports_files;

   // RETURNS: %TRUE on successful launch, %FALSE otherwise.
   // <uris>: a #GList containing URIs to launch.
   // <launch_context>: a #GAppLaunchContext or %NULL
   extern (C) int function (AppInfo* appinfo, GLib2.List* uris, AppLaunchContext* launch_context, GLib2.Error** error=null) launch_uris;
   // RETURNS: %TRUE if the @appinfo should be shown, %FALSE otherwise.
   extern (C) int function (AppInfo* appinfo) should_show;

   // RETURNS: %TRUE on success, %FALSE on error.
   // <content_type>: the content type.
   extern (C) int function (AppInfo* appinfo, char* content_type, GLib2.Error** error=null) set_as_default_for_type;

   // RETURNS: %TRUE on success, %FALSE on error.
   // <extension>: a string containing the file extension (without the dot).
   extern (C) int function (AppInfo* appinfo, char* extension, GLib2.Error** error=null) set_as_default_for_extension;

   // RETURNS: %TRUE on success, %FALSE on error.
   // <content_type>: a string.
   extern (C) int function (AppInfo* appinfo, char* content_type, GLib2.Error** error=null) add_supports_type;
   // RETURNS: %TRUE if it is possible to remove supported
   extern (C) int function (AppInfo* appinfo) can_remove_supports_type;

   // RETURNS: %TRUE on success, %FALSE on error.
   // <content_type>: a string.
   extern (C) int function (AppInfo* appinfo, char* content_type, GLib2.Error** error=null) remove_supports_type;
   // RETURNS: %TRUE if @appinfo can be deleted
   extern (C) int function (AppInfo* appinfo) can_delete;
   // RETURNS: %TRUE if @appinfo has been deleted
   extern (C) int function (AppInfo* appinfo) do_delete;
   // RETURNS: a string containing the @appinfo's commandline,
   extern (C) char* function (AppInfo* appinfo) get_commandline;
   // RETURNS: the display name of the application for @appinfo, or the name if
   extern (C) char* function (AppInfo* appinfo) get_display_name;

   // RETURNS: %TRUE on success, %FALSE on error.
   // <content_type>: the content type.
   extern (C) int function (AppInfo* appinfo, char* content_type, GLib2.Error** error=null) set_as_last_used_for_type;
}


// Integrating the launch with the launching application. This is used to
// handle for instance startup notification and launching the new application
// on the same screen as the launching window.
struct AppLaunchContext /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private AppLaunchContextPrivate* priv;


   // Creates a new application launch context. This is not normally used,
   // instead you instantiate a subclass of this, such as #GdkAppLaunchContext.
   // RETURNS: a #GAppLaunchContext.
   static AppLaunchContext* /*new*/ new_() {
      return g_app_launch_context_new();
   }

   // Gets the display string for the @context. This is used to ensure new
   // applications are started on the same display as the launching
   // application, by setting the <envar>DISPLAY</envar> environment variable.
   // RETURNS: a display string for the display.
   // <info>: a #GAppInfo
   // <files>: a #GList of #GFile objects
   char* /*new*/ get_display(AppInfo* info, GLib2.List* files) {
      return g_app_launch_context_get_display(&this, info, files);
   }

   // Initiates startup notification for the application and returns the
   // <envar>DESKTOP_STARTUP_ID</envar> for the launched operation,
   // if supported.
   // 
   // Startup notification IDs are defined in the <ulink
   // url="http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt">
   // FreeDesktop.Org Startup Notifications standard</ulink>.
   // 
   // not supported.
   // RETURNS: a startup notification ID for the application, or %NULL if
   // <info>: a #GAppInfo
   // <files>: a #GList of of #GFile objects
   char* /*new*/ get_startup_notify_id(AppInfo* info, GLib2.List* files) {
      return g_app_launch_context_get_startup_notify_id(&this, info, files);
   }

   // Called when an application has failed to launch, so that it can cancel
   // the application startup notification started in g_app_launch_context_get_startup_notify_id().
   // <startup_notify_id>: the startup notification id that was returned by g_app_launch_context_get_startup_notify_id().
   void launch_failed(char* startup_notify_id) {
      g_app_launch_context_launch_failed(&this, startup_notify_id);
   }
}

struct AppLaunchContextClass {
   GObject2.ObjectClass parent_class;

   // RETURNS: a display string for the display.
   // <info>: a #GAppInfo
   // <files>: a #GList of #GFile objects
   extern (C) char* /*new*/ function (AppLaunchContext* context, AppInfo* info, GLib2.List* files) get_display;

   // RETURNS: a startup notification ID for the application, or %NULL if
   // <info>: a #GAppInfo
   // <files>: a #GList of of #GFile objects
   extern (C) char* /*new*/ function (AppLaunchContext* context, AppInfo* info, GLib2.List* files) get_startup_notify_id;
   // <startup_notify_id>: the startup notification id that was returned by g_app_launch_context_get_startup_notify_id().
   extern (C) void function (AppLaunchContext* context, char* startup_notify_id) launch_failed;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct AppLaunchContextPrivate {
}


// A #GApplication is the foundation of an application, unique for a
// given application identifier.  The GApplication class wraps some
// low-level platform-specific services and is intended to act as the
// foundation for higher-level application classes such as
// #GtkApplication or #MxApplication.  In general, you should not use
// this class outside of a higher level framework.
// 
// One of the core features that GApplication provides is process
// uniqueness, in the context of a "session".  The session concept is
// platform-dependent, but corresponds roughly to a graphical desktop
// login.  When your application is launched again, its arguments
// are passed through platform communication to the already running
// program. The already running instance of the program is called the
// <firstterm>primary instance</firstterm>.
// 
// Before using GApplication, you must choose an "application identifier".
// The expected form of an application identifier is very close to that of
// of a <ulink url="http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-interface">DBus bus name</ulink>.
// Examples include: "com.example.MyApp", "org.example.internal-apps.Calculator".
// For details on valid application identifiers, see
// g_application_id_is_valid().
// 
// The application identifier is claimed by the application as a
// well-known bus name on the user's session bus.  This means that the
// uniqueness of your application is scoped to the current session.  It
// also means that your application may provide additional services
// (through registration of other object paths) at that bus name.
// 
// The registration of these object paths should be done with the shared
// GDBus session bus.  Note that due to the internal architecture of
// GDBus, method calls can be dispatched at any time (even if a main
// loop is not running).  For this reason, you must ensure that any
// object paths that you wish to register are registered before
// #GApplication attempts to acquire the bus name of your application
// (which happens in g_application_register()).  Unfortunately, this
// means that you cannot use g_application_get_is_remote() to decide if
// you want to register object paths.
// 
// GApplication provides convenient life cycle management by maintaining
// a <firstterm>use count</firstterm> for the primary application instance.
// The use count can be changed using g_application_hold() and
// g_application_release(). If it drops to zero, the application exits.
// 
// GApplication also implements the #GActionGroup interface and lets you
// easily export actions by adding them with g_application_set_action_group().
// When invoking an action by calling g_action_group_activate_action() on
// the application, it is always invoked in the primary instance.
// 
// There is a number of different entry points into a #GApplication:
// <itemizedlist>
// <listitem>via 'Activate' (i.e. just starting the application)</listitem>
// <listitem>via 'Open' (i.e. opening some files)</listitem>
// <listitem>by handling a command-line</listitem>
// <listitem>via activating an action</listitem>
// </itemizedlist>
// The #GApplication::startup signal lets you handle the application
// initialization for all of these in a single place.
// 
// Regardless of which of these entry points is used to start the application,
// GApplication passes some <firstterm id="platform-data">platform
// data</firstterm> from the launching instance to the primary instance,
// in the form of a #GVariant dictionary mapping strings to variants.
// To use platform data, override the @before_emit or @after_emit virtual
// functions in your #GApplication subclass. When dealing with
// #GApplicationCommandline objects, the platform data is directly
// available via g_application_command_line_get_cwd(),
// g_application_command_line_get_environ() and
// g_application_command_line_get_platform_data().
// 
// As the name indicates, the platform data may vary depending on the
// operating system, but it always includes the current directory (key
// "cwd"), and optionally the environment (ie the set of environment
// variables and their values) of the calling process (key "environ").
// The environment is only added to the platform data if the
// #G_APPLICATION_SEND_ENVIONMENT flag is set. GApplication subclasses
// can add their own platform data by overriding the @add_platform_data
// virtual function. For instance, #GtkApplication adds startup notification
// data in this way.
// 
// To parse commandline arguments you may handle the
// #GApplication::command-line signal or override the local_command_line()
// vfunc, to parse them in either the primary instance or the local instance,
// respectively.
// 
// <example id="gapplication-example-open"><title>Opening files with a GApplication</title>
// <programlisting>
// <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gapplication-example-open.c">
// <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
// </xi:include>
// </programlisting>
// </example>
// 
// <example id="gapplication-example-actions"><title>A GApplication with actions</title>
// <programlisting>
// <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gapplication-example-actions.c">
// <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
// </xi:include>
// </programlisting>
// </example>
struct Application /* : GObject.Object */ /* Version 2.28 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private ApplicationPrivate* priv;


   // Creates a new #GApplication instance.
   // 
   // This function calls g_type_init() for you.
   // 
   // The application id must be valid.  See g_application_id_is_valid().
   // RETURNS: a new #GApplication instance
   // <application_id>: the application id
   // <flags>: the application flags
   static Application* /*new*/ new_(char* application_id, ApplicationFlags flags) {
      return g_application_new(application_id, flags);
   }

   // Checks if @application_id is a valid application identifier.
   // 
   // A valid ID is required for calls to g_application_new() and
   // g_application_set_application_id().
   // 
   // For convenience, the restrictions on application identifiers are
   // reproduced here:
   // <itemizedlist>
   // <listitem>Application identifiers must contain only the ASCII characters "[A-Z][a-z][0-9]_-." and must not begin with a digit.</listitem>
   // <listitem>Application identifiers must contain at least one '.' (period) character (and thus at least three elements).</listitem>
   // <listitem>Application identifiers must not begin or end with a '.' (period) character.</listitem>
   // <listitem>Application identifiers must not contain consecutive '.' (period) characters.</listitem>
   // <listitem>Application identifiers must not exceed 255 characters.</listitem>
   // </itemizedlist>
   // RETURNS: %TRUE if @application_id is valid
   // <application_id>: a potential application identifier
   static int id_is_valid(char* application_id) {
      return g_application_id_is_valid(application_id);
   }

   // Activates the application.
   // 
   // In essence, this results in the #GApplication::activate() signal being
   // emitted in the primary instance.
   // 
   // The application must be registered before calling this function.
   void activate() {
      g_application_activate(&this);
   }

   // Gets the unique identifier for @application.
   // RETURNS: the identifier for @application, owned by @application
   char* get_application_id() {
      return g_application_get_application_id(&this);
   }

   // Gets the flags for @application.
   // 
   // See #GApplicationFlags.
   // RETURNS: the flags for @application
   ApplicationFlags get_flags() {
      return g_application_get_flags(&this);
   }

   // Gets the current inactivity timeout for the application.
   // 
   // This is the amount of time (in milliseconds) after the last call to
   // g_application_release() before the application stops running.
   // RETURNS: the timeout, in milliseconds
   uint get_inactivity_timeout() {
      return g_application_get_inactivity_timeout(&this);
   }

   // Checks if @application is registered.
   // 
   // An application is registered if g_application_register() has been
   // successfully called.
   // RETURNS: %TRUE if @application is registered
   int get_is_registered() {
      return g_application_get_is_registered(&this);
   }

   // Checks if @application is remote.
   // 
   // If @application is remote then it means that another instance of
   // application already exists (the 'primary' instance).  Calls to
   // perform actions on @application will result in the actions being
   // performed by the primary instance.
   // 
   // The value of this property cannot be accessed before
   // g_application_register() has been called.  See
   // g_application_get_is_registered().
   // RETURNS: %TRUE if @application is remote
   int get_is_remote() {
      return g_application_get_is_remote(&this);
   }

   // Increases the use count of @application.
   // 
   // Use this function to indicate that the application has a reason to
   // continue to run.  For example, g_application_hold() is called by GTK+
   // when a toplevel window is on the screen.
   // 
   // To cancel the hold, call g_application_release().
   void hold() {
      g_application_hold(&this);
   }

   // Opens the given files.
   // 
   // In essence, this results in the #GApplication::open signal being emitted
   // in the primary instance.
   // 
   // @n_files must be greater than zero.
   // 
   // @hint is simply passed through to the ::open signal.  It is
   // intended to be used by applications that have multiple modes for
   // opening files (eg: "view" vs "edit", etc).  Unless you have a need
   // for this functionality, you should use "".
   // 
   // The application must be registered before calling this function
   // and it must have the %G_APPLICATION_HANDLES_OPEN flag set.
   // <files>: an array of #GFiles to open
   // <n_files>: the length of the @files array
   // <hint>: a hint (or ""), but never %NULL
   void open(File** files, int n_files, char* hint) {
      g_application_open(&this, files, n_files, hint);
   }

   // Attempts registration of the application.
   // 
   // This is the point at which the application discovers if it is the
   // primary instance or merely acting as a remote for an already-existing
   // primary instance.  This is implemented by attempting to acquire the
   // application identifier as a unique bus name on the session bus using
   // GDBus.
   // 
   // Due to the internal architecture of GDBus, method calls can be
   // dispatched at any time (even if a main loop is not running).  For
   // this reason, you must ensure that any object paths that you wish to
   // register are registered before calling this function.
   // 
   // If the application has already been registered then %TRUE is
   // returned with no work performed.
   // 
   // The #GApplication::startup signal is emitted if registration succeeds
   // and @application is the primary instance.
   // 
   // In the event of an error (such as @cancellable being cancelled, or a
   // failure to connect to the session bus), %FALSE is returned and @error
   // is set appropriately.
   // 
   // Note: the return value of this function is not an indicator that this
   // instance is or is not the primary instance of the application.  See
   // g_application_get_is_remote() for that.
   // RETURNS: %TRUE if registration succeeded
   // <cancellable>: a #GCancellable, or %NULL
   int register(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_application_register(&this, cancellable, error);
   }

   // Decrease the use count of @application.
   // 
   // When the use count reaches zero, the application will stop running.
   // 
   // Never call this function except to cancel the effect of a previous
   // call to g_application_hold().
   void release() {
      g_application_release(&this);
   }

   // Runs the application.
   // 
   // This function is intended to be run from main() and its return value
   // is intended to be returned by main(). Although you are expected to pass
   // the @argc, @argv parameters from main() to this function, it is possible
   // to pass %NULL if @argv is not available or commandline handling is not
   // required.
   // 
   // First, the local_command_line() virtual function is invoked.
   // This function always runs on the local instance. It gets passed a pointer
   // to a %NULL-terminated copy of @argv and is expected to remove the arguments
   // that it handled (shifting up remaining arguments). See
   // <xref linkend="gapplication-example-cmdline2"/> for an example of
   // parsing @argv manually. Alternatively, you may use the #GOptionContext API,
   // after setting <literal>argc = g_strv_length (argv);</literal>.
   // 
   // The last argument to local_command_line() is a pointer to the @status
   // variable which can used to set the exit status that is returned from
   // g_application_run().
   // 
   // If local_command_line() returns %TRUE, the command line is expected
   // to be completely handled, including possibly registering as the primary
   // instance, calling g_application_activate() or g_application_open(), etc.
   // 
   // If local_command_line() returns %FALSE then the application is registered
   // and the #GApplication::command-line signal is emitted in the primary
   // instance (which may or may not be this instance). The signal handler
   // gets passed a #GApplicationCommandline object that (among other things)
   // contains the remaining commandline arguments that have not been handled
   // by local_command_line().
   // 
   // If the application has the %G_APPLICATION_HANDLES_COMMAND_LINE
   // flag set then the default implementation of local_command_line()
   // always returns %FALSE immediately, resulting in the commandline
   // always being handled in the primary instance.
   // 
   // Otherwise, the default implementation of local_command_line() tries
   // to do a couple of things that are probably reasonable for most
   // applications.  First, g_application_register() is called to attempt
   // to register the application.  If that works, then the command line
   // arguments are inspected.  If no commandline arguments are given, then
   // g_application_activate() is called.  If commandline arguments are
   // given and the %G_APPLICATION_HANDLES_OPEN flag is set then they
   // are assumed to be filenames and g_application_open() is called.
   // 
   // If you need to handle commandline arguments that are not filenames,
   // and you don't mind commandline handling to happen in the primary
   // instance, you should set %G_APPLICATION_HANDLED_COMMAND_LINE and
   // process the commandline arguments in your #GApplication::command-line
   // signal handler, either manually or using the #GOptionContext API.
   // 
   // If you are interested in doing more complicated local handling of the
   // commandline then you should implement your own #GApplication subclass
   // and override local_command_line(). In this case, you most likely want
   // to return %TRUE from your local_command_line() implementation to
   // suppress the default handling. See
   // <xref linkend="gapplication-example-cmdline2"/> for an example.
   // 
   // If, after the above is done, the use count of the application is zero
   // then the exit status is returned immediately.  If the use count is
   // non-zero then the mainloop is run until the use count falls to zero,
   // at which point 0 is returned.
   // 
   // If the %G_APPLICATION_IS_SERVICE flag is set, then the exiting at
   // use count of zero is delayed for a while (ie: the instance stays
   // around to provide its <emphasis>service</emphasis> to others).
   // RETURNS: the exit status
   // <argc>: the argc from main() (or 0 if @argv is %NULL)
   // <argv>: the argv from main(), or %NULL
   int run(int argc, char** argv=null) {
      return g_application_run(&this, argc, argv);
   }

   // Sets or unsets the group of actions associated with the application.
   // 
   // These actions are the actions that can be remotely invoked.
   // 
   // It is an error to call this function after the application has been
   // registered.
   // <action_group>: a #GActionGroup, or %NULL
   void set_action_group(ActionGroup* action_group=null) {
      g_application_set_action_group(&this, action_group);
   }

   // Sets the unique identifier for @application.
   // 
   // The application id can only be modified if @application has not yet
   // been registered.
   // 
   // The application id must be valid.  See g_application_id_is_valid().
   // <application_id>: the identifier for @application
   void set_application_id(char* application_id) {
      g_application_set_application_id(&this, application_id);
   }

   // Sets the flags for @application.
   // 
   // The flags can only be modified if @application has not yet been
   // registered.
   // 
   // See #GApplicationFlags.
   // <flags>: the flags for @application
   void set_flags(ApplicationFlags flags) {
      g_application_set_flags(&this, flags);
   }

   // Sets the current inactivity timeout for the application.
   // 
   // This is the amount of time (in milliseconds) after the last call to
   // g_application_release() before the application stops running.
   // 
   // This call has no side effects of its own.  The value set here is only
   // used for next time g_application_release() drops the use count to
   // zero.  Any timeouts currently in progress are not impacted.
   // RETURNS: the timeout, in milliseconds
   // <inactivity_timeout>: the timeout, in milliseconds
   void set_inactivity_timeout(uint inactivity_timeout) {
      g_application_set_inactivity_timeout(&this, inactivity_timeout);
   }

   // The ::activate signal is emitted on the primary instance when an
   // activation occurs. See g_application_activate().
   extern (C) alias static void function (Application* this_, void* user_data=null) signal_activate;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"activate", CB:signal_activate)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"activate",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::command-line signal is emitted on the primary instance when
   // a commandline is not handled locally. See g_application_run() and
   // the #GApplicationCommandline documentation for more information.
   // 
   // process. See g_application_command_line_set_exit_status().
   // RETURNS: An integer that is set as the exit status for the calling
   // <command_line>: a #GApplicationCommandLine representing the passed commandline
   extern (C) alias static int function (Application* this_, ApplicationCommandLine* command_line, void* user_data=null) signal_command_line;
   ulong signal_connect(string name:"command-line", CB:signal_command_line)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"command-line",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::open signal is emitted on the primary instance when there are
   // files to open. See g_application_open() for more information.
   // <files>: an array of #GFiles
   // <n_files>: the length of @files
   // <hint>: a hint provided by the calling instance
   extern (C) alias static void function (Application* this_, File* files, int n_files, char* hint, void* user_data=null) signal_open;
   ulong signal_connect(string name:"open", CB:signal_open)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"open",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::startup signal is emitted on the primary instance immediately
   // after registration. See g_application_register().
   extern (C) alias static void function (Application* this_, void* user_data=null) signal_startup;
   ulong signal_connect(string name:"startup", CB:signal_startup)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"startup",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ApplicationClass /* Version 2.28 */ {
   private GObject2.ObjectClass parent_class;
   extern (C) void function (Application* application) startup;
   extern (C) void function (Application* application) activate;

   // <files>: an array of #GFiles to open
   // <n_files>: the length of the @files array
   // <hint>: a hint (or ""), but never %NULL
   extern (C) void function (Application* application, File** files, int n_files, char* hint) open;
   extern (C) int function (Application* application, ApplicationCommandLine* command_line) command_line;
   extern (C) int function (Application* application, char*** arguments, int* exit_status) local_command_line;
   extern (C) void function (Application* application, GLib2.Variant* platform_data) before_emit;
   extern (C) void function (Application* application, GLib2.Variant* platform_data) after_emit;
   extern (C) void function (Application* application, GLib2.VariantBuilder* builder) add_platform_data;
   extern (C) void function (Application* application) quit_mainloop;
   extern (C) void function (Application* application) run_mainloop;
   private void*[12] padding;
}


// #GApplicationCommandLine represents a command-line invocation of
// an application.  It is created by #GApplication and emitted
// in the #GApplication::command-line signal and virtual function.
// 
// The class contains the list of arguments that the program was invoked
// with.  It is also possible to query if the commandline invocation was
// local (ie: the current process is running in direct response to the
// invocation) or remote (ie: some other process forwarded the
// commandline to this process).
// 
// The GApplicationCommandLine object can provide the @argc and @argv
// parameters for use with the #GOptionContext command-line parsing API,
// with the g_application_command_line_get_arguments() function. See
// <xref linkend="gapplication-example-cmdline3"/> for an example.
// 
// The exit status of the originally-invoked process may be set and
// messages can be printed to stdout or stderr of that process.  The
// lifecycle of the originally-invoked process is tied to the lifecycle
// of this object (ie: the process exits when the last reference is
// dropped).
// 
// The main use for #GApplicationCommandline (and the
// #GApplication::command-line signal) is 'Emacs server' like use cases:
// You can set the <envar>EDITOR</envar> environment variable to have
// e.g. git use your favourite editor to edit commit messages, and if you
// already have an instance of the editor running, the editing will happen
// in the running instance, instead of opening a new one. An important
// aspect of this use case is that the process that gets started by git
// does not return until the editing is done.
// 
// <example id="gapplication-example-cmdline"><title>Handling commandline arguments with GApplication</title>
// <para>
// A simple example where the commandline is completely handled
// in the #GApplication::command-line handler. The launching instance exits
// once the signal handler in the primary instance has returned, and the
// return value of the signal handler becomes the exit status of the launching
// instance.
// </para>
// <programlisting>
// <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gapplication-example-cmdline.c">
// <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
// </xi:include>
// </programlisting>
// </example>
// 
// <example id="gapplication-example-cmdline2"><title>Split commandline handling</title>
// <para>
// An example of split commandline handling. Options that start with
// <literal>--local-</literal> are handled locally, all other options are
// passed to the #GApplication::command-line handler which runs in the primary
// instance.
// </para>
// <programlisting>
// <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gapplication-example-cmdline2.c">
// <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
// </xi:include>
// </programlisting>
// </example>
// 
// <example id="gapplication-example-cmdline3"><title>Deferred commandline handling</title>
// <para>
// An example of deferred commandline handling. Here, the commandline is
// not completely handled before the #GApplication::command-line handler
// returns. Instead, we keep a reference to the GApplicationCommandline
// object and handle it later(in this example, in an idle). Note that it
// is necessary to hold the application until you are done with the
// commandline.
// </para>
// <para>
// This example also shows how to use #GOptionContext for parsing the
// commandline arguments. Note that it is necessary to disable the
// built-in help-handling of #GOptionContext, since it calls exit()
// after printing help, which is not what you want to happen in
// the primary instance.
// </para>
// <programlisting>
// <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gapplication-example-cmdline3.c">
// <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
// </xi:include>
// </programlisting>
// </example>
struct ApplicationCommandLine /* : GObject.Object */ /* Version 2.28 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private ApplicationCommandLinePrivate* priv;


   // Gets the list of arguments that was passed on the command line.
   // 
   // The strings in the array may contain non-utf8 data.
   // 
   // The return value is %NULL-terminated and should be freed using
   // g_strfreev().
   // 
   // containing the arguments (the argv)
   // RETURNS: the string array
   // <argc>: the length of the arguments array, or %NULL
   char** /*new*/ get_arguments(/*out*/ int* argc) {
      return g_application_command_line_get_arguments(&this, argc);
   }

   // Gets the working directory of the command line invocation.
   // The string may contain non-utf8 data.
   // 
   // It is possible that the remote application did not send a working
   // directory, so this may be %NULL.
   // 
   // The return value should not be modified or freed and is valid for as
   // long as @cmdline exists.
   // RETURNS: the current directory, or %NULL
   char* get_cwd() {
      return g_application_command_line_get_cwd(&this);
   }

   // Gets the contents of the 'environ' variable of the command line
   // invocation, as would be returned by g_get_environ(), ie as a
   // %NULL-terminated list of strings in the form 'NAME=VALUE'.
   // The strings may contain non-utf8 data.
   // 
   // The remote application usually does not send an environment.  Use
   // %G_APPLICATION_SEND_ENVIRONMENT to affect that.  Even with this flag
   // set it is possible that the environment is still not available (due
   // to invocation messages from other applications).
   // 
   // The return value should not be modified or freed and is valid for as
   // long as @cmdline exists.
   // 
   // See g_application_command_line_getenv() if you are only interested
   // in the value of a single environment variable.
   // 
   // strings, or %NULL if they were not sent
   // RETURNS: the environment
   char** get_environ() {
      return g_application_command_line_get_environ(&this);
   }

   // Gets the exit status of @cmdline.  See
   // g_application_command_line_set_exit_status() for more information.
   // RETURNS: the exit status
   int get_exit_status() {
      return g_application_command_line_get_exit_status(&this);
   }

   // Determines if @cmdline represents a remote invocation.
   // RETURNS: %TRUE if the invocation was remote
   int get_is_remote() {
      return g_application_command_line_get_is_remote(&this);
   }

   // Gets the platform data associated with the invocation of @cmdline.
   // 
   // This is a #GVariant dictionary containing information about the
   // context in which the invocation occurred.  It typically contains
   // information like the current working directory and the startup
   // notification ID.
   // 
   // For local invocation, it will be %NULL.
   // RETURNS: the platform data, or %NULL
   GLib2.Variant* /*new*/ get_platform_data() {
      return g_application_command_line_get_platform_data(&this);
   }

   // Gets the value of a particular environment variable of the command
   // line invocation, as would be returned by g_getenv().  The strings may
   // contain non-utf8 data.
   // 
   // The remote application usually does not send an environment.  Use
   // %G_APPLICATION_SEND_ENVIRONMENT to affect that.  Even with this flag
   // set it is possible that the environment is still not available (due
   // to invocation messages from other applications).
   // 
   // The return value should not be modified or freed and is valid for as
   // long as @cmdline exists.
   // RETURNS: the value of the variable, or %NULL if unset or unsent
   // <name>: the environment variable to get
   char* getenv(char* name) {
      return g_application_command_line_getenv(&this, name);
   }

   // Unintrospectable method: print() / g_application_command_line_print()
   // Formats a message and prints it using the stdout print handler in the
   // invoking process.
   // 
   // If @cmdline is a local invocation then this is exactly equivalent to
   // g_print().  If @cmdline is remote then this is equivalent to calling
   // g_print() in the invoking process.
   // <format>: a printf-style format string
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_application_command_line_print print; // Variadic
   +/

   // Unintrospectable method: printerr() / g_application_command_line_printerr()
   // Formats a message and prints it using the stderr print handler in the
   // invoking process.
   // 
   // If @cmdline is a local invocation then this is exactly equivalent to
   // g_printerr().  If @cmdline is remote then this is equivalent to
   // calling g_printerr() in the invoking process.
   // <format>: a printf-style format string
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_application_command_line_printerr printerr; // Variadic
   +/

   // Sets the exit status that will be used when the invoking process
   // exits.
   // 
   // The return value of the #GApplication::command-line signal is
   // passed to this function when the handler returns.  This is the usual
   // way of setting the exit status.
   // 
   // In the event that you want the remote invocation to continue running
   // and want to decide on the exit status in the future, you can use this
   // call.  For the case of a remote invocation, the remote process will
   // typically exit when the last reference is dropped on @cmdline.  The
   // exit status of the remote process will be equal to the last value
   // that was set with this function.
   // 
   // In the case that the commandline invocation is local, the situation
   // is slightly more complicated.  If the commandline invocation results
   // in the mainloop running (ie: because the use-count of the application
   // increased to a non-zero value) then the application is considered to
   // have been 'successful' in a certain sense, and the exit status is
   // always zero.  If the application use count is zero, though, the exit
   // status of the local #GApplicationCommandLine is used.
   // <exit_status>: the exit status
   void set_exit_status(int exit_status) {
      g_application_command_line_set_exit_status(&this, exit_status);
   }
}


// The <structname>GApplicationCommandLineClass</structname> structure contains
// private data only
struct ApplicationCommandLineClass /* Version 2.28 */ {
   private GObject2.ObjectClass parent_class;
   extern (C) void function (ApplicationCommandLine* cmdline, char* message) print_literal;
   extern (C) void function (ApplicationCommandLine* cmdline, char* message) printerr_literal;
   private void*[12] padding;
}

struct ApplicationCommandLinePrivate {
}

// Flags used to define the behaviour of a #GApplication.
enum ApplicationFlags /* Version 2.28 */ {
   FLAGS_NONE = 0,
   IS_SERVICE = 1,
   IS_LAUNCHER = 2,
   HANDLES_OPEN = 4,
   HANDLES_COMMAND_LINE = 8,
   SEND_ENVIRONMENT = 16,
   NON_UNIQUE = 32
}
struct ApplicationPrivate {
}


// #GAskPasswordFlags are used to request specific information from the
// user, or to notify the user of their choices in an authentication
// situation.
enum AskPasswordFlags {
   NEED_PASSWORD = 1,
   NEED_USERNAME = 2,
   NEED_DOMAIN = 4,
   SAVING_SUPPORTED = 8,
   ANONYMOUS_SUPPORTED = 16
}

// This is the asynchronous version of #GInitable; it behaves the same
// in all ways except that initialization is asynchronous. For more details
// see the descriptions on #GInitable.
// 
// A class may implement both the #GInitable and #GAsyncInitable interfaces.
// 
// Users of objects implementing this are not intended to use the interface
// method directly; instead it will be used automatically in various ways.
// For C applications you generally just call g_async_initable_new_async()
// directly, or indirectly via a foo_thing_new_async() wrapper. This will call
// g_async_initable_init_async() under the cover, calling back with %NULL and
// a set %GError on failure.
// 
// A typical implementation might look something like this:
// 
// |[
// enum {
// NOT_INITIALIZED,
// INITIALIZING,
// INITIALIZED
// };
// 
// static void
// _foo_ready_cb (Foo *self)
// {
// GList *l;
// 
// self->priv->state = INITIALIZED;
// 
// for (l = self->priv->init_results; l != NULL; l = l->next)
// {
// GSimpleAsyncResult *simple = l->data;
// 
// if (!self->priv->success)
// g_simple_async_result_set_error (simple, ...);
// 
// g_simple_async_result_complete (simple);
// g_object_unref (simple);
// }
// 
// g_list_free (self->priv->init_results);
// self->priv->init_results = NULL;
// }
// 
// static void
// foo_init_async (GAsyncInitable       *initable,
// int                   io_priority,
// GCancellable         *cancellable,
// GAsyncReadyCallback   callback,
// gpointer              user_data)
// {
// Foo *self = FOO (initable);
// GSimpleAsyncResult *simple;
// 
// simple = g_simple_async_result_new (G_OBJECT (initable)
// callback,
// user_data,
// foo_init_async);
// 
// switch (self->priv->state)
// {
// case NOT_INITIALIZED:
// _foo_get_ready (self);
// self->priv->init_results = g_list_append (self->priv->init_results,
// simple);
// self->priv->state = INITIALIZING;
// break;
// case INITIALIZING:
// self->priv->init_results = g_list_append (self->priv->init_results,
// simple);
// break;
// case INITIALIZED:
// if (!self->priv->success)
// g_simple_async_result_set_error (simple, ...);
// 
// g_simple_async_result_complete_in_idle (simple);
// g_object_unref (simple);
// break;
// }
// }
// 
// static gboolean
// foo_init_finish (GAsyncInitable       *initable,
// GAsyncResult         *result,
// GError              **error)
// {
// g_return_val_if_fail (g_simple_async_result_is_valid (result,
// G_OBJECT (initable), foo_init_async), FALSE);
// 
// if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
// error))
// return FALSE;
// 
// return TRUE;
// }
// 
// static void
// foo_async_initable_iface_init (gpointer g_iface,
// gpointer data)
// {
// GAsyncInitableIface *iface = g_iface;
// 
// iface->init_async = foo_init_async;
// iface->init_finish = foo_init_finish;
// }
// ]|
struct AsyncInitable /* Version 2.22 */ {

   // Unintrospectable function: new_async() / g_async_initable_new_async()
   // Helper function for constructing #GAsyncInitable object. This is
   // similar to g_object_new() but also initializes the object asynchronously.
   // 
   // When the initialization is finished, @callback will be called. You can
   // then call g_async_initable_new_finish() to get the new object and check
   // for any errors.
   // <object_type>: a #GType supporting #GAsyncInitable.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the operation.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the initialization is finished
   // <user_data>: the data to pass to callback function
   // <first_property_name>: the name of the first property, or %NULL if no properties
   alias g_async_initable_new_async new_async; // Variadic

   // Unintrospectable function: new_valist_async() / g_async_initable_new_valist_async()
   // Helper function for constructing #GAsyncInitable object. This is
   // similar to g_object_new_valist() but also initializes the object
   // asynchronously.
   // 
   // When the initialization is finished, @callback will be called. You can
   // then call g_async_initable_new_finish() to get the new object and check
   // for any errors.
   // <object_type>: a #GType supporting #GAsyncInitable.
   // <first_property_name>: the name of the first property, followed by the value, and other property value pairs, and ended by %NULL.
   // <var_args>: The var args list generated from @first_property_name.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the operation.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the initialization is finished
   // <user_data>: the data to pass to callback function
   static void new_valist_async(Type object_type, char* first_property_name, va_list var_args, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_async_initable_new_valist_async(object_type, first_property_name, var_args, io_priority, cancellable, callback, user_data);
   }

   // Helper function for constructing #GAsyncInitable object. This is
   // similar to g_object_newv() but also initializes the object asynchronously.
   // 
   // When the initialization is finished, @callback will be called. You can
   // then call g_async_initable_new_finish() to get the new object and check
   // for any errors.
   // <object_type>: a #GType supporting #GAsyncInitable.
   // <n_parameters>: the number of parameters in @parameters
   // <parameters>: the parameters to use to construct the object
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the operation.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the initialization is finished
   // <user_data>: the data to pass to callback function
   static void newv_async(Type object_type, uint n_parameters, GObject2.Parameter* parameters, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_async_initable_newv_async(object_type, n_parameters, parameters, io_priority, cancellable, callback, user_data);
   }

   // Starts asynchronous initialization of the object implementing the
   // interface. This must be done before any real use of the object after
   // initial construction. If the object also implements #GInitable you can
   // optionally call g_initable_init() instead.
   // 
   // When the initialization is finished, @callback will be called. You can
   // then call g_async_initable_init_finish() to get the result of the
   // initialization.
   // 
   // Implementations may also support cancellation. If @cancellable is not
   // %NULL, then initialization can be cancelled by triggering the cancellable
   // object from another thread. If the operation was cancelled, the error
   // %G_IO_ERROR_CANCELLED will be returned. If @cancellable is not %NULL, and
   // the object doesn't support cancellable initialization, the error
   // %G_IO_ERROR_NOT_SUPPORTED will be returned.
   // 
   // If this function is not called, or returns with an error, then all
   // operations on the object should fail, generally returning the
   // error %G_IO_ERROR_NOT_INITIALIZED.
   // 
   // Implementations of this method must be idempotent: i.e. multiple calls
   // to this function with the same argument should return the same results.
   // Only the first call initializes the object; further calls return the result
   // of the first call. This is so that it's safe to implement the singleton
   // pattern in the GObject constructor function.
   // 
   // For classes that also support the #GInitable interface, the default
   // implementation of this method will run the g_initable_init() function
   // in a thread, so if you want to support asynchronous initialization via
   // threads, just implement the #GAsyncInitable interface without overriding
   // any interface methods.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the operation.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void init_async(int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_async_initable_init_async(&this, io_priority, cancellable, callback, user_data);
   }

   // Finishes asynchronous initialization and returns the result.
   // See g_async_initable_init_async().
   // 
   // will return %FALSE and set @error appropriately if present.
   // RETURNS: %TRUE if successful. If an error has occurred, this function
   // <res>: a #GAsyncResult.
   int init_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_async_initable_init_finish(&this, res, error);
   }

   // Finishes the async construction for the various g_async_initable_new
   // calls, returning the created object or %NULL on error.
   // 
   // Free with g_object_unref().
   // RETURNS: a newly created #GObject, or %NULL on error.
   // <res>: the #GAsyncResult from the callback
   GObject2.Object* /*new*/ new_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_async_initable_new_finish(&this, res, error);
   }
}


// Provides an interface for asynchronous initializing object such that
// initialization may fail.
struct AsyncInitableIface /* Version 2.22 */ {
   GObject2.TypeInterface g_iface;

   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the operation.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (AsyncInitable* initable, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) init_async;

   // RETURNS: %TRUE if successful. If an error has occurred, this function
   // <res>: a #GAsyncResult.
   extern (C) int function (AsyncInitable* initable, AsyncResult* res, GLib2.Error** error=null) init_finish;
}


// Type definition for a function that will be called back when an asynchronous
// operation within GIO has been completed.
// <source_object>: the object the asynchronous operation was started with.
// <res>: a #GAsyncResult.
// <user_data>: user data passed to the callback.
extern (C) alias void function (GObject2.Object* source_object, AsyncResult* res, void* user_data) AsyncReadyCallback;


// Provides a base class for implementing asynchronous function results.
// 
// Asynchronous operations are broken up into two separate operations
// which are chained together by a #GAsyncReadyCallback. To begin
// an asynchronous operation, provide a #GAsyncReadyCallback to the
// asynchronous function. This callback will be triggered when the
// operation has completed, and will be passed a #GAsyncResult instance
// filled with the details of the operation's success or failure, the
// object the asynchronous function was started for and any error codes
// returned. The asynchronous callback function is then expected to call
// the corresponding "_finish()" function, passing the object the
// function was called for, the #GAsyncResult instance, and (optionally)
// an @error to grab any error conditions that may have occurred.
// 
// The "_finish()" function for an operation takes the generic result
// (of type #GAsyncResult) and returns the specific result that the
// operation in question yields (e.g. a #GFileEnumerator for a
// "enumerate children" operation). If the result or error status of the
// operation is not needed, there is no need to call the "_finish()"
// function; GIO will take care of cleaning up the result and error
// information after the #GAsyncReadyCallback returns. You can pass
// %NULL for the #GAsyncReadyCallback if you don't need to take any
// action at all after the operation completes. Applications may also
// take a reference to the #GAsyncResult and call "_finish()" later;
// however, the "_finish()" function may be called at most once.
// 
// Example of a typical asynchronous operation flow:
// |[
// void _theoretical_frobnitz_async (Theoretical         *t,
// GCancellable        *c,
// GAsyncReadyCallback *cb,
// gpointer             u);
// 
// gboolean _theoretical_frobnitz_finish (Theoretical   *t,
// GAsyncResult  *res,
// GError       **e);
// 
// static void
// frobnitz_result_func (GObject      *source_object,
// GAsyncResult *res,
// gpointer      user_data)
// {
// gboolean success = FALSE;
// 
// success = _theoretical_frobnitz_finish (source_object, res, NULL);
// 
// if (success)
// g_printf ("Hurray!\n");
// else
// g_printf ("Uh oh!\n");
// 
// /<!-- -->* ... *<!-- -->/
// 
// }
// 
// int main (int argc, void *argv[])
// {
// /<!-- -->* ... *<!-- -->/
// 
// _theoretical_frobnitz_async (theoretical_data,
// NULL,
// frobnitz_result_func,
// NULL);
// 
// /<!-- -->* ... *<!-- -->/
// }
// ]|
// 
// The callback for an asynchronous operation is called only once, and is
// always called, even in the case of a cancelled operation. On cancellation
// the result is a %G_IO_ERROR_CANCELLED error.
// 
// Some asynchronous operations are implemented using synchronous calls.
// These are run in a separate thread, if #GThread has been initialized, but
// otherwise they are sent to the Main Event Loop and processed in an idle
// function. So, if you truly need asynchronous operations, make sure to
// initialize #GThread.
struct AsyncResult {

   // Gets the source object from a #GAsyncResult.
   // 
   // or %NULL if there is none.
   // RETURNS: a new reference to the source object for the @res,
   GObject2.Object* /*new*/ get_source_object() {
      return g_async_result_get_source_object(&this);
   }

   // Gets the user data from a #GAsyncResult.
   // RETURNS: the user data for @res.
   void* /*new*/ get_user_data() {
      return g_async_result_get_user_data(&this);
   }
}

// Interface definition for #GAsyncResult.
struct AsyncResultIface {
   GObject2.TypeInterface g_iface;
   // RETURNS: the user data for @res.
   extern (C) void* /*new*/ function (AsyncResult* res) get_user_data;
   // RETURNS: a new reference to the source object for the @res,
   extern (C) GObject2.Object* /*new*/ function (AsyncResult* res) get_source_object;
}


// Buffered input stream implements #GFilterInputStream and provides
// for buffered reads.
// 
// By default, #GBufferedInputStream's buffer size is set at 4 kilobytes.
// 
// To create a buffered input stream, use g_buffered_input_stream_new(),
// or g_buffered_input_stream_new_sized() to specify the buffer's size at
// construction.
// 
// To get the size of a buffer within a buffered input stream, use
// g_buffered_input_stream_get_buffer_size(). To change the size of a
// buffered input stream's buffer, use
// g_buffered_input_stream_set_buffer_size(). Note that the buffer's size
// cannot be reduced below the size of the data within the buffer.
struct BufferedInputStream /* : FilterInputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance filterinputstream;
   FilterInputStream parent_instance;
   private BufferedInputStreamPrivate* priv;


   // Creates a new #GInputStream from the given @base_stream, with
   // a buffer set to the default size (4 kilobytes).
   // RETURNS: a #GInputStream for the given @base_stream.
   // <base_stream>: a #GInputStream
   static BufferedInputStream* /*new*/ new_(InputStream* base_stream) {
      return g_buffered_input_stream_new(base_stream);
   }

   // Creates a new #GBufferedInputStream from the given @base_stream,
   // with a buffer set to @size.
   // RETURNS: a #GInputStream.
   // <base_stream>: a #GInputStream
   // <size>: a #gsize
   static BufferedInputStream* /*new*/ new_sized(InputStream* base_stream, size_t size) {
      return g_buffered_input_stream_new_sized(base_stream, size);
   }

   // Tries to read @count bytes from the stream into the buffer.
   // Will block during this read.
   // 
   // If @count is zero, returns zero and does nothing. A value of @count
   // larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
   // 
   // On success, the number of bytes read into the buffer is returned.
   // It is not an error if this is not the same as the requested size, as it
   // can happen e.g. near the end of a file. Zero is returned on end of file
   // (or if @count is zero),  but never otherwise.
   // 
   // If @count is -1 then the attempted read size is equal to the number of
   // bytes that are required to fill the buffer.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
   // operation was partially finished when the operation was cancelled the
   // partial result will be returned, without an error.
   // 
   // On error -1 is returned and @error is set accordingly.
   // 
   // For the asynchronous, non-blocking, version of this function, see
   // g_buffered_input_stream_fill_async().
   // 
   // or -1 on error.
   // RETURNS: the number of bytes read into @stream's buffer, up to @count,
   // <count>: the number of bytes that will be read from the stream
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   ssize_t fill(ssize_t count, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_buffered_input_stream_fill(&this, count, cancellable, error);
   }

   // Reads data into @stream's buffer asynchronously, up to @count size.
   // @io_priority can be used to prioritize reads. For the synchronous
   // version of this function, see g_buffered_input_stream_fill().
   // 
   // If @count is -1 then the attempted read size is equal to the number
   // of bytes that are required to fill the buffer.
   // <count>: the number of bytes that will be read from the stream
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request
   // <cancellable>: optional #GCancellable object
   // <callback>: a #GAsyncReadyCallback
   // <user_data>: a #gpointer
   void fill_async(ssize_t count, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_buffered_input_stream_fill_async(&this, count, io_priority, cancellable, callback, user_data);
   }

   // Finishes an asynchronous read.
   // RETURNS: a #gssize of the read stream, or %-1 on an error.
   // <result>: a #GAsyncResult
   ssize_t fill_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_buffered_input_stream_fill_finish(&this, result, error);
   }

   // Gets the size of the available data within the stream.
   // RETURNS: size of the available stream.
   size_t get_available() {
      return g_buffered_input_stream_get_available(&this);
   }

   // Gets the size of the input buffer.
   // RETURNS: the current buffer size.
   size_t get_buffer_size() {
      return g_buffered_input_stream_get_buffer_size(&this);
   }

   // Peeks in the buffer, copying data of size @count into @buffer,
   // offset @offset bytes.
   // RETURNS: a #gsize of the number of bytes peeked, or -1 on error.
   // <buffer>: a pointer to an allocated chunk of memory
   // <offset>: a #gsize
   // <count>: a #gsize
   size_t peek(void* buffer, size_t offset, size_t count) {
      return g_buffered_input_stream_peek(&this, buffer, offset, count);
   }

   // Returns the buffer with the currently available bytes. The returned
   // buffer must not be modified and will become invalid when reading from
   // the stream or filling the buffer.
   // 
   // read-only buffer
   // <count>: a #gsize to get the number of bytes available in the buffer
   ubyte* peek_buffer(/*out*/ size_t* count) {
      return g_buffered_input_stream_peek_buffer(&this, count);
   }

   // Tries to read a single byte from the stream or the buffer. Will block
   // during this read.
   // 
   // On success, the byte read from the stream is returned. On end of stream
   // -1 is returned but it's not an exceptional error and @error is not set.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
   // operation was partially finished when the operation was cancelled the
   // partial result will be returned, without an error.
   // 
   // On error -1 is returned and @error is set accordingly.
   // RETURNS: the byte read from the @stream, or -1 on end of stream or error.
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   int read_byte(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_buffered_input_stream_read_byte(&this, cancellable, error);
   }

   // Sets the size of the internal buffer of @stream to @size, or to the
   // size of the contents of the buffer. The buffer can never be resized
   // smaller than its current contents.
   // <size>: a #gsize
   void set_buffer_size(size_t size) {
      g_buffered_input_stream_set_buffer_size(&this, size);
   }
}

struct BufferedInputStreamClass {
   FilterInputStreamClass parent_class;

   // RETURNS: the number of bytes read into @stream's buffer, up to @count,
   // <count>: the number of bytes that will be read from the stream
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   extern (C) ssize_t function (BufferedInputStream* stream, ssize_t count, Cancellable* cancellable, GLib2.Error** error=null) fill;

   // <count>: the number of bytes that will be read from the stream
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request
   // <cancellable>: optional #GCancellable object
   // <callback>: a #GAsyncReadyCallback
   // <user_data>: a #gpointer
   extern (C) void function (BufferedInputStream* stream, ssize_t count, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) fill_async;

   // RETURNS: a #gssize of the read stream, or %-1 on an error.
   // <result>: a #GAsyncResult
   extern (C) ssize_t function (BufferedInputStream* stream, AsyncResult* result, GLib2.Error** error=null) fill_finish;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct BufferedInputStreamPrivate {
}


// Buffered output stream implements #GFilterOutputStream and provides
// for buffered writes.
// 
// By default, #GBufferedOutputStream's buffer size is set at 4 kilobytes.
// 
// To create a buffered output stream, use g_buffered_output_stream_new(),
// or g_buffered_output_stream_new_sized() to specify the buffer's size
// at construction.
// 
// To get the size of a buffer within a buffered input stream, use
// g_buffered_output_stream_get_buffer_size(). To change the size of a
// buffered output stream's buffer, use
// g_buffered_output_stream_set_buffer_size(). Note that the buffer's
// size cannot be reduced below the size of the data within the buffer.
struct BufferedOutputStream /* : FilterOutputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance filteroutputstream;
   FilterOutputStream parent_instance;
   BufferedOutputStreamPrivate* priv;


   // Creates a new buffered output stream for a base stream.
   // RETURNS: a #GOutputStream for the given @base_stream.
   // <base_stream>: a #GOutputStream.
   static BufferedOutputStream* /*new*/ new_(OutputStream* base_stream) {
      return g_buffered_output_stream_new(base_stream);
   }

   // Creates a new buffered output stream with a given buffer size.
   // RETURNS: a #GOutputStream with an internal buffer set to @size.
   // <base_stream>: a #GOutputStream.
   // <size>: a #gsize.
   static BufferedOutputStream* /*new*/ new_sized(OutputStream* base_stream, size_t size) {
      return g_buffered_output_stream_new_sized(base_stream, size);
   }

   // Checks if the buffer automatically grows as data is added.
   // 
   // %FALSE otherwise.
   // RETURNS: %TRUE if the @stream's buffer automatically grows,
   int get_auto_grow() {
      return g_buffered_output_stream_get_auto_grow(&this);
   }

   // Gets the size of the buffer in the @stream.
   // RETURNS: the current size of the buffer.
   size_t get_buffer_size() {
      return g_buffered_output_stream_get_buffer_size(&this);
   }

   // Sets whether or not the @stream's buffer should automatically grow.
   // If @auto_grow is true, then each write will just make the buffer
   // larger, and you must manually flush the buffer to actually write out
   // the data to the underlying stream.
   // <auto_grow>: a #gboolean.
   void set_auto_grow(int auto_grow) {
      g_buffered_output_stream_set_auto_grow(&this, auto_grow);
   }

   // Sets the size of the internal buffer to @size.
   // <size>: a #gsize.
   void set_buffer_size(size_t size) {
      g_buffered_output_stream_set_buffer_size(&this, size);
   }
}

struct BufferedOutputStreamClass {
   FilterOutputStreamClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
}

struct BufferedOutputStreamPrivate {
}


// Invoked when a connection to a message bus has been obtained.
// <connection>: The #GDBusConnection to a message bus.
// <name>: The name that is requested to be owned.
// <user_data>: User data passed to g_bus_own_name().
extern (C) alias void function (DBusConnection* connection, char* name, void* user_data) BusAcquiredCallback;


// Invoked when the name is acquired.
// <connection>: The #GDBusConnection on which to acquired the name.
// <name>: The name being owned.
// <user_data>: User data passed to g_bus_own_name() or g_bus_own_name_on_connection().
extern (C) alias void function (DBusConnection* connection, char* name, void* user_data) BusNameAcquiredCallback;


// Invoked when the name being watched is known to have to have a owner.
// <connection>: The #GDBusConnection the name is being watched on.
// <name>: The name being watched.
// <name_owner>: Unique name of the owner of the name being watched.
// <user_data>: User data passed to g_bus_watch_name().
extern (C) alias void function (DBusConnection* connection, char* name, char* name_owner, void* user_data) BusNameAppearedCallback;


// Invoked when the name is lost or @connection has been closed.
// <connection>: The #GDBusConnection on which to acquire the name or %NULL if the connection was disconnected.
// <name>: The name being owned.
// <user_data>: User data passed to g_bus_own_name() or g_bus_own_name_on_connection().
extern (C) alias void function (DBusConnection* connection, char* name, void* user_data) BusNameLostCallback;

// Flags used in g_bus_own_name().
enum BusNameOwnerFlags /* Version 2.26 */ {
   NONE = 0,
   ALLOW_REPLACEMENT = 1,
   REPLACE = 2
}

// Invoked when the name being watched is known not to have to have a owner.
// <connection>: The #GDBusConnection the name is being watched on.
// <name>: The name being watched.
// <user_data>: User data passed to g_bus_watch_name().
extern (C) alias void function (DBusConnection* connection, char* name, void* user_data) BusNameVanishedCallback;

// Flags used in g_bus_watch_name().
enum BusNameWatcherFlags /* Version 2.26 */ {
   NONE = 0,
   AUTO_START = 1
}
// An enumeration for well-known message buses.
enum BusType /* Version 2.26 */ {
   STARTER = -1,
   NONE = 0,
   SYSTEM = 1,
   SESSION = 2
}

// GCancellable is a thread-safe operation cancellation stack used
// throughout GIO to allow for cancellation of synchronous and
// asynchronous operations.
struct Cancellable /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private CancellablePrivate* priv;


   // Creates a new #GCancellable object.
   // 
   // Applications that want to start one or more operations
   // that should be cancellable should create a #GCancellable
   // and pass it to the operations.
   // 
   // One #GCancellable can be used in multiple consecutive
   // operations or in multiple concurrent operations.
   // RETURNS: a #GCancellable.
   static Cancellable* /*new*/ new_() {
      return g_cancellable_new();
   }

   // Gets the top cancellable from the stack.
   // 
   // if the stack is empty.
   // RETURNS: a #GCancellable from the top of the stack, or %NULL
   static Cancellable* get_current() {
      return g_cancellable_get_current();
   }

   // Will set @cancellable to cancelled, and will emit the
   // #GCancellable::cancelled signal. (However, see the warning about
   // race conditions in the documentation for that signal if you are
   // planning to connect to it.)
   // 
   // This function is thread-safe. In other words, you can safely call
   // it from a thread other than the one running the operation that was
   // passed the @cancellable.
   // 
   // The convention within gio is that cancelling an asynchronous
   // operation causes it to complete asynchronously. That is, if you
   // cancel the operation from the same thread in which it is running,
   // then the operation's #GAsyncReadyCallback will not be invoked until
   // the application returns to the main loop.
   void cancel() {
      g_cancellable_cancel(&this);
   }

   // Convenience function to connect to the #GCancellable::cancelled
   // signal. Also handles the race condition that may happen
   // if the cancellable is cancelled right before connecting.
   // 
   // @callback is called at most once, either directly at the
   // time of the connect if @cancellable is already cancelled,
   // or when @cancellable is cancelled in some thread.
   // 
   // @data_destroy_func will be called when the handler is
   // disconnected, or immediately if the cancellable is already
   // cancelled.
   // 
   // See #GCancellable::cancelled for details on how to use this.
   // 
   // been cancelled.
   // RETURNS: The id of the signal handler or 0 if @cancellable has already
   // <callback>: The #GCallback to connect.
   // <data>: Data to pass to @callback.
   // <data_destroy_func>: Free function for @data or %NULL.
   c_ulong connect(GObject2.Callback callback, void* data, GLib2.DestroyNotify data_destroy_func) {
      return g_cancellable_connect(&this, callback, data, data_destroy_func);
   }

   // Disconnects a handler from a cancellable instance similar to
   // g_signal_handler_disconnect().  Additionally, in the event that a
   // signal handler is currently running, this call will block until the
   // handler has finished.  Calling this function from a
   // #GCancellable::cancelled signal handler will therefore result in a
   // deadlock.
   // 
   // This avoids a race condition where a thread cancels at the
   // same time as the cancellable operation is finished and the
   // signal handler is removed. See #GCancellable::cancelled for
   // details on how to use this.
   // 
   // If @cancellable is %NULL or @handler_id is %0 this function does
   // nothing.
   // <handler_id>: Handler id of the handler to be disconnected, or %0.
   void disconnect(c_ulong handler_id) {
      g_cancellable_disconnect(&this, handler_id);
   }

   // Gets the file descriptor for a cancellable job. This can be used to
   // implement cancellable operations on Unix systems. The returned fd will
   // turn readable when @cancellable is cancelled.
   // 
   // You are not supposed to read from the fd yourself, just check for
   // readable status. Reading to unset the readable status is done
   // with g_cancellable_reset().
   // 
   // After a successful return from this function, you should use
   // g_cancellable_release_fd() to free up resources allocated for
   // the returned file descriptor.
   // 
   // See also g_cancellable_make_pollfd().
   // 
   // is not supported, or on errors.
   // RETURNS: A valid file descriptor. %-1 if the file descriptor
   int get_fd() {
      return g_cancellable_get_fd(&this);
   }

   // Checks if a cancellable job has been cancelled.
   // 
   // FALSE if called with %NULL or if item is not cancelled.
   // RETURNS: %TRUE if @cancellable is cancelled,
   int is_cancelled() {
      return g_cancellable_is_cancelled(&this);
   }

   // Creates a #GPollFD corresponding to @cancellable; this can be passed
   // to g_poll() and used to poll for cancellation. This is useful both
   // for unix systems without a native poll and for portability to
   // windows.
   // 
   // When this function returns %TRUE, you should use
   // g_cancellable_release_fd() to free up resources allocated for the
   // @pollfd. After a %FALSE return, do not call g_cancellable_release_fd().
   // 
   // If this function returns %FALSE, either no @cancellable was given or
   // resource limits prevent this function from allocating the necessary
   // structures for polling. (On Linux, you will likely have reached
   // the maximum number of file descriptors.) The suggested way to handle
   // these cases is to ignore the @cancellable.
   // 
   // You are not supposed to read from the fd yourself, just check for
   // readable status. Reading to unset the readable status is done
   // with g_cancellable_reset().
   // 
   // failure to prepare the cancellable.
   // RETURNS: %TRUE if @pollfd was successfully initialized, %FALSE on
   // <pollfd>: a pointer to a #GPollFD
   int make_pollfd(GLib2.PollFD* pollfd) {
      return g_cancellable_make_pollfd(&this, pollfd);
   }

   // Pops @cancellable off the cancellable stack (verifying that @cancellable
   // is on the top of the stack).
   void pop_current() {
      g_cancellable_pop_current(&this);
   }

   // Pushes @cancellable onto the cancellable stack. The current
   // cancellable can then be received using g_cancellable_get_current().
   // 
   // This is useful when implementing cancellable operations in
   // code that does not allow you to pass down the cancellable object.
   // 
   // This is typically called automatically by e.g. #GFile operations,
   // so you rarely have to call this yourself.
   void push_current() {
      g_cancellable_push_current(&this);
   }

   // Releases a resources previously allocated by g_cancellable_get_fd()
   // or g_cancellable_make_pollfd().
   // 
   // For compatibility reasons with older releases, calling this function
   // is not strictly required, the resources will be automatically freed
   // when the @cancellable is finalized. However, the @cancellable will
   // block scarce file descriptors until it is finalized if this function
   // is not called. This can cause the application to run out of file
   // descriptors when many #GCancellables are used at the same time.
   void release_fd() {
      g_cancellable_release_fd(&this);
   }

   // Resets @cancellable to its uncancelled state.
   // 
   // If cancellable is currently in use by any cancellable operation
   // then the behavior of this function is undefined.
   void reset() {
      g_cancellable_reset(&this);
   }

   // If the @cancellable is cancelled, sets the error to notify
   // that the operation was cancelled.
   // RETURNS: %TRUE if @cancellable was cancelled, %FALSE if it was not
   int set_error_if_cancelled(GLib2.Error** error=null) {
      return g_cancellable_set_error_if_cancelled(&this, error);
   }

   // Unintrospectable method: source_new() / g_cancellable_source_new()
   // Creates a source that triggers if @cancellable is cancelled and
   // calls its callback of type #GCancellableSourceFunc. This is
   // primarily useful for attaching to another (non-cancellable) source
   // with g_source_add_child_source() to add cancellability to it.
   // 
   // For convenience, you can call this with a %NULL #GCancellable,
   // in which case the source will never trigger.
   // RETURNS: the new #GSource.
   GLib2.Source* /*new*/ source_new() {
      return g_cancellable_source_new(&this);
   }

   // Emitted when the operation has been cancelled.
   // 
   // Can be used by implementations of cancellable operations. If the
   // operation is cancelled from another thread, the signal will be
   // emitted in the thread that cancelled the operation, not the
   // thread that is running the operation.
   // 
   // Note that disconnecting from this signal (or any signal) in a
   // multi-threaded program is prone to race conditions. For instance
   // it is possible that a signal handler may be invoked even
   // <emphasis>after</emphasis> a call to
   // g_signal_handler_disconnect() for that handler has already
   // returned.
   // 
   // There is also a problem when cancellation happen
   // right before connecting to the signal. If this happens the
   // signal will unexpectedly not be emitted, and checking before
   // connecting to the signal leaves a race condition where this is
   // still happening.
   // 
   // In order to make it safe and easy to connect handlers there
   // are two helper functions: g_cancellable_connect() and
   // g_cancellable_disconnect() which protect against problems
   // like this.
   // 
   // An example of how to us this:
   // |[
   // /<!-- -->* Make sure we don't do any unnecessary work if already cancelled *<!-- -->/
   // if (g_cancellable_set_error_if_cancelled (cancellable))
   // return;
   // 
   // /<!-- -->* Set up all the data needed to be able to
   // * handle cancellation of the operation *<!-- -->/
   // my_data = my_data_new (...);
   // 
   // id = 0;
   // if (cancellable)
   // id = g_cancellable_connect (cancellable,
   // G_CALLBACK (cancelled_handler)
   // data, NULL);
   // 
   // /<!-- -->* cancellable operation here... *<!-- -->/
   // 
   // g_cancellable_disconnect (cancellable, id);
   // 
   // /<!-- -->* cancelled_handler is never called after this, it
   // * is now safe to free the data *<!-- -->/
   // my_data_free (my_data);
   // ]|
   // 
   // Note that the cancelled signal is emitted in the thread that
   // the user cancelled from, which may be the main thread. So, the
   // cancellable signal should not do something that can block.
   extern (C) alias static void function (Cancellable* this_, void* user_data=null) signal_cancelled;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"cancelled", CB:signal_cancelled)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"cancelled",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct CancellableClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (Cancellable* cancellable) cancelled;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct CancellablePrivate {
}


// This is the function type of the callback used for the #GSource
// returned by g_cancellable_source_new().
// RETURNS: it should return %FALSE if the source should be removed.
// <cancellable>: the #GCancellable
// <user_data>: data passed in by the user.
extern (C) alias int function (Cancellable* cancellable, void* user_data) CancellableSourceFunc;


// #GCharsetConverter is an implementation of #GConverter based on
// GIConv.
struct CharsetConverter /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new #GCharsetConverter.
   // RETURNS: a new #GCharsetConverter or %NULL on error.
   // <to_charset>: destination charset
   // <from_charset>: source charset
   static CharsetConverter* /*new*/ new_(char* to_charset, char* from_charset, GLib2.Error** error=null) {
      return g_charset_converter_new(to_charset, from_charset, error);
   }

   // Gets the number of fallbacks that @converter has applied so far.
   // RETURNS: the number of fallbacks that @converter has applied
   uint get_num_fallbacks() {
      return g_charset_converter_get_num_fallbacks(&this);
   }

   // Gets the #GCharsetConverter:use-fallback property.
   // RETURNS: %TRUE if fallbacks are used by @converter
   int get_use_fallback() {
      return g_charset_converter_get_use_fallback(&this);
   }

   // Sets the #GCharsetConverter:use-fallback property.
   // <use_fallback>: %TRUE to use fallbacks
   void set_use_fallback(int use_fallback) {
      g_charset_converter_set_use_fallback(&this, use_fallback);
   }
}

struct CharsetConverterClass {
   GObject2.ObjectClass parent_class;
}


// #GConverter is implemented by objects that convert
// binary data in various ways. The conversion can be
// stateful and may fail at any place.
// 
// Some example conversions are: character set conversion,
// compression, decompression and regular expression
// replace.
struct Converter /* Version 2.24 */ {

   // This is the main operation used when converting data. It is to be called
   // multiple times in a loop, and each time it will do some work, i.e.
   // producing some output (in @outbuf) or consuming some input (from @inbuf) or
   // both. If its not possible to do any work an error is returned.
   // 
   // Note that a single call may not consume all input (or any input at all).
   // Also a call may produce output even if given no input, due to state stored
   // in the converter producing output.
   // 
   // If any data was either produced or consumed, and then an error happens, then
   // only the successful conversion is reported and the error is returned on the
   // next call.
   // 
   // A full conversion loop involves calling this method repeatedly, each time
   // giving it new input and space output space. When there is no more input
   // data after the data in @inbuf, the flag %G_CONVERTER_INPUT_AT_END must be set.
   // The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED
   // each time until all data is consumed and all output is produced, then
   // %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED
   // may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance
   // in a decompression converter where the end of data is detectable from the
   // data (and there might even be other data after the end of the compressed data).
   // 
   // When some data has successfully been converted @bytes_read and is set to
   // the number of bytes read from @inbuf, and @bytes_written is set to indicate
   // how many bytes was written to @outbuf. If there are more data to output
   // or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then
   // %G_CONVERTER_CONVERTED is returned, and if no more data is to be output
   // then %G_CONVERTER_FINISHED is returned.
   // 
   // On error %G_CONVERTER_ERROR is returned and @error is set accordingly.
   // Some errors need special handling:
   // 
   // %G_IO_ERROR_NO_SPACE is returned if there is not enough space
   // to write the resulting converted data, the application should
   // call the function again with a larger @outbuf to continue.
   // 
   // %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough
   // input to fully determine what the conversion should produce,
   // and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for
   // example with an incomplete multibyte sequence when converting text,
   // or when a regexp matches up to the end of the input (and may match
   // further input). It may also happen when @inbuf_size is zero and
   // there is no more data to produce.
   // 
   // When this happens the application should read more input and then
   // call the function again. If further input shows that there is no
   // more data call the function again with the same data but with
   // the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion
   // to finish as e.g. in the regexp match case (or, to fail again with
   // %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
   // input is actually partial).
   // 
   // After g_converter_convert() has returned %G_CONVERTER_FINISHED the
   // converter object is in an invalid state where its not allowed
   // to call g_converter_convert() anymore. At this time you can only
   // free the object or call g_converter_reset() to reset it to the
   // initial state.
   // 
   // If the flag %G_CONVERTER_FLUSH is set then conversion is modified
   // to try to write out all internal state to the output. The application
   // has to call the function multiple times with the flag set, and when
   // the available input has been consumed and all internal state has
   // been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if
   // really at the end) is returned instead of %G_CONVERTER_CONVERTED.
   // This is somewhat similar to what happens at the end of the input stream,
   // but done in the middle of the data.
   // 
   // This has different meanings for different conversions. For instance
   // in a compression converter it would mean that we flush all the
   // compression state into output such that if you uncompress the
   // compressed data you get back all the input data. Doing this may
   // make the final file larger due to padding though. Another example
   // is a regexp conversion, where if you at the end of the flushed data
   // have a match, but there is also a potential longer match. In the
   // non-flushed case we would ask for more input, but when flushing we
   // treat this as the end of input and do the match.
   // 
   // Flushing is not always possible (like if a charset converter flushes
   // at a partial multibyte sequence). Converters are supposed to try
   // to produce as much output as possible and then return an error
   // (typically %G_IO_ERROR_PARTIAL_INPUT).
   // RETURNS: a #GConverterResult, %G_CONVERTER_ERROR on error.
   // <inbuf>: the buffer containing the data to convert.
   // <inbuf_size>: the number of bytes in @inbuf
   // <outbuf>: a buffer to write converted data in.
   // <outbuf_size>: the number of bytes in @outbuf, must be at least one
   // <flags>: a #GConvertFlags controlling the conversion details
   // <bytes_read>: will be set to the number of bytes read from @inbuf on success
   // <bytes_written>: will be set to the number of bytes written to @outbuf on success
   ConverterResult convert(ubyte* inbuf, size_t inbuf_size, void* outbuf, size_t outbuf_size, ConverterFlags flags, /*out*/ size_t* bytes_read, /*out*/ size_t* bytes_written, GLib2.Error** error=null) {
      return g_converter_convert(&this, inbuf, inbuf_size, outbuf, outbuf_size, flags, bytes_read, bytes_written, error);
   }

   // Resets all internal state in the converter, making it behave
   // as if it was just created. If the converter has any internal
   // state that would produce output then that output is lost.
   void reset() {
      g_converter_reset(&this);
   }
}

// Flags used when calling a g_converter_convert().
enum ConverterFlags /* Version 2.24 */ {
   G_CONVERTER_NO_FLAGS = 0,
   INPUT_AT_END = 1,
   FLUSH = 2
}

// Provides an interface for converting data from one type
// to another type. The conversion can be stateful
// and may fail at any place.
struct ConverterIface /* Version 2.24 */ {
   GObject2.TypeInterface g_iface;

   // RETURNS: a #GConverterResult, %G_CONVERTER_ERROR on error.
   // <inbuf>: the buffer containing the data to convert.
   // <inbuf_size>: the number of bytes in @inbuf
   // <outbuf>: a buffer to write converted data in.
   // <outbuf_size>: the number of bytes in @outbuf, must be at least one
   // <flags>: a #GConvertFlags controlling the conversion details
   // <bytes_read>: will be set to the number of bytes read from @inbuf on success
   // <bytes_written>: will be set to the number of bytes written to @outbuf on success
   extern (C) ConverterResult function (Converter* converter, ubyte* inbuf, size_t inbuf_size, void* outbuf, size_t outbuf_size, ConverterFlags flags, /*out*/ size_t* bytes_read, /*out*/ size_t* bytes_written, GLib2.Error** error=null) convert;
   extern (C) void function (Converter* converter) reset;
}


// Converter input stream implements #GInputStream and allows
// conversion of data of various types during reading.
struct ConverterInputStream /* : FilterInputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance filterinputstream;
   FilterInputStream parent_instance;
   private ConverterInputStreamPrivate* priv;


   // Creates a new converter input stream for the @base_stream.
   // RETURNS: a new #GInputStream.
   // <base_stream>: a #GInputStream
   // <converter>: a #GConverter
   static ConverterInputStream* /*new*/ new_(InputStream* base_stream, Converter* converter) {
      return g_converter_input_stream_new(base_stream, converter);
   }

   // Gets the #GConverter that is used by @converter_stream.
   // RETURNS: the converter of the converter input stream
   Converter* get_converter() {
      return g_converter_input_stream_get_converter(&this);
   }
}

struct ConverterInputStreamClass {
   FilterInputStreamClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct ConverterInputStreamPrivate {
}


// Converter output stream implements #GOutputStream and allows
// conversion of data of various types during reading.
struct ConverterOutputStream /* : FilterOutputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance filteroutputstream;
   FilterOutputStream parent_instance;
   private ConverterOutputStreamPrivate* priv;


   // Creates a new converter output stream for the @base_stream.
   // RETURNS: a new #GOutputStream.
   // <base_stream>: a #GOutputStream
   // <converter>: a #GConverter
   static ConverterOutputStream* /*new*/ new_(OutputStream* base_stream, Converter* converter) {
      return g_converter_output_stream_new(base_stream, converter);
   }

   // Gets the #GConverter that is used by @converter_stream.
   // RETURNS: the converter of the converter output stream
   Converter* get_converter() {
      return g_converter_output_stream_get_converter(&this);
   }
}

struct ConverterOutputStreamClass {
   FilterOutputStreamClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct ConverterOutputStreamPrivate {
}

// Results returned from g_converter_convert().
enum ConverterResult /* Version 2.24 */ {
   ERROR = 0,
   CONVERTED = 1,
   FINISHED = 2,
   FLUSHED = 3
}

// The #GCredentials type is a reference-counted wrapper for native
// credentials. This information is typically used for identifying,
// authenticating and authorizing other processes.
// 
// Some operating systems supports looking up the credentials of the
// remote peer of a communication endpoint - see e.g.
// g_socket_get_credentials().
// 
// Some operating systems supports securely sending and receiving
// credentials over a Unix Domain Socket, see
// #GUnixCredentialsMessage, g_unix_connection_send_credentials() and
// g_unix_connection_receive_credentials() for details.
// 
// On Linux, the native credential type is a <type>struct ucred</type>
// - see the
// <citerefentry><refentrytitle>unix</refentrytitle><manvolnum>7</manvolnum></citerefentry>
// man page for details. This corresponds to
// %G_CREDENTIALS_TYPE_LINUX_UCRED.
// 
// On FreeBSD, the native credential type is a <type>struct cmsgcred</type>.
// This corresponds to %G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED.
// 
// On OpenBSD, the native credential type is a <type>struct sockpeercred</type>.
// This corresponds to %G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED.
struct Credentials /* : GObject.Object */ /* Version 2.26 */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new #GCredentials object with credentials matching the
   // the current process.
   // RETURNS: A #GCredentials. Free with g_object_unref().
   static Credentials* /*new*/ new_() {
      return g_credentials_new();
   }

   // Unintrospectable method: get_native() / g_credentials_get_native()
   // Gets a pointer to native credentials of type @native_type from
   // @credentials.
   // 
   // It is a programming error (which will cause an warning to be
   // logged) to use this method if there is no #GCredentials support for
   // the OS or if @native_type isn't supported by the OS.
   // 
   // operation there is no #GCredentials support for the OS or if
   // @native_type isn't supported by the OS. Do not free the returned
   // data, it is owned by @credentials.
   // RETURNS: The pointer to native credentials or %NULL if the
   // <native_type>: The type of native credentials to get.
   void* get_native(CredentialsType native_type) {
      return g_credentials_get_native(&this, native_type);
   }

   // Tries to get the UNIX user identifier from @credentials. This
   // method is only available on UNIX platforms.
   // 
   // This operation can fail if #GCredentials is not supported on the
   // OS or if the native credentials type does not contain information
   // about the UNIX user.
   // RETURNS: The UNIX user identifier or -1 if @error is set.
   uint get_unix_user(GLib2.Error** error=null) {
      return g_credentials_get_unix_user(&this, error);
   }

   // Checks if @credentials and @other_credentials is the same user.
   // 
   // This operation can fail if #GCredentials is not supported on the
   // the OS.
   // 
   // user, %FALSE otherwise or if @error is set.
   // RETURNS: %TRUE if @credentials and @other_credentials has the same
   // <other_credentials>: A #GCredentials.
   int is_same_user(Credentials* other_credentials, GLib2.Error** error=null) {
      return g_credentials_is_same_user(&this, other_credentials, error);
   }

   // Copies the native credentials of type @native_type from @native
   // into @credentials.
   // 
   // It is a programming error (which will cause an warning to be
   // logged) to use this method if there is no #GCredentials support for
   // the OS or if @native_type isn't supported by the OS.
   // <native_type>: The type of native credentials to set.
   // <native>: A pointer to native credentials.
   void set_native(CredentialsType native_type, void* native) {
      g_credentials_set_native(&this, native_type, native);
   }

   // Tries to set the UNIX user identifier on @credentials. This method
   // is only available on UNIX platforms.
   // 
   // This operation can fail if #GCredentials is not supported on the
   // OS or if the native credentials type does not contain information
   // about the UNIX user.
   // RETURNS: %TRUE if @uid was set, %FALSE if error is set.
   // <uid>: The UNIX user identifier to set.
   int set_unix_user(uint uid, GLib2.Error** error=null) {
      return g_credentials_set_unix_user(&this, uid, error);
   }

   // Creates a human-readable textual representation of @credentials
   // that can be used in logging and debug messages. The format of the
   // returned string may change in future GLib release.
   // RETURNS: A string that should be freed with g_free().
   char* /*new*/ to_string() {
      return g_credentials_to_string(&this);
   }
}

// Class structure for #GCredentials.
struct CredentialsClass /* Version 2.26 */ {
}

// Enumeration describing different kinds of native credential types.
enum CredentialsType /* Version 2.26 */ {
   INVALID = 0,
   LINUX_UCRED = 1,
   FREEBSD_CMSGCRED = 2,
   OPENBSD_SOCKPEERCRED = 3
}
// Information about an annotation.
struct DBusAnnotationInfo /* Version 2.26 */ {
   int ref_count;
   char* key, value;
   DBusAnnotationInfo*[666] annotations;


   // If @info is statically allocated does nothing. Otherwise increases
   // the reference count.
   // RETURNS: The same @info.
   DBusAnnotationInfo* /*new*/ ref_() {
      return g_dbus_annotation_info_ref(&this);
   }

   // If @info is statically allocated, does nothing. Otherwise decreases
   // the reference count of @info. When its reference count drops to 0,
   // the memory used is freed.
   void unref() {
      g_dbus_annotation_info_unref(&this);
   }

   // Looks up the value of an annotation.
   // 
   // This cost of this function is O(n) in number of annotations.
   // RETURNS: The value or %NULL if not found. Do not free, it is owned by @annotations.
   // <annotations>: A %NULL-terminated array of annotations or %NULL.
   // <name>: The name of the annotation to look up.
   static char* lookup(DBusAnnotationInfo** annotations, char* name) {
      return g_dbus_annotation_info_lookup(annotations, name);
   }
}

// Information about an argument for a method or a signal.
struct DBusArgInfo /* Version 2.26 */ {
   int ref_count;
   char* name, signature;
   DBusAnnotationInfo*[666] annotations;


   // If @info is statically allocated does nothing. Otherwise increases
   // the reference count.
   // RETURNS: The same @info.
   DBusArgInfo* /*new*/ ref_() {
      return g_dbus_arg_info_ref(&this);
   }

   // If @info is statically allocated, does nothing. Otherwise decreases
   // the reference count of @info. When its reference count drops to 0,
   // the memory used is freed.
   void unref() {
      g_dbus_arg_info_unref(&this);
   }
}


// The #GDBusAuthObserver type provides a mechanism for participating
// in how a #GDBusServer (or a #GDBusConnection) authenticates remote
// peers. Simply instantiate a #GDBusAuthObserver and connect to the
// signals you are interested in. Note that new signals may be added
// in the future
// 
// For example, if you only want to allow D-Bus connections from
// processes owned by the same uid as the server, you would use a
// signal handler like the following:
// <example id="auth-observer"><title>Controlling Authentication</title><programlisting>
// static gboolean
// on_authorize_authenticated_peer (GDBusAuthObserver *observer,
// GIOStream         *stream,
// GCredentials      *credentials,
// gpointer           user_data)
// {
// gboolean authorized;
// 
// authorized = FALSE;
// if (credentials != NULL)
// {
// GCredentials *own_credentials;
// own_credentials = g_credentials_new ();
// if (g_credentials_is_same_user (credentials, own_credentials, NULL))
// authorized = TRUE;
// g_object_unref (own_credentials);
// }
// 
// return authorized;
// }
// </programlisting></example>
struct DBusAuthObserver /* : GObject.Object */ /* Version 2.26 */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new #GDBusAuthObserver object.
   // RETURNS: A #GDBusAuthObserver. Free with g_object_unref().
   static DBusAuthObserver* /*new*/ new_() {
      return g_dbus_auth_observer_new();
   }

   // Emits the #GDBusAuthObserver::authorize-authenticated-peer signal on @observer.
   // RETURNS: %TRUE if the peer is authorized, %FALSE if not.
   // <stream>: A #GIOStream for the #GDBusConnection.
   // <credentials>: Credentials received from the peer or %NULL.
   int authorize_authenticated_peer(IOStream* stream, Credentials* credentials) {
      return g_dbus_auth_observer_authorize_authenticated_peer(&this, stream, credentials);
   }

   // Emitted to check if a peer that is successfully authenticated
   // is authorized.
   // RETURNS: %TRUE if the peer is authorized, %FALSE if not.
   // <stream>: A #GIOStream for the #GDBusConnection.
   // <credentials>: Credentials received from the peer or %NULL.
   extern (C) alias static c_int function (DBusAuthObserver* this_, IOStream* stream, Credentials* credentials, void* user_data=null) signal_authorize_authenticated_peer;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"authorize-authenticated-peer", CB:signal_authorize_authenticated_peer)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"authorize-authenticated-peer",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

// Flags used in g_dbus_connection_call() and similar APIs.
enum DBusCallFlags /* Version 2.26 */ {
   NONE = 0,
   NO_AUTO_START = 1
}
// Capabilities negotiated with the remote peer.
enum DBusCapabilityFlags /* Version 2.26 */ {
   NONE = 0,
   UNIX_FD_PASSING = 1
}

// The #GDBusConnection type is used for D-Bus connections to remote
// peers such as a message buses. It is a low-level API that offers a
// lot of flexibility. For instance, it lets you establish a connection
// over any transport that can by represented as an #GIOStream.
// 
// This class is rarely used directly in D-Bus clients. If you are writing
// an D-Bus client, it is often easier to use the g_bus_own_name(),
// g_bus_watch_name() or g_dbus_proxy_new_for_bus() APIs.
// 
// <example id="gdbus-server"><title>D-Bus server example</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-server.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
// 
// <example id="gdbus-subtree-server"><title>D-Bus subtree example</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-subtree.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
// 
// <example id="gdbus-unix-fd-client"><title>D-Bus UNIX File Descriptor example</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-unix-fd-client.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
// 
// <example id="gdbus-export"><title>Exporting a GObject</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-export.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
struct DBusConnection /* : GObject.Object */ /* Version 2.26 */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Finishes an operation started with g_dbus_connection_new().
   // RETURNS: A #GDBusConnection or %NULL if @error is set. Free with g_object_unref().
   // <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_new().
   static DBusConnection* /*new*/ new_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_dbus_connection_new_finish(res, error);
   }

   // Finishes an operation started with g_dbus_connection_new_for_address().
   // RETURNS: A #GDBusConnection or %NULL if @error is set. Free with g_object_unref().
   // <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_new().
   static DBusConnection* /*new*/ new_for_address_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_dbus_connection_new_for_address_finish(res, error);
   }

   // Synchronously connects and sets up a D-Bus client connection for
   // exchanging D-Bus messages with an endpoint specified by @address
   // which must be in the D-Bus address format.
   // 
   // This constructor can only be used to initiate client-side
   // connections - use g_dbus_connection_new_sync() if you need to act
   // as the server. In particular, @flags cannot contain the
   // %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER or
   // %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS flags.
   // 
   // This is a synchronous failable constructor. See
   // g_dbus_connection_new_for_address() for the asynchronous version.
   // 
   // If @observer is not %NULL it may be used to control the
   // authentication process.
   // RETURNS: A #GDBusConnection or %NULL if @error is set. Free with g_object_unref().
   // <address>: A D-Bus address.
   // <flags>: Flags describing how to make the connection.
   // <observer>: A #GDBusAuthObserver or %NULL.
   // <cancellable>: A #GCancellable or %NULL.
   static DBusConnection* /*new*/ new_for_address_sync(char* address, DBusConnectionFlags flags, DBusAuthObserver* observer, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_connection_new_for_address_sync(address, flags, observer, cancellable, error);
   }

   // Synchronously sets up a D-Bus connection for exchanging D-Bus messages
   // with the end represented by @stream.
   // 
   // If @stream is a #GSocketConnection, then the corresponding #GSocket
   // will be put into non-blocking mode.
   // 
   // If @observer is not %NULL it may be used to control the
   // authentication process.
   // 
   // This is a synchronous failable constructor. See
   // g_dbus_connection_new() for the asynchronous version.
   // RETURNS: A #GDBusConnection or %NULL if @error is set. Free with g_object_unref().
   // <stream>: A #GIOStream.
   // <guid>: The GUID to use if a authenticating as a server or %NULL.
   // <flags>: Flags describing how to make the connection.
   // <observer>: A #GDBusAuthObserver or %NULL.
   // <cancellable>: A #GCancellable or %NULL.
   static DBusConnection* /*new*/ new_sync(IOStream* stream, char* guid, DBusConnectionFlags flags, DBusAuthObserver* observer, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_connection_new_sync(stream, guid, flags, observer, cancellable, error);
   }

   // Asynchronously sets up a D-Bus connection for exchanging D-Bus messages
   // with the end represented by @stream.
   // 
   // If @stream is a #GSocketConnection, then the corresponding #GSocket
   // will be put into non-blocking mode.
   // 
   // If @observer is not %NULL it may be used to control the
   // authentication process.
   // 
   // When the operation is finished, @callback will be invoked. You can
   // then call g_dbus_connection_new_finish() to get the result of the
   // operation.
   // 
   // This is a asynchronous failable constructor. See
   // g_dbus_connection_new_sync() for the synchronous
   // version.
   // <stream>: A #GIOStream.
   // <guid>: The GUID to use if a authenticating as a server or %NULL.
   // <flags>: Flags describing how to make the connection.
   // <observer>: A #GDBusAuthObserver or %NULL.
   // <cancellable>: A #GCancellable or %NULL.
   // <callback>: A #GAsyncReadyCallback to call when the request is satisfied.
   // <user_data>: The data to pass to @callback.
   static void new_(IOStream* stream, char* guid, DBusConnectionFlags flags, DBusAuthObserver* observer, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_dbus_connection_new(stream, guid, flags, observer, cancellable, callback, user_data);
   }

   // Asynchronously connects and sets up a D-Bus client connection for
   // exchanging D-Bus messages with an endpoint specified by @address
   // which must be in the D-Bus address format.
   // 
   // This constructor can only be used to initiate client-side
   // connections - use g_dbus_connection_new() if you need to act as the
   // server. In particular, @flags cannot contain the
   // %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER or
   // %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS flags.
   // 
   // When the operation is finished, @callback will be invoked. You can
   // then call g_dbus_connection_new_finish() to get the result of the
   // operation.
   // 
   // If @observer is not %NULL it may be used to control the
   // authentication process.
   // 
   // This is a asynchronous failable constructor. See
   // g_dbus_connection_new_for_address_sync() for the synchronous
   // version.
   // <address>: A D-Bus address.
   // <flags>: Flags describing how to make the connection.
   // <observer>: A #GDBusAuthObserver or %NULL.
   // <cancellable>: A #GCancellable or %NULL.
   // <callback>: A #GAsyncReadyCallback to call when the request is satisfied.
   // <user_data>: The data to pass to @callback.
   static void new_for_address(char* address, DBusConnectionFlags flags, DBusAuthObserver* observer, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_dbus_connection_new_for_address(address, flags, observer, cancellable, callback, user_data);
   }

   // Adds a message filter. Filters are handlers that are run on all
   // incoming and outgoing messages, prior to standard dispatch. Filters
   // are run in the order that they were added.  The same handler can be
   // added as a filter more than once, in which case it will be run more
   // than once.  Filters added during a filter callback won't be run on
   // the message being processed. Filter functions are allowed to modify
   // and even drop messages.
   // 
   // Note that filters are run in a dedicated message handling thread so
   // they can't block and, generally, can't do anything but signal a
   // worker thread. Also note that filters are rarely needed - use API
   // such as g_dbus_connection_send_message_with_reply(),
   // g_dbus_connection_signal_subscribe() or g_dbus_connection_call() instead.
   // 
   // If a filter consumes an incoming message the message is not
   // dispatched anywhere else - not even the standard dispatch machinery
   // (that API such as g_dbus_connection_signal_subscribe() and
   // g_dbus_connection_send_message_with_reply() relies on) will see the
   // message. Similary, if a filter consumes an outgoing message, the
   // message will not be sent to the other peer.
   // 
   // g_dbus_connection_remove_filter().
   // RETURNS: A filter identifier that can be used with
   // <filter_function>: A filter function.
   // <user_data>: User data to pass to @filter_function.
   // <user_data_free_func>: Function to free @user_data with when filter is removed or %NULL.
   uint add_filter(DBusMessageFilterFunction filter_function, void* user_data, GLib2.DestroyNotify user_data_free_func) {
      return g_dbus_connection_add_filter(&this, filter_function, user_data, user_data_free_func);
   }

   // Asynchronously invokes the @method_name method on the
   // @interface_name D-Bus interface on the remote object at
   // @object_path owned by @bus_name.
   // 
   // If @connection is closed then the operation will fail with
   // %G_IO_ERROR_CLOSED. If @cancellable is canceled, the operation will
   // fail with %G_IO_ERROR_CANCELLED. If @parameters contains a value
   // not compatible with the D-Bus protocol, the operation fails with
   // %G_IO_ERROR_INVALID_ARGUMENT.
   // 
   // If @reply_type is non-%NULL then the reply will be checked for having this type and an
   // error will be raised if it does not match.  Said another way, if you give a @reply_type
   // then any non-%NULL return value will be of this type.
   // 
   // If the @parameters #GVariant is floating, it is consumed. This allows
   // convenient 'inline' use of g_variant_new(), e.g.:
   // |[
   // g_dbus_connection_call (connection,
   // "org.freedesktop.StringThings",
   // "/org/freedesktop/StringThings",
   // "org.freedesktop.StringThings",
   // "TwoStrings",
   // g_variant_new ("(ss)",
   // "Thing One",
   // "Thing Two"),
   // NULL,
   // G_DBUS_CALL_FLAGS_NONE,
   // -1,
   // NULL,
   // (GAsyncReadyCallback) two_strings_done,
   // NULL);
   // ]|
   // 
   // This is an asynchronous method. When the operation is finished, @callback will be invoked
   // in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
   // of the thread you are calling this method from. You can then call
   // g_dbus_connection_call_finish() to get the result of the operation.
   // See g_dbus_connection_call_sync() for the synchronous version of this
   // function.
   // <bus_name>: A unique or well-known bus name or %NULL if @connection is not a message bus connection.
   // <object_path>: Path of remote object.
   // <interface_name>: D-Bus interface to invoke method on.
   // <method_name>: The name of the method to invoke.
   // <parameters>: A #GVariant tuple with parameters for the method or %NULL if not passing parameters.
   // <reply_type>: The expected type of the reply, or %NULL.
   // <flags>: Flags from the #GDBusCallFlags enumeration.
   // <timeout_msec>: The timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout.
   // <cancellable>: A #GCancellable or %NULL.
   // <callback>: A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't * care about the result of the method invocation.
   // <user_data>: The data to pass to @callback.
   void call(char* bus_name, char* object_path, char* interface_name, char* method_name, GLib2.Variant* parameters, GLib2.VariantType* reply_type, DBusCallFlags flags, int timeout_msec, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_dbus_connection_call(&this, bus_name, object_path, interface_name, method_name, parameters, reply_type, flags, timeout_msec, cancellable, callback, user_data);
   }

   // Finishes an operation started with g_dbus_connection_call().
   // 
   // return values. Free with g_variant_unref().
   // RETURNS: %NULL if @error is set. Otherwise a #GVariant tuple with
   // <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_call().
   GLib2.Variant* /*new*/ call_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_dbus_connection_call_finish(&this, res, error);
   }

   // Synchronously invokes the @method_name method on the
   // @interface_name D-Bus interface on the remote object at
   // @object_path owned by @bus_name.
   // 
   // If @connection is closed then the operation will fail with
   // %G_IO_ERROR_CLOSED. If @cancellable is canceled, the
   // operation will fail with %G_IO_ERROR_CANCELLED. If @parameters
   // contains a value not compatible with the D-Bus protocol, the operation
   // fails with %G_IO_ERROR_INVALID_ARGUMENT.
   // If @reply_type is non-%NULL then the reply will be checked for having
   // this type and an error will be raised if it does not match.  Said
   // another way, if you give a @reply_type then any non-%NULL return
   // value will be of this type.
   // 
   // If the @parameters #GVariant is floating, it is consumed.
   // This allows convenient 'inline' use of g_variant_new(), e.g.:
   // |[
   // g_dbus_connection_call_sync (connection,
   // "org.freedesktop.StringThings",
   // "/org/freedesktop/StringThings",
   // "org.freedesktop.StringThings",
   // "TwoStrings",
   // g_variant_new ("(ss)",
   // "Thing One",
   // "Thing Two"),
   // NULL,
   // G_DBUS_CALL_FLAGS_NONE,
   // -1,
   // NULL,
   // &amp;error);
   // ]|
   // 
   // The calling thread is blocked until a reply is received. See
   // g_dbus_connection_call() for the asynchronous version of
   // this method.
   // 
   // return values. Free with g_variant_unref().
   // RETURNS: %NULL if @error is set. Otherwise a #GVariant tuple with
   // <bus_name>: A unique or well-known bus name.
   // <object_path>: Path of remote object.
   // <interface_name>: D-Bus interface to invoke method on.
   // <method_name>: The name of the method to invoke.
   // <parameters>: A #GVariant tuple with parameters for the method or %NULL if not passing parameters.
   // <reply_type>: The expected type of the reply, or %NULL.
   // <flags>: Flags from the #GDBusCallFlags enumeration.
   // <timeout_msec>: The timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout.
   // <cancellable>: A #GCancellable or %NULL.
   GLib2.Variant* /*new*/ call_sync(char* bus_name, char* object_path, char* interface_name, char* method_name, GLib2.Variant* parameters, GLib2.VariantType* reply_type, DBusCallFlags flags, int timeout_msec, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_connection_call_sync(&this, bus_name, object_path, interface_name, method_name, parameters, reply_type, flags, timeout_msec, cancellable, error);
   }

   // Like g_dbus_connection_call() but also takes a #GUnixFDList object.
   // 
   // This method is only available on UNIX.
   // <bus_name>: A unique or well-known bus name or %NULL if @connection is not a message bus connection.
   // <object_path>: Path of remote object.
   // <interface_name>: D-Bus interface to invoke method on.
   // <method_name>: The name of the method to invoke.
   // <parameters>: A #GVariant tuple with parameters for the method or %NULL if not passing parameters.
   // <reply_type>: The expected type of the reply, or %NULL.
   // <flags>: Flags from the #GDBusCallFlags enumeration.
   // <timeout_msec>: The timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout.
   // <fd_list>: A #GUnixFDList or %NULL.
   // <cancellable>: A #GCancellable or %NULL.
   // <callback>: A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't * care about the result of the method invocation.
   // <user_data>: The data to pass to @callback.
   void call_with_unix_fd_list(char* bus_name, char* object_path, char* interface_name, char* method_name, GLib2.Variant* parameters, GLib2.VariantType* reply_type, DBusCallFlags flags, int timeout_msec, UnixFDList* fd_list, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_dbus_connection_call_with_unix_fd_list(&this, bus_name, object_path, interface_name, method_name, parameters, reply_type, flags, timeout_msec, fd_list, cancellable, callback, user_data);
   }

   // Finishes an operation started with g_dbus_connection_call_with_unix_fd_list().
   // 
   // return values. Free with g_variant_unref().
   // RETURNS: %NULL if @error is set. Otherwise a #GVariant tuple with
   // <out_fd_list>: Return location for a #GUnixFDList or %NULL.
   // <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_call_with_unix_fd_list().
   GLib2.Variant* /*new*/ call_with_unix_fd_list_finish(/*out*/ UnixFDList** out_fd_list, AsyncResult* res, GLib2.Error** error=null) {
      return g_dbus_connection_call_with_unix_fd_list_finish(&this, out_fd_list, res, error);
   }

   // Like g_dbus_connection_call_sync() but also takes and returns #GUnixFDList objects.
   // 
   // This method is only available on UNIX.
   // 
   // return values. Free with g_variant_unref().
   // RETURNS: %NULL if @error is set. Otherwise a #GVariant tuple with
   // <bus_name>: A unique or well-known bus name.
   // <object_path>: Path of remote object.
   // <interface_name>: D-Bus interface to invoke method on.
   // <method_name>: The name of the method to invoke.
   // <parameters>: A #GVariant tuple with parameters for the method or %NULL if not passing parameters.
   // <reply_type>: The expected type of the reply, or %NULL.
   // <flags>: Flags from the #GDBusCallFlags enumeration.
   // <timeout_msec>: The timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout.
   // <fd_list>: A #GUnixFDList or %NULL.
   // <out_fd_list>: Return location for a #GUnixFDList or %NULL.
   // <cancellable>: A #GCancellable or %NULL.
   GLib2.Variant* /*new*/ call_with_unix_fd_list_sync(char* bus_name, char* object_path, char* interface_name, char* method_name, GLib2.Variant* parameters, GLib2.VariantType* reply_type, DBusCallFlags flags, int timeout_msec, UnixFDList* fd_list, /*out*/ UnixFDList** out_fd_list, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_connection_call_with_unix_fd_list_sync(&this, bus_name, object_path, interface_name, method_name, parameters, reply_type, flags, timeout_msec, fd_list, out_fd_list, cancellable, error);
   }

   // Closes @connection. Note that this never causes the process to
   // exit (this might only happen if the other end of a shared message
   // bus connection disconnects, see #GDBusConnection:exit-on-close).
   // 
   // Once the connection is closed, operations such as sending a message
   // will return with the error %G_IO_ERROR_CLOSED. Closing a connection
   // will not automatically flush the connection so queued messages may
   // be lost. Use g_dbus_connection_flush() if you need such guarantees.
   // 
   // If @connection is already closed, this method fails with
   // %G_IO_ERROR_CLOSED.
   // 
   // When @connection has been closed, the #GDBusConnection::closed
   // signal is emitted in the <link
   // linkend="g-main-context-push-thread-default">thread-default main
   // loop</link> of the thread that @connection was constructed in.
   // 
   // This is an asynchronous method. When the operation is finished,
   // @callback will be invoked in the <link
   // linkend="g-main-context-push-thread-default">thread-default main
   // loop</link> of the thread you are calling this method from. You can
   // then call g_dbus_connection_close_finish() to get the result of the
   // operation.  See g_dbus_connection_close_sync() for the synchronous
   // version.
   // <cancellable>: A #GCancellable or %NULL.
   // <callback>: A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result.
   // <user_data>: The data to pass to @callback.
   void close(Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_dbus_connection_close(&this, cancellable, callback, user_data);
   }

   // Finishes an operation started with g_dbus_connection_close().
   // RETURNS: %TRUE if the operation succeeded, %FALSE if @error is set.
   // <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_close().
   int close_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_dbus_connection_close_finish(&this, res, error);
   }

   // Synchronously closees @connection. The calling thread is blocked
   // until this is done. See g_dbus_connection_close() for the
   // asynchronous version of this method and more details about what it
   // does.
   // RETURNS: %TRUE if the operation succeeded, %FALSE if @error is set.
   // <cancellable>: A #GCancellable or %NULL.
   int close_sync(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_connection_close_sync(&this, cancellable, error);
   }

   // Emits a signal.
   // 
   // If the parameters GVariant is floating, it is consumed.
   // 
   // This can only fail if @parameters is not compatible with the D-Bus protocol.
   // RETURNS: %TRUE unless @error is set.
   // <destination_bus_name>: The unique bus name for the destination for the signal or %NULL to emit to all listeners.
   // <object_path>: Path of remote object.
   // <interface_name>: D-Bus interface to emit a signal on.
   // <signal_name>: The name of the signal to emit.
   // <parameters>: A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
   int emit_signal(char* destination_bus_name, char* object_path, char* interface_name, char* signal_name, GLib2.Variant* parameters, GLib2.Error** error=null) {
      return g_dbus_connection_emit_signal(&this, destination_bus_name, object_path, interface_name, signal_name, parameters, error);
   }

   // Asynchronously flushes @connection, that is, writes all queued
   // outgoing message to the transport and then flushes the transport
   // (using g_output_stream_flush_async()). This is useful in programs
   // that wants to emit a D-Bus signal and then exit
   // immediately. Without flushing the connection, there is no guarantee
   // that the message has been sent to the networking buffers in the OS
   // kernel.
   // 
   // This is an asynchronous method. When the operation is finished,
   // @callback will be invoked in the <link
   // linkend="g-main-context-push-thread-default">thread-default main
   // loop</link> of the thread you are calling this method from. You can
   // then call g_dbus_connection_flush_finish() to get the result of the
   // operation.  See g_dbus_connection_flush_sync() for the synchronous
   // version.
   // <cancellable>: A #GCancellable or %NULL.
   // <callback>: A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result.
   // <user_data>: The data to pass to @callback.
   void flush(Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_dbus_connection_flush(&this, cancellable, callback, user_data);
   }

   // Finishes an operation started with g_dbus_connection_flush().
   // RETURNS: %TRUE if the operation succeeded, %FALSE if @error is set.
   // <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_flush().
   int flush_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_dbus_connection_flush_finish(&this, res, error);
   }

   // Synchronously flushes @connection. The calling thread is blocked
   // until this is done. See g_dbus_connection_flush() for the
   // asynchronous version of this method and more details about what it
   // does.
   // RETURNS: %TRUE if the operation succeeded, %FALSE if @error is set.
   // <cancellable>: A #GCancellable or %NULL.
   int flush_sync(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_connection_flush_sync(&this, cancellable, error);
   }

   // Gets the capabilities negotiated with the remote peer
   // RETURNS: Zero or more flags from the #GDBusCapabilityFlags enumeration.
   DBusCapabilityFlags get_capabilities() {
      return g_dbus_connection_get_capabilities(&this);
   }

   // Gets whether the process is terminated when @connection is
   // closed by the remote peer. See
   // #GDBusConnection:exit-on-close for more details.
   // 
   // closed by the remote peer.
   // RETURNS: Whether the process is terminated when @connection is
   int get_exit_on_close() {
      return g_dbus_connection_get_exit_on_close(&this);
   }

   // The GUID of the peer performing the role of server when
   // authenticating. See #GDBusConnection:guid for more details.
   // 
   // @connection.
   // RETURNS: The GUID. Do not free this string, it is owned by
   char* get_guid() {
      return g_dbus_connection_get_guid(&this);
   }

   // Gets the credentials of the authenticated peer. This will always
   // return %NULL unless @connection acted as a server
   // (e.g. %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER was passed)
   // when set up and the client passed credentials as part of the
   // authentication process.
   // 
   // In a message bus setup, the message bus is always the server and
   // each application is a client. So this method will always return
   // %NULL for message bus clients.
   // 
   // this object, it is owned by @connection.
   // RETURNS: A #GCredentials or %NULL if not available. Do not free
   Credentials* get_peer_credentials() {
      return g_dbus_connection_get_peer_credentials(&this);
   }

   // Gets the underlying stream used for IO.
   // RETURNS: the stream used for IO
   IOStream* get_stream() {
      return g_dbus_connection_get_stream(&this);
   }

   // Gets the unique name of @connection as assigned by the message
   // bus. This can also be used to figure out if @connection is a
   // message bus connection.
   // 
   // bus connection. Do not free this string, it is owned by
   // @connection.
   // RETURNS: The unique name or %NULL if @connection is not a message
   char* get_unique_name() {
      return g_dbus_connection_get_unique_name(&this);
   }

   // Gets whether @connection is closed.
   // RETURNS: %TRUE if the connection is closed, %FALSE otherwise.
   int is_closed() {
      return g_dbus_connection_is_closed(&this);
   }

   // Registers callbacks for exported objects at @object_path with the
   // D-Bus interface that is described in @interface_info.
   // 
   // Calls to functions in @vtable (and @user_data_free_func) will
   // happen in the <link linkend="g-main-context-push-thread-default">thread-default main
   // loop</link> of the thread you are calling this method from.
   // 
   // Note that all #GVariant values passed to functions in @vtable will match
   // the signature given in @interface_info - if a remote caller passes
   // incorrect values, the <literal>org.freedesktop.DBus.Error.InvalidArgs</literal>
   // is returned to the remote caller.
   // 
   // Additionally, if the remote caller attempts to invoke methods or
   // access properties not mentioned in @interface_info the
   // <literal>org.freedesktop.DBus.Error.UnknownMethod</literal> resp.
   // <literal>org.freedesktop.DBus.Error.InvalidArgs</literal> errors
   // are returned to the caller.
   // 
   // It is considered a programming error if the
   // #GDBusInterfaceGetPropertyFunc function in @vtable returns a
   // #GVariant of incorrect type.
   // 
   // If an existing callback is already registered at @object_path and
   // @interface_name, then @error is set to #G_IO_ERROR_EXISTS.
   // 
   // GDBus automatically implements the standard D-Bus interfaces
   // org.freedesktop.DBus.Properties, org.freedesktop.DBus.Introspectable
   // and org.freedesktop.Peer, so you don't have to implement those for
   // the objects you export. You <emphasis>can</emphasis> implement
   // org.freedesktop.DBus.Properties yourself, e.g. to handle getting
   // and setting of properties asynchronously.
   // 
   // Note that the reference count on @interface_info will be
   // incremented by 1 (unless allocated statically, e.g. if the
   // reference count is -1, see g_dbus_interface_info_ref()) for as long
   // as the object is exported. Also note that @vtable will be copied.
   // 
   // See <xref linkend="gdbus-server"/> for an example of how to use this method.
   // 
   // that can be used with g_dbus_connection_unregister_object() .
   // RETURNS: 0 if @error is set, otherwise a registration id (never 0)
   // <object_path>: The object path to register at.
   // <interface_info>: Introspection data for the interface.
   // <vtable>: A #GDBusInterfaceVTable to call into or %NULL.
   // <user_data>: Data to pass to functions in @vtable.
   // <user_data_free_func>: Function to call when the object path is unregistered.
   uint register_object(char* object_path, DBusInterfaceInfo* interface_info, DBusInterfaceVTable* vtable, void* user_data, GLib2.DestroyNotify user_data_free_func, GLib2.Error** error=null) {
      return g_dbus_connection_register_object(&this, object_path, interface_info, vtable, user_data, user_data_free_func, error);
   }

   // Registers a whole subtree of <quote>dynamic</quote> objects.
   // 
   // The @enumerate and @introspection functions in @vtable are used to
   // convey, to remote callers, what nodes exist in the subtree rooted
   // by @object_path.
   // 
   // When handling remote calls into any node in the subtree, first the
   // @enumerate function is used to check if the node exists. If the node exists
   // or the #G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is set
   // the @introspection function is used to check if the node supports the
   // requested method. If so, the @dispatch function is used to determine
   // where to dispatch the call. The collected #GDBusInterfaceVTable and
   // #gpointer will be used to call into the interface vtable for processing
   // the request.
   // 
   // All calls into user-provided code will be invoked in the <link
   // linkend="g-main-context-push-thread-default">thread-default main
   // loop</link> of the thread you are calling this method from.
   // 
   // If an existing subtree is already registered at @object_path or
   // then @error is set to #G_IO_ERROR_EXISTS.
   // 
   // Note that it is valid to register regular objects (using
   // g_dbus_connection_register_object()) in a subtree registered with
   // g_dbus_connection_register_subtree() - if so, the subtree handler
   // is tried as the last resort. One way to think about a subtree
   // handler is to consider it a <quote>fallback handler</quote>
   // for object paths not registered via g_dbus_connection_register_object()
   // or other bindings.
   // 
   // Note that @vtable will be copied so you cannot change it after
   // registration.
   // 
   // See <xref linkend="gdbus-subtree-server"/> for an example of how to use this method.
   // 
   // that can be used with g_dbus_connection_unregister_subtree() .
   // RETURNS: 0 if @error is set, otherwise a subtree registration id (never 0)
   // <object_path>: The object path to register the subtree at.
   // <vtable>: A #GDBusSubtreeVTable to enumerate, introspect and dispatch nodes in the subtree.
   // <flags>: Flags used to fine tune the behavior of the subtree.
   // <user_data>: Data to pass to functions in @vtable.
   // <user_data_free_func>: Function to call when the subtree is unregistered.
   uint register_subtree(char* object_path, DBusSubtreeVTable* vtable, DBusSubtreeFlags flags, void* user_data, GLib2.DestroyNotify user_data_free_func, GLib2.Error** error=null) {
      return g_dbus_connection_register_subtree(&this, object_path, vtable, flags, user_data, user_data_free_func, error);
   }

   // Removes a filter.
   // <filter_id>: an identifier obtained from g_dbus_connection_add_filter()
   void remove_filter(uint filter_id) {
      g_dbus_connection_remove_filter(&this, filter_id);
   }

   // Asynchronously sends @message to the peer represented by @connection.
   // 
   // Unless @flags contain the
   // %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
   // will be assigned by @connection and set on @message via
   // g_dbus_message_set_serial(). If @out_serial is not %NULL, then the
   // serial number used will be written to this location prior to
   // submitting the message to the underlying transport.
   // 
   // If @connection is closed then the operation will fail with
   // %G_IO_ERROR_CLOSED. If @message is not well-formed,
   // the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
   // 
   // See <xref linkend="gdbus-server"/> and <xref
   // linkend="gdbus-unix-fd-client"/> for an example of how to use this
   // low-level API to send and receive UNIX file descriptors.
   // 
   // Note that @message must be unlocked, unless @flags contain the
   // %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
   // 
   // transmission, %FALSE if @error is set.
   // RETURNS: %TRUE if the message was well-formed and queued for
   // <message>: A #GDBusMessage
   // <flags>: Flags affecting how the message is sent.
   // <out_serial>: Return location for serial number assigned to @message when sending it or %NULL.
   int send_message(DBusMessage* message, DBusSendMessageFlags flags, /*out*/ uint* out_serial, GLib2.Error** error=null) {
      return g_dbus_connection_send_message(&this, message, flags, out_serial, error);
   }

   // Asynchronously sends @message to the peer represented by @connection.
   // 
   // Unless @flags contain the
   // %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
   // will be assigned by @connection and set on @message via
   // g_dbus_message_set_serial(). If @out_serial is not %NULL, then the
   // serial number used will be written to this location prior to
   // submitting the message to the underlying transport.
   // 
   // If @connection is closed then the operation will fail with
   // %G_IO_ERROR_CLOSED. If @cancellable is canceled, the operation will
   // fail with %G_IO_ERROR_CANCELLED. If @message is not well-formed,
   // the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
   // 
   // This is an asynchronous method. When the operation is finished, @callback will be invoked
   // in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
   // of the thread you are calling this method from. You can then call
   // g_dbus_connection_send_message_with_reply_finish() to get the result of the operation.
   // See g_dbus_connection_send_message_with_reply_sync() for the synchronous version.
   // 
   // Note that @message must be unlocked, unless @flags contain the
   // %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
   // 
   // See <xref linkend="gdbus-server"/> and <xref
   // linkend="gdbus-unix-fd-client"/> for an example of how to use this
   // low-level API to send and receive UNIX file descriptors.
   // <message>: A #GDBusMessage.
   // <flags>: Flags affecting how the message is sent.
   // <timeout_msec>: The timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout.
   // <out_serial>: Return location for serial number assigned to @message when sending it or %NULL.
   // <cancellable>: A #GCancellable or %NULL.
   // <callback>: A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result.
   // <user_data>: The data to pass to @callback.
   void send_message_with_reply(DBusMessage* message, DBusSendMessageFlags flags, int timeout_msec, /*out*/ uint* out_serial, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_dbus_connection_send_message_with_reply(&this, message, flags, timeout_msec, out_serial, cancellable, callback, user_data);
   }

   // Finishes an operation started with g_dbus_connection_send_message_with_reply().
   // 
   // Note that @error is only set if a local in-process error
   // occurred. That is to say that the returned #GDBusMessage object may
   // be of type %G_DBUS_MESSAGE_TYPE_ERROR. Use
   // g_dbus_message_to_gerror() to transcode this to a #GError.
   // 
   // See <xref linkend="gdbus-server"/> and <xref
   // linkend="gdbus-unix-fd-client"/> for an example of how to use this
   // low-level API to send and receive UNIX file descriptors.
   // RETURNS: A locked #GDBusMessage or %NULL if @error is set.
   // <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_send_message_with_reply().
   DBusMessage* /*new*/ send_message_with_reply_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_dbus_connection_send_message_with_reply_finish(&this, res, error);
   }

   // Synchronously sends @message to the peer represented by @connection
   // and blocks the calling thread until a reply is received or the
   // timeout is reached. See g_dbus_connection_send_message_with_reply()
   // for the asynchronous version of this method.
   // 
   // Unless @flags contain the
   // %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
   // will be assigned by @connection and set on @message via
   // g_dbus_message_set_serial(). If @out_serial is not %NULL, then the
   // serial number used will be written to this location prior to
   // submitting the message to the underlying transport.
   // 
   // If @connection is closed then the operation will fail with
   // %G_IO_ERROR_CLOSED. If @cancellable is canceled, the operation will
   // fail with %G_IO_ERROR_CANCELLED. If @message is not well-formed,
   // the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
   // 
   // Note that @error is only set if a local in-process error
   // occurred. That is to say that the returned #GDBusMessage object may
   // be of type %G_DBUS_MESSAGE_TYPE_ERROR. Use
   // g_dbus_message_to_gerror() to transcode this to a #GError.
   // 
   // See <xref linkend="gdbus-server"/> and <xref
   // linkend="gdbus-unix-fd-client"/> for an example of how to use this
   // low-level API to send and receive UNIX file descriptors.
   // 
   // Note that @message must be unlocked, unless @flags contain the
   // %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
   // RETURNS: A locked #GDBusMessage that is the reply to @message or %NULL if @error is set.
   // <message>: A #GDBusMessage.
   // <flags>: Flags affecting how the message is sent.
   // <timeout_msec>: The timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout.
   // <out_serial>: Return location for serial number assigned to @message when sending it or %NULL.
   // <cancellable>: A #GCancellable or %NULL.
   DBusMessage* /*new*/ send_message_with_reply_sync(DBusMessage* message, DBusSendMessageFlags flags, int timeout_msec, /*out*/ uint* out_serial, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_connection_send_message_with_reply_sync(&this, message, flags, timeout_msec, out_serial, cancellable, error);
   }

   // Sets whether the process should be terminated when @connection is
   // closed by the remote peer. See #GDBusConnection:exit-on-close for
   // more details.
   // 
   // Note that this function should be used with care. Most modern UNIX
   // desktops tie the notion of a user session the session bus, and expect
   // all of a users applications to quit when their bus connection goes away.
   // If you are setting @exit_on_close to %FALSE for the shared session
   // bus connection, you should make sure that your application exits
   // when the user session ends.
   // <exit_on_close>: Whether the process should be terminated when @connection is closed by the remote peer.
   void set_exit_on_close(int exit_on_close) {
      g_dbus_connection_set_exit_on_close(&this, exit_on_close);
   }

   // Subscribes to signals on @connection and invokes @callback with a
   // whenever the signal is received. Note that @callback
   // will be invoked in the <link
   // linkend="g-main-context-push-thread-default">thread-default main
   // loop</link> of the thread you are calling this method from.
   // 
   // If @connection is not a message bus connection, @sender must be
   // %NULL.
   // 
   // If @sender is a well-known name note that @callback is invoked with
   // the unique name for the owner of @sender, not the well-known name
   // as one would expect. This is because the message bus rewrites the
   // name. As such, to avoid certain race conditions, users should be
   // tracking the name owner of the well-known name and use that when
   // processing the received signal.
   // RETURNS: A subscription identifier that can be used with g_dbus_connection_signal_unsubscribe().
   // <sender>: Sender name to match on (unique or well-known name) or %NULL to listen from all senders.
   // <interface_name>: D-Bus interface name to match on or %NULL to match on all interfaces.
   // <member>: D-Bus signal name to match on or %NULL to match on all signals.
   // <object_path>: Object path to match on or %NULL to match on all object paths.
   // <arg0>: Contents of first string argument to match on or %NULL to match on all kinds of arguments.
   // <flags>: Flags describing how to subscribe to the signal (currently unused).
   // <callback>: Callback to invoke when there is a signal matching the requested data.
   // <user_data>: User data to pass to @callback.
   // <user_data_free_func>: Function to free @user_data with when subscription is removed or %NULL.
   uint signal_subscribe(char* sender, char* interface_name, char* member, char* object_path, char* arg0, DBusSignalFlags flags, DBusSignalCallback callback, void* user_data, GLib2.DestroyNotify user_data_free_func=null) {
      return g_dbus_connection_signal_subscribe(&this, sender, interface_name, member, object_path, arg0, flags, callback, user_data, user_data_free_func);
   }

   // Unsubscribes from signals.
   // <subscription_id>: A subscription id obtained from g_dbus_connection_signal_subscribe().
   void signal_unsubscribe(uint subscription_id) {
      g_dbus_connection_signal_unsubscribe(&this, subscription_id);
   }

   // If @connection was created with
   // %G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING, this method
   // starts processing messages. Does nothing on if @connection wasn't
   // created with this flag or if the method has already been called.
   void start_message_processing() {
      g_dbus_connection_start_message_processing(&this);
   }

   // Unregisters an object.
   // RETURNS: %TRUE if the object was unregistered, %FALSE otherwise.
   // <registration_id>: A registration id obtained from g_dbus_connection_register_object().
   int unregister_object(uint registration_id) {
      return g_dbus_connection_unregister_object(&this, registration_id);
   }

   // Unregisters a subtree.
   // RETURNS: %TRUE if the subtree was unregistered, %FALSE otherwise.
   // <registration_id>: A subtree registration id obtained from g_dbus_connection_register_subtree().
   int unregister_subtree(uint registration_id) {
      return g_dbus_connection_unregister_subtree(&this, registration_id);
   }

   // Emitted when the connection is closed.
   // 
   // The cause of this event can be
   // <itemizedlist>
   // <listitem><para>
   // If g_dbus_connection_close() is called. In this case
   // @remote_peer_vanished is set to %FALSE and @error is %NULL.
   // </para></listitem>
   // <listitem><para>
   // If the remote peer closes the connection. In this case
   // @remote_peer_vanished is set to %TRUE and @error is set.
   // </para></listitem>
   // <listitem><para>
   // If the remote peer sends invalid or malformed data. In this
   // case @remote_peer_vanished is set to %FALSE and @error
   // is set.
   // </para></listitem>
   // </itemizedlist>
   // 
   // Upon receiving this signal, you should give up your reference to
   // @connection. You are guaranteed that this signal is emitted only
   // once.
   // <remote_peer_vanished>: %TRUE if @connection is closed because the remote peer closed its end of the connection.
   // <error>: A #GError with more details about the event or %NULL.
   extern (C) alias static void function (DBusConnection* this_, c_int remote_peer_vanished, GLib2.Error* error, void* user_data=null) signal_closed;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"closed", CB:signal_closed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"closed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

// Flags used when creating a new #GDBusConnection.
enum DBusConnectionFlags /* Version 2.26 */ {
   NONE = 0,
   AUTHENTICATION_CLIENT = 1,
   AUTHENTICATION_SERVER = 2,
   AUTHENTICATION_ALLOW_ANONYMOUS = 4,
   MESSAGE_BUS_CONNECTION = 8,
   DELAY_MESSAGE_PROCESSING = 16
}

// Certain timeout errors, e.g. while starting a service. Warning: this is
// Error codes for the %G_DBUS_ERROR error domain.
enum DBusError /* Version 2.26 */ {
   FAILED = 0,
   NO_MEMORY = 1,
   SERVICE_UNKNOWN = 2,
   NAME_HAS_NO_OWNER = 3,
   NO_REPLY = 4,
   IO_ERROR = 5,
   BAD_ADDRESS = 6,
   NOT_SUPPORTED = 7,
   LIMITS_EXCEEDED = 8,
   ACCESS_DENIED = 9,
   AUTH_FAILED = 10,
   NO_SERVER = 11,
   TIMEOUT = 12,
   NO_NETWORK = 13,
   ADDRESS_IN_USE = 14,
   DISCONNECTED = 15,
   INVALID_ARGS = 16,
   FILE_NOT_FOUND = 17,
   FILE_EXISTS = 18,
   UNKNOWN_METHOD = 19,
   TIMED_OUT = 20,
   MATCH_RULE_NOT_FOUND = 21,
   MATCH_RULE_INVALID = 22,
   SPAWN_EXEC_FAILED = 23,
   SPAWN_FORK_FAILED = 24,
   SPAWN_CHILD_EXITED = 25,
   SPAWN_CHILD_SIGNALED = 26,
   SPAWN_FAILED = 27,
   SPAWN_SETUP_FAILED = 28,
   SPAWN_CONFIG_INVALID = 29,
   SPAWN_SERVICE_INVALID = 30,
   SPAWN_SERVICE_NOT_FOUND = 31,
   SPAWN_PERMISSIONS_INVALID = 32,
   SPAWN_FILE_INVALID = 33,
   SPAWN_NO_MEMORY = 34,
   UNIX_PROCESS_ID_UNKNOWN = 35,
   INVALID_SIGNATURE = 36,
   INVALID_FILE_CONTENT = 37,
   SELINUX_SECURITY_CONTEXT_UNKNOWN = 38,
   ADT_AUDIT_DATA_UNKNOWN = 39,
   OBJECT_PATH_IN_USE = 40
}
// Struct used in g_dbus_error_register_error_domain().
struct DBusErrorEntry /* Version 2.26 */ {
   int error_code;
   char* dbus_error_name;
}


// The #GDBusInterface type is the base type for D-Bus interfaces both
// on the service side (see #GDBusInterfaceSkeleton) and client side
// (see #GDBusProxy).
struct DBusInterface /* Version 2.30 */ {

   // Gets D-Bus introspection information for the D-Bus interface
   // implemented by @interface_.
   // RETURNS: A #GDBusInterfaceInfo. Do not free.
   DBusInterfaceInfo* get_info() {
      return g_dbus_interface_get_info(&this);
   }

   // Gets the #GDBusObject that @interface_ belongs to, if any.
   // 
   // reference belongs to @interface_ and should not be freed.
   // RETURNS: A #GDBusObject or %NULL. The returned
   DBusObject* get_object() {
      return g_dbus_interface_get_object(&this);
   }

   // Sets the #GDBusObject for @interface_ to @object.
   // 
   // Note that @interface_ will hold a weak reference to @object.
   // <object>: A #GDBusObject or %NULL.
   void set_object(DBusObject* object) {
      g_dbus_interface_set_object(&this, object);
   }
}


// The type of the @get_property function in #GDBusInterfaceVTable.
// 
// @error is set. If the returned #GVariant is floating, it is
// consumed - otherwise its reference count is decreased by one.
// RETURNS: A #GVariant with the value for @property_name or %NULL if
// <connection>: A #GDBusConnection.
// <sender>: The unique bus name of the remote caller.
// <object_path>: The object path that the method was invoked on.
// <interface_name>: The D-Bus interface name for the property.
// <property_name>: The name of the property to get the value of.
// <error>: Return location for error.
// <user_data>: The @user_data #gpointer passed to g_dbus_connection_register_object().
extern (C) alias GLib2.Variant* /*new*/ function (DBusConnection* connection, char* sender, char* object_path, char* interface_name, char* property_name, GLib2.Error** error, void* user_data) DBusInterfaceGetPropertyFunc;

// Base type for D-Bus interfaces.
struct DBusInterfaceIface /* Version 2.30 */ {
   GObject2.TypeInterface parent_iface;
   // RETURNS: A #GDBusInterfaceInfo. Do not free.
   extern (C) DBusInterfaceInfo* function (DBusInterface* interface_) get_info;
   // RETURNS: A #GDBusObject or %NULL. The returned
   extern (C) DBusObject* function (DBusInterface* interface_) get_object;
   // <object>: A #GDBusObject or %NULL.
   extern (C) void function (DBusInterface* interface_, DBusObject* object) set_object;
}

// Information about a D-Bus interface.
struct DBusInterfaceInfo /* Version 2.26 */ {
   int ref_count;
   char* name;
   DBusMethodInfo*[666] methods;
   DBusSignalInfo*[666] signals;
   DBusPropertyInfo*[666] properties;
   DBusAnnotationInfo*[666] annotations;


   // Builds a lookup-cache to speed up
   // g_dbus_interface_info_lookup_method(),
   // g_dbus_interface_info_lookup_signal() and
   // g_dbus_interface_info_lookup_property().
   // 
   // If this has already been called with @info, the existing cache is
   // used and its use count is increased.
   // 
   // Note that @info cannot be modified until
   // g_dbus_interface_info_cache_release() is called.
   void cache_build() {
      g_dbus_interface_info_cache_build(&this);
   }

   // Decrements the usage count for the cache for @info built by
   // g_dbus_interface_info_cache_build() (if any) and frees the
   // resources used by the cache if the usage count drops to zero.
   void cache_release() {
      g_dbus_interface_info_cache_release(&this);
   }

   // Appends an XML representation of @info (and its children) to @string_builder.
   // 
   // This function is typically used for generating introspection XML
   // documents at run-time for handling the
   // <literal>org.freedesktop.DBus.Introspectable.Introspect</literal>
   // method.
   // <indent>: Indentation level.
   // <string_builder>: A #GString to to append XML data to.
   void generate_xml(uint indent, /*out*/ GLib2.String* string_builder) {
      g_dbus_interface_info_generate_xml(&this, indent, string_builder);
   }

   // Looks up information about a method.
   // 
   // This cost of this function is O(n) in number of methods unless
   // g_dbus_interface_info_cache_build() has been used on @info.
   // RETURNS: A #GDBusMethodInfo or %NULL if not found. Do not free, it is owned by @info.
   // <name>: A D-Bus method name (typically in CamelCase)
   DBusMethodInfo* lookup_method(char* name) {
      return g_dbus_interface_info_lookup_method(&this, name);
   }

   // Looks up information about a property.
   // 
   // This cost of this function is O(n) in number of properties unless
   // g_dbus_interface_info_cache_build() has been used on @info.
   // RETURNS: A #GDBusPropertyInfo or %NULL if not found. Do not free, it is owned by @info.
   // <name>: A D-Bus property name (typically in CamelCase).
   DBusPropertyInfo* lookup_property(char* name) {
      return g_dbus_interface_info_lookup_property(&this, name);
   }

   // Looks up information about a signal.
   // 
   // This cost of this function is O(n) in number of signals unless
   // g_dbus_interface_info_cache_build() has been used on @info.
   // RETURNS: A #GDBusSignalInfo or %NULL if not found. Do not free, it is owned by @info.
   // <name>: A D-Bus signal name (typically in CamelCase)
   DBusSignalInfo* lookup_signal(char* name) {
      return g_dbus_interface_info_lookup_signal(&this, name);
   }

   // If @info is statically allocated does nothing. Otherwise increases
   // the reference count.
   // RETURNS: The same @info.
   DBusInterfaceInfo* /*new*/ ref_() {
      return g_dbus_interface_info_ref(&this);
   }

   // If @info is statically allocated, does nothing. Otherwise decreases
   // the reference count of @info. When its reference count drops to 0,
   // the memory used is freed.
   void unref() {
      g_dbus_interface_info_unref(&this);
   }
}


// The type of the @method_call function in #GDBusInterfaceVTable.
// <connection>: A #GDBusConnection.
// <sender>: The unique bus name of the remote caller.
// <object_path>: The object path that the method was invoked on.
// <interface_name>: The D-Bus interface name the method was invoked on.
// <method_name>: The name of the method that was invoked.
// <parameters>: A #GVariant tuple with parameters.
// <invocation>: A #GDBusMethodInvocation object that can be used to return a value or error.
// <user_data>: The @user_data #gpointer passed to g_dbus_connection_register_object().
extern (C) alias void function (DBusConnection* connection, char* sender, char* object_path, char* interface_name, char* method_name, GLib2.Variant* parameters, DBusMethodInvocation* invocation, void* user_data) DBusInterfaceMethodCallFunc;


// The type of the @set_property function in #GDBusInterfaceVTable.
// RETURNS: %TRUE if the property was set to @value, %FALSE if @error is set.
// <connection>: A #GDBusConnection.
// <sender>: The unique bus name of the remote caller.
// <object_path>: The object path that the method was invoked on.
// <interface_name>: The D-Bus interface name for the property.
// <property_name>: The name of the property to get the value of.
// <value>: The value to set the property to.
// <error>: Return location for error.
// <user_data>: The @user_data #gpointer passed to g_dbus_connection_register_object().
extern (C) alias int function (DBusConnection* connection, char* sender, char* object_path, char* interface_name, char* property_name, GLib2.Variant* value, GLib2.Error** error, void* user_data) DBusInterfaceSetPropertyFunc;

// Abstract base class for D-Bus interfaces on the service side.
struct DBusInterfaceSkeleton /* : GObject.Object */ /* Version 2.30 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private DBusInterfaceSkeletonPrivate* priv;


   // Exports @interface_ at @object_path on @connection.
   // 
   // Use g_dbus_interface_skeleton_unexport() to unexport the object.
   // 
   // @error set.
   // RETURNS: %TRUE if the interface was exported, other %FALSE with
   // <connection>: A #GDBusConnection to export @interface_ on.
   // <object_path>: The path to export the interface at.
   int export_(DBusConnection* connection, char* object_path, GLib2.Error** error=null) {
      return g_dbus_interface_skeleton_export(&this, connection, object_path, error);
   }

   // If @interface_ has outstanding changes, request for these changes to be
   // emitted immediately.
   // 
   // For example, an exported D-Bus interface may queue up property
   // changes and emit the
   // <literal>org.freedesktop.DBus.Properties::PropertiesChanged</literal>
   // signal later (e.g. in an idle handler). This technique is useful
   // for collapsing multiple property changes into one.
   void flush() {
      g_dbus_interface_skeleton_flush(&this);
   }

   // Gets the connection that @interface_ is exported on, if any.
   // 
   // not exported anywhere. Do not free, the object belongs to @interface_.
   // RETURNS: A #GDBusConnection or %NULL if @interface_ is
   DBusConnection* get_connection() {
      return g_dbus_interface_skeleton_get_connection(&this);
   }

   // Gets the #GDBusInterfaceSkeletonFlags that describes what the behavior
   // of @interface_
   // RETURNS: One or more flags from the #GDBusInterfaceSkeletonFlags enumeration.
   DBusInterfaceSkeletonFlags get_flags() {
      return g_dbus_interface_skeleton_get_flags(&this);
   }

   // Gets D-Bus introspection information for the D-Bus interface
   // implemented by @interface_.
   // RETURNS: A #GDBusInterfaceInfo (never %NULL). Do not free.
   DBusInterfaceInfo* get_info() {
      return g_dbus_interface_skeleton_get_info(&this);
   }

   // Gets the object path that @interface_ is exported on, if any.
   // 
   // anywhere. Do not free, the string belongs to @interface_.
   // RETURNS: A string owned by @interface_ or %NULL if @interface_ is not exported
   char* get_object_path() {
      return g_dbus_interface_skeleton_get_object_path(&this);
   }

   // Gets all D-Bus properties for @interface_.
   // RETURNS: A #GVariant of type <link linkend="G-VARIANT-TYPE-VARDICT:CAPS">'a{sv}'</link>. Free with g_variant_unref().
   GLib2.Variant* /*new*/ get_properties() {
      return g_dbus_interface_skeleton_get_properties(&this);
   }

   // Unintrospectable method: get_vtable() / g_dbus_interface_skeleton_get_vtable()
   // Gets the interface vtable for the D-Bus interface implemented by
   // @interface_. The returned function pointers should expect @interface_
   // itself to be passed as @user_data.
   // RETURNS: A #GDBusInterfaceVTable (never %NULL).
   DBusInterfaceVTable* get_vtable() {
      return g_dbus_interface_skeleton_get_vtable(&this);
   }

   // Sets flags describing what the behavior of @skeleton should be.
   // <flags>: Flags from the #GDBusInterfaceSkeletonFlags enumeration.
   void set_flags(DBusInterfaceSkeletonFlags flags) {
      g_dbus_interface_skeleton_set_flags(&this, flags);
   }

   // Stops exporting an interface previously exported with
   // g_dbus_interface_skeleton_export().
   void unexport() {
      g_dbus_interface_skeleton_unexport(&this);
   }

   // Emitted when a method is invoked by a remote caller and used to
   // determine if the method call is authorized.
   // 
   // Note that this signal is emitted in a thread dedicated to
   // handling the method call so handlers are allowed to perform
   // blocking IO. This means that it is appropriate to call
   // e.g. <ulink
   // url="http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#polkit-authority-check-authorization-sync">polkit_authority_check_authorization_sync()</ulink>
   // with the <ulink
   // url="http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#POLKIT-CHECK-AUTHORIZATION-FLAGS-ALLOW-USER-INTERACTION:CAPS">POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION</ulink> flag set.
   // 
   // If %FALSE is returned then no further handlers are run and the
   // signal handler must take a reference to @invocation and finish
   // handling the call (e.g. return an error via
   // g_dbus_method_invocation_return_error()).
   // 
   // Otherwise, if %TRUE is returned, signal emission continues. If no
   // handlers return %FALSE, then the method is dispatched. If
   // @interface has an enclosing #GDBusObjectSkeleton, then the
   // #GDBusObjectSkeleton::authorize-method signal handlers run before
   // the handlers for this signal.
   // 
   // The default class handler just returns %TRUE.
   // 
   // Please note that the common case is optimized: if no signals
   // handlers are connected and the default class handler isn't
   // overridden (for both @interface and the enclosing
   // #GDBusObjectSkeleton, if any) and #GDBusInterfaceSkeleton:g-flags does
   // not have the
   // %G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD
   // flags set, no dedicated thread is ever used and the call will be
   // handled in the same thread as the object that @interface belongs
   // to was exported in.
   // RETURNS: %TRUE if the call is authorized, %FALSE otherwise.
   // <invocation>: A #GDBusMethodInvocation.
   extern (C) alias static c_int function (DBusInterfaceSkeleton* this_, DBusMethodInvocation* invocation, void* user_data=null) signal_g_authorize_method;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"g-authorize-method", CB:signal_g_authorize_method)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"g-authorize-method",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

// Class structure for #GDBusInterfaceSkeleton.
struct DBusInterfaceSkeletonClass /* Version 2.30 */ {
   GObject2.ObjectClass parent_class;
   // RETURNS: A #GDBusInterfaceInfo (never %NULL). Do not free.
   extern (C) DBusInterfaceInfo* function (DBusInterfaceSkeleton* interface_) get_info;

   // Unintrospectable functionp: get_vtable() / ()
   // 
   // RETURNS: A #GDBusInterfaceVTable (never %NULL).
   extern (C) DBusInterfaceVTable* function (DBusInterfaceSkeleton* interface_) get_vtable;
   // RETURNS: A #GVariant of type <link linkend="G-VARIANT-TYPE-VARDICT:CAPS">'a{sv}'</link>. Free with g_variant_unref().
   extern (C) GLib2.Variant* /*new*/ function (DBusInterfaceSkeleton* interface_) get_properties;
   extern (C) void function (DBusInterfaceSkeleton* interface_) flush;
   private void*[8] vfunc_padding;
   extern (C) int function (DBusInterfaceSkeleton* interface_, DBusMethodInvocation* invocation) g_authorize_method;
   private void*[8] signal_padding;
}

// Flags describing the behavior of a #GDBusInterfaceSkeleton instance.
enum DBusInterfaceSkeletonFlags /* Version 2.30 */ {
   NONE = 0,
   HANDLE_METHOD_INVOCATIONS_IN_THREAD = 1
}
struct DBusInterfaceSkeletonPrivate {
}


// Virtual table for handling properties and method calls for a D-Bus
// interface.
// 
// If you want to handle getting/setting D-Bus properties asynchronously, simply
// register an object with the <literal>org.freedesktop.DBus.Properties</literal>
// D-Bus interface using g_dbus_connection_register_object().
struct DBusInterfaceVTable /* Version 2.26 */ {
   DBusInterfaceMethodCallFunc method_call;
   DBusInterfaceGetPropertyFunc get_property;
   DBusInterfaceSetPropertyFunc set_property;
   private void*[8] padding;
}


// A type for representing D-Bus messages that can be sent or received
// on a #GDBusConnection.
struct DBusMessage /* : GObject.Object */ /* Version 2.26 */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new empty #GDBusMessage.
   // RETURNS: A #GDBusMessage. Free with g_object_unref().
   static DBusMessage* /*new*/ new_() {
      return g_dbus_message_new();
   }

   // Creates a new #GDBusMessage from the data stored at @blob. The byte
   // order that the message was in can be retrieved using
   // g_dbus_message_get_byte_order().
   // 
   // g_object_unref().
   // RETURNS: A new #GDBusMessage or %NULL if @error is set. Free with
   // <blob>: A blob represent a binary D-Bus message.
   // <blob_len>: The length of @blob.
   // <capabilities>: A #GDBusCapabilityFlags describing what protocol features are supported.
   static DBusMessage* /*new*/ new_from_blob(ubyte* blob, size_t blob_len, DBusCapabilityFlags capabilities, GLib2.Error** error=null) {
      return g_dbus_message_new_from_blob(blob, blob_len, capabilities, error);
   }

   // Creates a new #GDBusMessage for a method call.
   // RETURNS: A #GDBusMessage. Free with g_object_unref().
   // <name>: A valid D-Bus name or %NULL.
   // <path>: A valid object path.
   // <interface_>: A valid D-Bus interface name or %NULL.
   // <method>: A valid method name.
   static DBusMessage* /*new*/ new_method_call(char* name, char* path, char* interface_, char* method) {
      return g_dbus_message_new_method_call(name, path, interface_, method);
   }

   // Creates a new #GDBusMessage for a signal emission.
   // RETURNS: A #GDBusMessage. Free with g_object_unref().
   // <path>: A valid object path.
   // <interface_>: A valid D-Bus interface name.
   // <signal>: A valid signal name.
   static DBusMessage* /*new*/ new_signal(char* path, char* interface_, char* signal) {
      return g_dbus_message_new_signal(path, interface_, signal);
   }

   // Utility function to calculate how many bytes are needed to
   // completely deserialize the D-Bus message stored at @blob.
   // 
   // @blob contains invalid data or not enough data is available to
   // determine the size).
   // RETURNS: Number of bytes needed or -1 if @error is set (e.g. if
   // <blob>: A blob represent a binary D-Bus message.
   // <blob_len>: The length of @blob (must be at least 16).
   static ssize_t bytes_needed(ubyte* blob, size_t blob_len, GLib2.Error** error=null) {
      return g_dbus_message_bytes_needed(blob, blob_len, error);
   }

   // Copies @message. The copy is a deep copy and the returned
   // #GDBusMessage is completely identical except that it is guaranteed
   // to not be locked.
   // 
   // This operation can fail if e.g. @message contains file descriptors
   // and the per-process or system-wide open files limit is reached.
   // 
   // Free with g_object_unref().
   // RETURNS: A new #GDBusMessage or %NULL if @error is set.
   DBusMessage* /*new*/ copy(GLib2.Error** error=null) {
      return g_dbus_message_copy(&this, error);
   }

   // Convenience to get the first item in the body of @message.
   // 
   // @message is not a string.
   // RETURNS: The string item or %NULL if the first item in the body of
   char* get_arg0() {
      return g_dbus_message_get_arg0(&this);
   }

   // Gets the body of a message.
   // RETURNS: A #GVariant or %NULL if the body is empty. Do not free, it is owned by @message.
   GLib2.Variant* /*new*/ get_body() {
      return g_dbus_message_get_body(&this);
   }

   // Gets the byte order of @message.
   // RETURNS: The byte order.
   DBusMessageByteOrder get_byte_order() {
      return g_dbus_message_get_byte_order(&this);
   }

   // Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
   // RETURNS: The value.
   char* get_destination() {
      return g_dbus_message_get_destination(&this);
   }

   // Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
   // RETURNS: The value.
   char* get_error_name() {
      return g_dbus_message_get_error_name(&this);
   }

   // Gets the flags for @message.
   // RETURNS: Flags that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together).
   DBusMessageFlags get_flags() {
      return g_dbus_message_get_flags(&this);
   }

   // Gets a header field on @message.
   // 
   // otherwise. Do not free, it is owned by @message.
   // RETURNS: A #GVariant with the value if the header was found, %NULL
   // <header_field>: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
   GLib2.Variant* /*new*/ get_header(DBusMessageHeaderField header_field) {
      return g_dbus_message_get_header(&this, header_field);
   }

   // Gets an array of all header fields on @message that are set.
   // 
   // %G_DBUS_MESSAGE_HEADER_FIELD_INVALID.  Each element is a
   // #guchar. Free with g_free().
   // RETURNS: An array of header fields terminated by
   ubyte* get_header_fields() {
      return g_dbus_message_get_header_fields(&this);
   }

   // Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
   // RETURNS: The value.
   char* get_interface() {
      return g_dbus_message_get_interface(&this);
   }

   // Checks whether @message is locked. To monitor changes to this
   // value, conncet to the #GObject::notify signal to listen for changes
   // on the #GDBusMessage:locked property.
   // RETURNS: %TRUE if @message is locked, %FALSE otherwise.
   int get_locked() {
      return g_dbus_message_get_locked(&this);
   }

   // Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
   // RETURNS: The value.
   char* get_member() {
      return g_dbus_message_get_member(&this);
   }

   // Gets the type of @message.
   // RETURNS: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
   DBusMessageType get_message_type() {
      return g_dbus_message_get_message_type(&this);
   }

   // Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
   // RETURNS: The value.
   uint get_num_unix_fds() {
      return g_dbus_message_get_num_unix_fds(&this);
   }

   // Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
   // RETURNS: The value.
   char* get_path() {
      return g_dbus_message_get_path(&this);
   }

   // Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
   // RETURNS: The value.
   uint get_reply_serial() {
      return g_dbus_message_get_reply_serial(&this);
   }

   // Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
   // RETURNS: The value.
   char* get_sender() {
      return g_dbus_message_get_sender(&this);
   }

   // Gets the serial for @message.
   // RETURNS: A #guint32.
   uint get_serial() {
      return g_dbus_message_get_serial(&this);
   }

   // Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
   // RETURNS: The value.
   char* get_signature() {
      return g_dbus_message_get_signature(&this);
   }

   // Gets the UNIX file descriptors associated with @message, if any.
   // 
   // This method is only available on UNIX.
   // 
   // associated. Do not free, this object is owned by @message.
   // RETURNS: A #GUnixFDList or %NULL if no file descriptors are
   UnixFDList* get_unix_fd_list() {
      return g_dbus_message_get_unix_fd_list(&this);
   }
   // If @message is locked, does nothing. Otherwise locks the message.
   void lock() {
      g_dbus_message_lock(&this);
   }

   // Unintrospectable method: new_method_error() / g_dbus_message_new_method_error()
   // Creates a new #GDBusMessage that is an error reply to @method_call_message.
   // RETURNS: A #GDBusMessage. Free with g_object_unref().
   // <error_name>: A valid D-Bus error name.
   // <error_message_format>: The D-Bus error message in a printf() format.
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_dbus_message_new_method_error new_method_error; // Variadic
   +/

   // Creates a new #GDBusMessage that is an error reply to @method_call_message.
   // RETURNS: A #GDBusMessage. Free with g_object_unref().
   // <error_name>: A valid D-Bus error name.
   // <error_message>: The D-Bus error message.
   DBusMessage* /*new*/ new_method_error_literal(char* error_name, char* error_message) {
      return g_dbus_message_new_method_error_literal(&this, error_name, error_message);
   }

   // Unintrospectable method: new_method_error_valist() / g_dbus_message_new_method_error_valist()
   // Like g_dbus_message_new_method_error() but intended for language bindings.
   // RETURNS: A #GDBusMessage. Free with g_object_unref().
   // <error_name>: A valid D-Bus error name.
   // <error_message_format>: The D-Bus error message in a printf() format.
   // <var_args>: Arguments for @error_message_format.
   DBusMessage* /*new*/ new_method_error_valist(char* error_name, char* error_message_format, va_list var_args) {
      return g_dbus_message_new_method_error_valist(&this, error_name, error_message_format, var_args);
   }

   // Creates a new #GDBusMessage that is a reply to @method_call_message.
   // RETURNS: #GDBusMessage. Free with g_object_unref().
   DBusMessage* /*new*/ new_method_reply() {
      return g_dbus_message_new_method_reply(&this);
   }

   // Produces a human-readable multi-line description of @message.
   // 
   // The contents of the description has no ABI guarantees, the contents
   // and formatting is subject to change at any time. Typical output
   // looks something like this:
   // <programlisting>
   // Flags:   none
   // Version: 0
   // Serial:  4
   // Headers:
   // path -> objectpath '/org/gtk/GDBus/TestObject'
   // interface -> 'org.gtk.GDBus.TestInterface'
   // member -> 'GimmeStdout'
   // destination -> ':1.146'
   // Body: ()
   // UNIX File Descriptors:
   // (none)
   // </programlisting>
   // or
   // <programlisting>
   // Flags:   no-reply-expected
   // Version: 0
   // Serial:  477
   // Headers:
   // reply-serial -> uint32 4
   // destination -> ':1.159'
   // sender -> ':1.146'
   // num-unix-fds -> uint32 1
   // Body: ()
   // UNIX File Descriptors:
   // fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
   // </programlisting>
   // RETURNS: A string that should be freed with g_free().
   // <indent>: Indentation level.
   char* /*new*/ print(uint indent) {
      return g_dbus_message_print(&this, indent);
   }

   // Sets the body @message. As a side-effect the
   // %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field is set to the
   // type string of @body (or cleared if @body is %NULL).
   // 
   // If @body is floating, @message assumes ownership of @body.
   // <body>: Either %NULL or a #GVariant that is a tuple.
   void set_body(GLib2.Variant* body_) {
      g_dbus_message_set_body(&this, body_);
   }

   // Sets the byte order of @message.
   // <byte_order>: The byte order.
   void set_byte_order(DBusMessageByteOrder byte_order) {
      g_dbus_message_set_byte_order(&this, byte_order);
   }

   // Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
   // <value>: The value to set.
   void set_destination(char* value) {
      g_dbus_message_set_destination(&this, value);
   }

   // Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
   // <value>: The value to set.
   void set_error_name(char* value) {
      g_dbus_message_set_error_name(&this, value);
   }

   // Sets the flags to set on @message.
   // <flags>: Flags for @message that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together).
   void set_flags(DBusMessageFlags flags) {
      g_dbus_message_set_flags(&this, flags);
   }

   // Sets a header field on @message.
   // 
   // If @value is floating, @message assumes ownership of @value.
   // <header_field>: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
   // <value>: A #GVariant to set the header field or %NULL to clear the header field.
   void set_header(DBusMessageHeaderField header_field, GLib2.Variant* value) {
      g_dbus_message_set_header(&this, header_field, value);
   }

   // Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
   // <value>: The value to set.
   void set_interface(char* value) {
      g_dbus_message_set_interface(&this, value);
   }

   // Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
   // <value>: The value to set.
   void set_member(char* value) {
      g_dbus_message_set_member(&this, value);
   }

   // Sets @message to be of @type.
   // <type>: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
   void set_message_type(DBusMessageType type) {
      g_dbus_message_set_message_type(&this, type);
   }

   // Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
   // <value>: The value to set.
   void set_num_unix_fds(uint value) {
      g_dbus_message_set_num_unix_fds(&this, value);
   }

   // Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
   // <value>: The value to set.
   void set_path(char* value) {
      g_dbus_message_set_path(&this, value);
   }

   // Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
   // <value>: The value to set.
   void set_reply_serial(uint value) {
      g_dbus_message_set_reply_serial(&this, value);
   }

   // Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
   // <value>: The value to set.
   void set_sender(char* value) {
      g_dbus_message_set_sender(&this, value);
   }

   // Sets the serial for @message.
   // <serial>: A #guint32.
   void set_serial(uint serial) {
      g_dbus_message_set_serial(&this, serial);
   }

   // Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
   // <value>: The value to set.
   void set_signature(char* value) {
      g_dbus_message_set_signature(&this, value);
   }

   // Sets the UNIX file descriptors associated with @message. As a
   // side-effect the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header
   // field is set to the number of fds in @fd_list (or cleared if
   // @fd_list is %NULL).
   // 
   // This method is only available on UNIX.
   // <fd_list>: A #GUnixFDList or %NULL.
   void set_unix_fd_list(UnixFDList* fd_list=null) {
      g_dbus_message_set_unix_fd_list(&this, fd_list);
   }

   // Serializes @message to a blob. The byte order returned by
   // g_dbus_message_get_byte_order() will be used.
   // 
   // generated by @message or %NULL if @error is set. Free with g_free().
   // RETURNS: A pointer to a valid binary D-Bus message of @out_size bytes
   // <out_size>: Return location for size of generated blob.
   // <capabilities>: A #GDBusCapabilityFlags describing what protocol features are supported.
   ubyte* to_blob(size_t* out_size, DBusCapabilityFlags capabilities, GLib2.Error** error=null) {
      return g_dbus_message_to_blob(&this, out_size, capabilities, error);
   }

   // If @message is not of type %G_DBUS_MESSAGE_TYPE_ERROR does
   // nothing and returns %FALSE.
   // 
   // Otherwise this method encodes the error in @message as a #GError
   // using g_dbus_error_set_dbus_error() using the information in the
   // %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of @message as
   // well as the first string item in @message's body.
   // RETURNS: %TRUE if @error was set, %FALSE otherwise.
   int to_gerror(GLib2.Error** error=null) {
      return g_dbus_message_to_gerror(&this, error);
   }
}

// Enumeration used to describe the byte order of a D-Bus message.
enum DBusMessageByteOrder /* Version 2.26 */ {
   BIG_ENDIAN = 66,
   LITTLE_ENDIAN = 108
}

// Signature for function used in g_dbus_connection_add_filter().
// 
// A filter function is passed a #GDBusMessage and expected to return
// a #GDBusMessage too. Passive filter functions that don't modify the
// message can simply return the @message object:
// |[
// static GDBusMessage *
// passive_filter (GDBusConnection *connection
// GDBusMessage    *message,
// gboolean         incoming,
// gpointer         user_data)
// {
// /<!-- -->* inspect @message *<!-- -->/
// return message;
// }
// ]|
// Filter functions that wants to drop a message can simply return %NULL:
// |[
// static GDBusMessage *
// drop_filter (GDBusConnection *connection
// GDBusMessage    *message,
// gboolean         incoming,
// gpointer         user_data)
// {
// if (should_drop_message)
// {
// g_object_unref (message);
// message = NULL;
// }
// return message;
// }
// ]|
// Finally, a filter function may modify a message by copying it:
// |[
// static GDBusMessage *
// modifying_filter (GDBusConnection *connection
// GDBusMessage    *message,
// gboolean         incoming,
// gpointer         user_data)
// {
// GDBusMessage *copy;
// GError *error;
// 
// error = NULL;
// copy = g_dbus_message_copy (message, &error);
// /<!-- -->* handle @error being is set *<!-- -->/
// g_object_unref (message);
// 
// /<!-- -->* modify @copy *<!-- -->/
// 
// return copy;
// }
// ]|
// If the returned #GDBusMessage is different from @message and cannot
// be sent on @connection (it could use features, such as file
// descriptors, not compatible with @connection), then a warning is
// logged to <emphasis>standard error</emphasis>. Applications can
// check this ahead of time using g_dbus_message_to_blob() passing a
// #GDBusCapabilityFlags value obtained from @connection.
// 
// g_object_unref() or %NULL to drop the message. Passive filter
// functions can simply return the passed @message object.
// RETURNS: A #GDBusMessage that will be freed with
// <connection>: A #GDBusConnection.
// <message>: A locked #GDBusMessage that the filter function takes ownership of.
// <incoming>: %TRUE if it is a message received from the other peer, %FALSE if it is a message to be sent to the other peer.
// <user_data>: User data passed when adding the filter.
extern (C) alias DBusMessage* /*new*/ function (DBusConnection* connection, DBusMessage* message, int incoming, void* user_data) DBusMessageFilterFunction;

// Message flags used in #GDBusMessage.
enum DBusMessageFlags /* Version 2.26 */ {
   NONE = 0,
   NO_REPLY_EXPECTED = 1,
   NO_AUTO_START = 2
}
// Header fields used in #GDBusMessage.
enum DBusMessageHeaderField /* Version 2.26 */ {
   INVALID = 0,
   PATH = 1,
   INTERFACE = 2,
   MEMBER = 3,
   ERROR_NAME = 4,
   REPLY_SERIAL = 5,
   DESTINATION = 6,
   SENDER = 7,
   SIGNATURE = 8,
   NUM_UNIX_FDS = 9
}
// Message types used in #GDBusMessage.
enum DBusMessageType /* Version 2.26 */ {
   INVALID = 0,
   METHOD_CALL = 1,
   METHOD_RETURN = 2,
   ERROR = 3,
   SIGNAL = 4
}
// Information about a method on an D-Bus interface.
struct DBusMethodInfo /* Version 2.26 */ {
   int ref_count;
   char* name;
   DBusArgInfo*[666] in_args, out_args;
   DBusAnnotationInfo*[666] annotations;


   // If @info is statically allocated does nothing. Otherwise increases
   // the reference count.
   // RETURNS: The same @info.
   DBusMethodInfo* /*new*/ ref_() {
      return g_dbus_method_info_ref(&this);
   }

   // If @info is statically allocated, does nothing. Otherwise decreases
   // the reference count of @info. When its reference count drops to 0,
   // the memory used is freed.
   void unref() {
      g_dbus_method_info_unref(&this);
   }
}


// Instances of the #GDBusMethodInvocation class are used when
// handling D-Bus method calls. It provides a way to asynchronously
// return results and errors.
// 
// The normal way to obtain a #GDBusMethodInvocation object is to receive
// it as an argument to the handle_method_call() function in a
// #GDBusInterfaceVTable that was passed to g_dbus_connection_register_object().
struct DBusMethodInvocation /* : GObject.Object */ /* Version 2.26 */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Gets the #GDBusConnection the method was invoked on.
   // RETURNS: A #GDBusConnection. Do not free, it is owned by @invocation.
   DBusConnection* get_connection() {
      return g_dbus_method_invocation_get_connection(&this);
   }

   // Gets the name of the D-Bus interface the method was invoked on.
   // RETURNS: A string. Do not free, it is owned by @invocation.
   char* get_interface_name() {
      return g_dbus_method_invocation_get_interface_name(&this);
   }

   // Gets the #GDBusMessage for the method invocation. This is useful if
   // you need to use low-level protocol features, such as UNIX file
   // descriptor passing, that cannot be properly expressed in the
   // #GVariant API.
   // 
   // See <xref linkend="gdbus-server"/> and <xref
   // linkend="gdbus-unix-fd-client"/> for an example of how to use this
   // low-level API to send and receive UNIX file descriptors.
   // RETURNS: #GDBusMessage. Do not free, it is owned by @invocation.
   DBusMessage* get_message() {
      return g_dbus_method_invocation_get_message(&this);
   }

   // Gets information about the method call, if any.
   // RETURNS: A #GDBusMethodInfo or %NULL. Do not free, it is owned by @invocation.
   DBusMethodInfo* get_method_info() {
      return g_dbus_method_invocation_get_method_info(&this);
   }

   // Gets the name of the method that was invoked.
   // RETURNS: A string. Do not free, it is owned by @invocation.
   char* get_method_name() {
      return g_dbus_method_invocation_get_method_name(&this);
   }

   // Gets the object path the method was invoked on.
   // RETURNS: A string. Do not free, it is owned by @invocation.
   char* get_object_path() {
      return g_dbus_method_invocation_get_object_path(&this);
   }

   // Gets the parameters of the method invocation. If there are no input
   // parameters then this will return a GVariant with 0 children rather than NULL.
   // RETURNS: A #GVariant tuple. Do not unref this because it is owned by @invocation.
   GLib2.Variant* get_parameters() {
      return g_dbus_method_invocation_get_parameters(&this);
   }

   // Gets the bus name that invoked the method.
   // RETURNS: A string. Do not free, it is owned by @invocation.
   char* get_sender() {
      return g_dbus_method_invocation_get_sender(&this);
   }

   // Unintrospectable method: get_user_data() / g_dbus_method_invocation_get_user_data()
   // Gets the @user_data #gpointer passed to g_dbus_connection_register_object().
   // RETURNS: A #gpointer.
   void* get_user_data() {
      return g_dbus_method_invocation_get_user_data(&this);
   }

   // Finishes handling a D-Bus method call by returning an error.
   // 
   // This method will free @invocation, you cannot use it afterwards.
   // <error_name>: A valid D-Bus error name.
   // <error_message>: A valid D-Bus error message.
   void return_dbus_error(char* error_name, char* error_message) {
      g_dbus_method_invocation_return_dbus_error(&this, error_name, error_message);
   }

   // Unintrospectable method: return_error() / g_dbus_method_invocation_return_error()
   // Finishes handling a D-Bus method call by returning an error.
   // 
   // See g_dbus_error_encode_gerror() for details about what error name
   // will be returned on the wire. In a nutshell, if the given error is
   // registered using g_dbus_error_register_error() the name given
   // during registration is used. Otherwise, a name of the form
   // <literal>org.gtk.GDBus.UnmappedGError.Quark...</literal> is
   // used. This provides transparent mapping of #GError between
   // applications using GDBus.
   // 
   // If you are writing an application intended to be portable,
   // <emphasis>always</emphasis> register errors with g_dbus_error_register_error()
   // or use g_dbus_method_invocation_return_dbus_error().
   // 
   // This method will free @invocation, you cannot use it afterwards.
   // <domain>: A #GQuark for the #GError error domain.
   // <code>: The error code.
   // <format>: printf()-style format.
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_dbus_method_invocation_return_error return_error; // Variadic
   +/

   // Like g_dbus_method_invocation_return_error() but without printf()-style formatting.
   // 
   // This method will free @invocation, you cannot use it afterwards.
   // <domain>: A #GQuark for the #GError error domain.
   // <code>: The error code.
   // <message>: The error message.
   void return_error_literal(GLib2.Quark domain, int code, char* message) {
      g_dbus_method_invocation_return_error_literal(&this, domain, code, message);
   }

   // Unintrospectable method: return_error_valist() / g_dbus_method_invocation_return_error_valist()
   // Like g_dbus_method_invocation_return_error() but intended for
   // language bindings.
   // 
   // This method will free @invocation, you cannot use it afterwards.
   // <domain>: A #GQuark for the #GError error domain.
   // <code>: The error code.
   // <format>: printf()-style format.
   // <var_args>: #va_list of parameters for @format.
   void return_error_valist(GLib2.Quark domain, int code, char* format, va_list var_args) {
      g_dbus_method_invocation_return_error_valist(&this, domain, code, format, var_args);
   }

   // Like g_dbus_method_invocation_return_error() but takes a #GError
   // instead of the error domain, error code and message.
   // 
   // This method will free @invocation, you cannot use it afterwards.
   // <error>: A #GError.
   void return_gerror(GLib2.Error* error) {
      g_dbus_method_invocation_return_gerror(&this, error);
   }

   // Finishes handling a D-Bus method call by returning @parameters.
   // If the @parameters GVariant is floating, it is consumed.
   // 
   // It is an error if @parameters is not of the right format.
   // 
   // This method will free @invocation, you cannot use it afterwards.
   // <parameters>: A #GVariant tuple with out parameters for the method or %NULL if not passing any parameters.
   void return_value(GLib2.Variant* parameters=null) {
      g_dbus_method_invocation_return_value(&this, parameters);
   }

   // Like g_dbus_method_invocation_return_value() but also takes a #GUnixFDList.
   // 
   // This method is only available on UNIX.
   // 
   // This method will free @invocation, you cannot use it afterwards.
   // <parameters>: A #GVariant tuple with out parameters for the method or %NULL if not passing any parameters.
   // <fd_list>: A #GUnixFDList or %NULL.
   void return_value_with_unix_fd_list(GLib2.Variant* parameters=null, UnixFDList* fd_list=null) {
      g_dbus_method_invocation_return_value_with_unix_fd_list(&this, parameters, fd_list);
   }

   // Unintrospectable method: take_error() / g_dbus_method_invocation_take_error()
   // Like g_dbus_method_invocation_return_gerror() but takes ownership
   // of @error so the caller does not need to free it.
   // 
   // This method will free @invocation, you cannot use it afterwards.
   // <error>: A #GError.
   void take_error(GLib2.Error* error) {
      g_dbus_method_invocation_take_error(&this, error);
   }
}

// Information about nodes in a remote object hierarchy.
struct DBusNodeInfo /* Version 2.26 */ {
   int ref_count;
   char* path;
   DBusInterfaceInfo*[666] interfaces;
   DBusNodeInfo*[666] nodes;
   DBusAnnotationInfo*[666] annotations;


   // Parses @xml_data and returns a #GDBusNodeInfo representing the data.
   // 
   // with g_dbus_node_info_unref().
   // RETURNS: A #GDBusNodeInfo structure or %NULL if @error is set. Free
   // <xml_data>: Valid D-Bus introspection XML.
   static DBusNodeInfo* /*new*/ new_for_xml(char* xml_data, GLib2.Error** error=null) {
      return g_dbus_node_info_new_for_xml(xml_data, error);
   }

   // Appends an XML representation of @info (and its children) to @string_builder.
   // 
   // This function is typically used for generating introspection XML documents at run-time for
   // handling the <literal>org.freedesktop.DBus.Introspectable.Introspect</literal> method.
   // <indent>: Indentation level.
   // <string_builder>: A #GString to to append XML data to.
   void generate_xml(uint indent, /*out*/ GLib2.String* string_builder) {
      g_dbus_node_info_generate_xml(&this, indent, string_builder);
   }

   // Looks up information about an interface.
   // 
   // This cost of this function is O(n) in number of interfaces.
   // RETURNS: A #GDBusInterfaceInfo or %NULL if not found. Do not free, it is owned by @info.
   // <name>: A D-Bus interface name.
   DBusInterfaceInfo* lookup_interface(char* name) {
      return g_dbus_node_info_lookup_interface(&this, name);
   }

   // If @info is statically allocated does nothing. Otherwise increases
   // the reference count.
   // RETURNS: The same @info.
   DBusNodeInfo* /*new*/ ref_() {
      return g_dbus_node_info_ref(&this);
   }

   // If @info is statically allocated, does nothing. Otherwise decreases
   // the reference count of @info. When its reference count drops to 0,
   // the memory used is freed.
   void unref() {
      g_dbus_node_info_unref(&this);
   }
}


// The #GDBusObject type is the base type for D-Bus objects on both
// the service side (see #GDBusObjectSkeleton) and the client side
// (see #GDBusObjectProxy). It is essentially just a container of
// interfaces.
struct DBusObject {

   // Gets the D-Bus interface with name @interface_name associated with
   // @object, if any.
   // 
   // #GDBusInterface that must be freed with g_object_unref().
   // RETURNS: %NULL if not found, otherwise a
   // <interface_name>: A D-Bus interface name.
   DBusInterface* /*new*/ get_interface(char* interface_name) {
      return g_dbus_object_get_interface(&this, interface_name);
   }

   // Gets the D-Bus interfaces associated with @object.
   // 
   // The returned list must be freed by g_list_free() after each element has been freed
   // with g_object_unref().
   // RETURNS: A list of #GDBusInterface instances.
   GLib2.List* /*new*/ get_interfaces() {
      return g_dbus_object_get_interfaces(&this);
   }

   // Gets the object path for @object.
   // RETURNS: A string owned by @object. Do not free.
   char* get_object_path() {
      return g_dbus_object_get_object_path(&this);
   }

   // Emitted when @interface is added to @object.
   // <interface>: The #GDBusInterface that was added.
   extern (C) alias static void function (DBusObject* this_, DBusInterface* interface_, void* user_data=null) signal_interface_added;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"interface-added", CB:signal_interface_added)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"interface-added",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when @interface is removed from @object.
   // <interface>: The #GDBusInterface that was removed.
   extern (C) alias static void function (DBusObject* this_, DBusInterface* interface_, void* user_data=null) signal_interface_removed;
   ulong signal_connect(string name:"interface-removed", CB:signal_interface_removed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"interface-removed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

// Base object type for D-Bus objects.
struct DBusObjectIface /* Version 2.30 */ {
   GObject2.TypeInterface parent_iface;
   // RETURNS: A string owned by @object. Do not free.
   extern (C) char* function (DBusObject* object) get_object_path;
   // RETURNS: A list of #GDBusInterface instances.
   extern (C) GLib2.List* /*new*/ function (DBusObject* object) get_interfaces;

   // RETURNS: %NULL if not found, otherwise a
   // <interface_name>: A D-Bus interface name.
   extern (C) DBusInterface* /*new*/ function (DBusObject* object, char* interface_name) get_interface;
   extern (C) void function (DBusObject* object, DBusInterface* interface_) interface_added;
   extern (C) void function (DBusObject* object, DBusInterface* interface_) interface_removed;
}


// The #GDBusObjectManager type is the base type for service- and
// client-side implementations of the standardized <ulink
// url="http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager">org.freedesktop.DBus.ObjectManager</ulink>
// interface.
// 
// See #GDBusObjectManagerClient for the client-side implementation
// and #GDBusObjectManagerServer for the service-side implementation.
struct DBusObjectManager {

   // Gets the interface proxy for @interface_name at @object_path, if
   // any.
   // 
   // with g_object_unref().
   // RETURNS: A #GDBusInterface instance or %NULL. Free
   // <object_path>: Object path to lookup.
   // <interface_name>: D-Bus interface name to lookup.
   DBusInterface* /*new*/ get_interface(char* object_path, char* interface_name) {
      return g_dbus_object_manager_get_interface(&this, object_path, interface_name);
   }

   // Gets the #GDBusObjectProxy at @object_path, if any.
   // 
   // g_object_unref().
   // RETURNS: A #GDBusObject or %NULL. Free with
   // <object_path>: Object path to lookup.
   DBusObject* /*new*/ get_object(char* object_path) {
      return g_dbus_object_manager_get_object(&this, object_path);
   }

   // Gets the object path that @manager is for.
   // RETURNS: A string owned by @manager. Do not free.
   char* get_object_path() {
      return g_dbus_object_manager_get_object_path(&this);
   }

   // Gets all #GDBusObject objects known to @manager.
   // 
   // #GDBusObject objects. The returned list should be freed with
   // g_list_free() after each element has been freed with
   // g_object_unref().
   // RETURNS: A list of
   GLib2.List* /*new*/ get_objects() {
      return g_dbus_object_manager_get_objects(&this);
   }

   // Emitted when @interface is added to @object.
   // 
   // This signal exists purely as a convenience to avoid having to
   // connect signals to all objects managed by @manager.
   // <object>: The #GDBusObject on which an interface was added.
   // <interface>: The #GDBusInterface that was added.
   extern (C) alias static void function (DBusObjectManager* this_, DBusObject* object, DBusInterface* interface_, void* user_data=null) signal_interface_added;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"interface-added", CB:signal_interface_added)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"interface-added",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when @interface has been removed from @object.
   // 
   // This signal exists purely as a convenience to avoid having to
   // connect signals to all objects managed by @manager.
   // <object>: The #GDBusObject on which an interface was removed.
   // <interface>: The #GDBusInterface that was removed.
   extern (C) alias static void function (DBusObjectManager* this_, DBusObject* object, DBusInterface* interface_, void* user_data=null) signal_interface_removed;
   ulong signal_connect(string name:"interface-removed", CB:signal_interface_removed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"interface-removed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when @object is added to @manager.
   // <object>: The #GDBusObject that was added.
   extern (C) alias static void function (DBusObjectManager* this_, DBusObject* object, void* user_data=null) signal_object_added;
   ulong signal_connect(string name:"object-added", CB:signal_object_added)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"object-added",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when @object is removed from @manager.
   // <object>: The #GDBusObject that was removed.
   extern (C) alias static void function (DBusObjectManager* this_, DBusObject* object, void* user_data=null) signal_object_removed;
   ulong signal_connect(string name:"object-removed", CB:signal_object_removed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"object-removed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}


// #GDBusObjectManagerClient is used to create, monitor and delete object
// proxies for remote objects exported by a #GDBusObjectManagerServer (or any
// code implementing the <ulink
// url="http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager">org.freedesktop.DBus.ObjectManager</ulink>
// interface).
// 
// Once an instance of this type has been created, you can connect to
// the #GDBusObjectManager::object-added and
// #GDBusObjectManager::object-removed signals and inspect the
// #GDBusObjectProxy objects returned by
// g_dbus_object_manager_get_objects().
// 
// If the name for a #GDBusObjectManagerClient is not owned by anyone at
// object construction time, the default behavior is to request the
// message bus to launch an owner for the name. This behavior can be
// disabled using the %G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START
// flag. It's also worth noting that this only works if the name of
// interest is activatable in the first place. E.g. in some cases it
// is not possible to launch an owner for the requested name. In this
// case, #GDBusObjectManagerClient object construction still succeeds but
// there will be no object proxies
// (e.g. g_dbus_object_manager_get_objects() returns the empty list) and
// the #GDBusObjectManagerClient:name-owner property is %NULL.
// 
// The owner of the requested name can come and go (for example
// consider a system service being restarted) – #GDBusObjectManagerClient
// handles this case too; simply connect to the #GObject::notify
// signal to watch for changes on the #GDBusObjectManagerClient:name-owner
// property. When the name owner vanishes, the behavior is that
// #GDBusObjectManagerClient:name-owner is set to %NULL (this includes
// emission of the #GObject::notify signal) and then
// #GDBusObjectManager::object-removed signals are synthesized
// for all currently existing object proxies. Since
// #GDBusObjectManagerClient:name-owner is %NULL when this happens, you can
// use this information to disambiguate a synthesized signal from a
// genuine signal caused by object removal on the remote
// #GDBusObjectManager. Similarly, when a new name owner appears,
// #GDBusObjectManager::object-added signals are synthesized
// while #GDBusObjectManagerClient:name-owner is still %NULL. Only when all
// object proxies have been added, the #GDBusObjectManagerClient:name-owner
// is set to the new name owner (this includes emission of the
// #GObject::notify signal).  Furthermore, you are guaranteed that
// #GDBusObjectManagerClient:name-owner will alternate between a name owner
// (e.g. <literal>:1.42</literal>) and %NULL even in the case where
// the name of interest is atomically replaced
// 
// Ultimately, #GDBusObjectManagerClient is used to obtain #GDBusProxy
// instances. All signals (including the
// <literal>org.freedesktop.DBus.Properties::PropertiesChanged</literal>
// signal) delivered to #GDBusProxy instances are guaranteed to
// originate from the name owner. This guarantee along with the
// behavior described above, means that certain race conditions
// including the <emphasis><quote>half the proxy is from the old owner
// and the other half is from the new owner</quote></emphasis> problem
// cannot happen.
// 
// To avoid having the application connect to signals on the returned
// #GDBusObjectProxy and #GDBusProxy objects, the
// #GDBusObject::interface-added,
// #GDBusObject::interface-removed,
// #GDBusProxy::g-properties-changed and
// #GDBusProxy::g-signal signals
// are also emitted on the #GDBusObjectManagerClient instance managing these
// objects. The signals emitted are
// #GDBusObjectManager::interface-added,
// #GDBusObjectManager::interface-removed,
// #GDBusObjectManagerClient::interface-proxy-properties-changed and
// #GDBusObjectManagerClient::interface-proxy-signal.
// 
// Note that all callbacks and signals are emitted in the
// <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
// that the #GDBusObjectManagerClient object was constructed
// in. Additionally, the #GDBusObjectProxy and #GDBusProxy objects
// originating from the #GDBusObjectManagerClient object will be created in
// the same context and, consequently, will deliver signals in the
// same main loop.
struct DBusObjectManagerClient /* : GObject.Object */ /* Version 2.30 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private DBusObjectManagerClientPrivate* priv;


   // Finishes an operation started with g_dbus_object_manager_client_new().
   // 
   // #GDBusObjectManagerClient object or %NULL if @error is set. Free
   // with g_object_unref().
   // RETURNS: A
   // <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_object_manager_client_new().
   static DBusObjectManagerClient* /*new*/ new_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_dbus_object_manager_client_new_finish(res, error);
   }

   // Finishes an operation started with g_dbus_object_manager_client_new_for_bus().
   // 
   // #GDBusObjectManagerClient object or %NULL if @error is set. Free
   // with g_object_unref().
   // RETURNS: A
   // <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_object_manager_client_new_for_bus().
   static DBusObjectManagerClient* /*new*/ new_for_bus_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_dbus_object_manager_client_new_for_bus_finish(res, error);
   }

   // Like g_dbus_object_manager_client_new_sync() but takes a #GBusType instead
   // of a #GDBusConnection.
   // 
   // This is a synchronous failable constructor - the calling thread is
   // blocked until a reply is received. See g_dbus_object_manager_client_new_for_bus()
   // for the asynchronous version.
   // 
   // #GDBusObjectManagerClient object or %NULL if @error is set. Free
   // with g_object_unref().
   // RETURNS: A
   // <bus_type>: A #GBusType.
   // <flags>: Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
   // <name>: The owner of the control object (unique or well-known name).
   // <object_path>: The object path of the control object.
   // <get_proxy_type_func>: A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
   // <get_proxy_type_user_data>: User data to pass to @get_proxy_type_func.
   // <get_proxy_type_destroy_notify>: Free function for @get_proxy_type_user_data or %NULL.
   // <cancellable>: A #GCancellable or %NULL
   static DBusObjectManagerClient* /*new*/ new_for_bus_sync(BusType bus_type, DBusObjectManagerClientFlags flags, char* name, char* object_path, DBusProxyTypeFunc get_proxy_type_func, void* get_proxy_type_user_data, GLib2.DestroyNotify get_proxy_type_destroy_notify, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_object_manager_client_new_for_bus_sync(bus_type, flags, name, object_path, get_proxy_type_func, get_proxy_type_user_data, get_proxy_type_destroy_notify, cancellable, error);
   }

   // Creates a new #GDBusObjectManagerClient object.
   // 
   // This is a synchronous failable constructor - the calling thread is
   // blocked until a reply is received. See g_dbus_object_manager_client_new()
   // for the asynchronous version.
   // 
   // #GDBusObjectManagerClient object or %NULL if @error is set. Free
   // with g_object_unref().
   // RETURNS: A
   // <connection>: A #GDBusConnection.
   // <flags>: Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
   // <name>: The owner of the control object (unique or well-known name).
   // <object_path>: The object path of the control object.
   // <get_proxy_type_func>: A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
   // <get_proxy_type_user_data>: User data to pass to @get_proxy_type_func.
   // <get_proxy_type_destroy_notify>: Free function for @get_proxy_type_user_data or %NULL.
   // <cancellable>: A #GCancellable or %NULL
   static DBusObjectManagerClient* /*new*/ new_sync(DBusConnection* connection, DBusObjectManagerClientFlags flags, char* name, char* object_path, DBusProxyTypeFunc get_proxy_type_func, void* get_proxy_type_user_data, GLib2.DestroyNotify get_proxy_type_destroy_notify, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_object_manager_client_new_sync(connection, flags, name, object_path, get_proxy_type_func, get_proxy_type_user_data, get_proxy_type_destroy_notify, cancellable, error);
   }

   // Asynchronously creates a new #GDBusObjectManagerClient object.
   // 
   // This is an asynchronous failable constructor. When the result is
   // ready, @callback will be invoked in the
   // <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
   // of the thread you are calling this method from. You can
   // then call g_dbus_object_manager_client_new_finish() to get the result. See
   // g_dbus_object_manager_client_new_sync() for the synchronous version.
   // <connection>: A #GDBusConnection.
   // <flags>: Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
   // <name>: The owner of the control object (unique or well-known name).
   // <object_path>: The object path of the control object.
   // <get_proxy_type_func>: A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
   // <get_proxy_type_user_data>: User data to pass to @get_proxy_type_func.
   // <get_proxy_type_destroy_notify>: Free function for @get_proxy_type_user_data or %NULL.
   // <cancellable>: A #GCancellable or %NULL
   // <callback>: A #GAsyncReadyCallback to call when the request is satisfied.
   // <user_data>: The data to pass to @callback.
   static void new_(DBusConnection* connection, DBusObjectManagerClientFlags flags, char* name, char* object_path, DBusProxyTypeFunc get_proxy_type_func, void* get_proxy_type_user_data, GLib2.DestroyNotify get_proxy_type_destroy_notify, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_dbus_object_manager_client_new(connection, flags, name, object_path, get_proxy_type_func, get_proxy_type_user_data, get_proxy_type_destroy_notify, cancellable, callback, user_data);
   }

   // Like g_dbus_object_manager_client_new() but takes a #GBusType instead of a
   // #GDBusConnection.
   // 
   // This is an asynchronous failable constructor. When the result is
   // ready, @callback will be invoked in the
   // <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
   // of the thread you are calling this method from. You can
   // then call g_dbus_object_manager_client_new_for_bus_finish() to get the result. See
   // g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.
   // <bus_type>: A #GBusType.
   // <flags>: Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
   // <name>: The owner of the control object (unique or well-known name).
   // <object_path>: The object path of the control object.
   // <get_proxy_type_func>: A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
   // <get_proxy_type_user_data>: User data to pass to @get_proxy_type_func.
   // <get_proxy_type_destroy_notify>: Free function for @get_proxy_type_user_data or %NULL.
   // <cancellable>: A #GCancellable or %NULL
   // <callback>: A #GAsyncReadyCallback to call when the request is satisfied.
   // <user_data>: The data to pass to @callback.
   static void new_for_bus(BusType bus_type, DBusObjectManagerClientFlags flags, char* name, char* object_path, DBusProxyTypeFunc get_proxy_type_func, void* get_proxy_type_user_data, GLib2.DestroyNotify get_proxy_type_destroy_notify, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_dbus_object_manager_client_new_for_bus(bus_type, flags, name, object_path, get_proxy_type_func, get_proxy_type_user_data, get_proxy_type_destroy_notify, cancellable, callback, user_data);
   }

   // Gets the #GDBusConnection used by @manager.
   // 
   // the object belongs to @manager.
   // RETURNS: A #GDBusConnection object. Do not free,
   DBusConnection* get_connection() {
      return g_dbus_object_manager_client_get_connection(&this);
   }

   // Gets the flags that @manager was constructed with.
   // 
   // enumeration.
   // RETURNS: Zero of more flags from the #GDBusObjectManagerClientFlags
   DBusObjectManagerClientFlags get_flags() {
      return g_dbus_object_manager_client_get_flags(&this);
   }

   // Gets the name that @manager is for.
   // 
   // belongs to @manager.
   // RETURNS: A unique or well-known name. Do not free, the string
   char* get_name() {
      return g_dbus_object_manager_client_get_name(&this);
   }

   // The unique name that owns the name that @manager is for or %NULL if
   // no-one currently owns that name. You can connect to the
   // #GObject::notify signal to track changes to the
   // #GDBusObjectManagerClient:name-owner property.
   // 
   // g_free().
   // RETURNS: The name owner or %NULL if no name owner exists. Free with
   char* /*new*/ get_name_owner() {
      return g_dbus_object_manager_client_get_name_owner(&this);
   }

   // Emitted when one or more D-Bus properties on proxy changes. The
   // local cache has already been updated when this signal fires. Note
   // that both @changed_properties and @invalidated_properties are
   // guaranteed to never be %NULL (either may be empty though).
   // 
   // This signal exists purely as a convenience to avoid having to
   // connect signals to all interface proxies managed by @manager.
   // 
   // This signal is emitted in the
   // <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
   // that @manager was constructed in.
   // <object_proxy>: The #GDBusObjectProxy on which an interface has properties that are changing.
   // <interface_proxy>: The #GDBusProxy that has properties that are changing.
   // <changed_properties>: A #GVariant containing the properties that changed.
   // <invalidated_properties>: A %NULL terminated array of properties that was invalidated.
   extern (C) alias static void function (DBusObjectManagerClient* this_, DBusObjectProxy* object_proxy, DBusProxy* interface_proxy, GLib2.Variant* changed_properties, char* invalidated_properties, void* user_data=null) signal_interface_proxy_properties_changed;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"interface-proxy-properties-changed", CB:signal_interface_proxy_properties_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"interface-proxy-properties-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when a D-Bus signal is received on @interface_proxy.
   // 
   // This signal exists purely as a convenience to avoid having to
   // connect signals to all interface proxies managed by @manager.
   // 
   // This signal is emitted in the
   // <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
   // that @manager was constructed in.
   // <object_proxy>: The #GDBusObjectProxy on which an interface is emitting a D-Bus signal.
   // <interface_proxy>: The #GDBusProxy that is emitting a D-Bus signal.
   // <sender_name>: The sender of the signal or NULL if the connection is not a bus connection.
   // <signal_name>: The signal name.
   // <parameters>: A #GVariant tuple with parameters for the signal.
   extern (C) alias static void function (DBusObjectManagerClient* this_, DBusObjectProxy* object_proxy, DBusProxy* interface_proxy, char* sender_name, char* signal_name, GLib2.Variant* parameters, void* user_data=null) signal_interface_proxy_signal;
   ulong signal_connect(string name:"interface-proxy-signal", CB:signal_interface_proxy_signal)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"interface-proxy-signal",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

// Class structure for #GDBusObjectManagerClient.
struct DBusObjectManagerClientClass /* Version 2.30 */ {
   GObject2.ObjectClass parent_class;
   extern (C) void function (DBusObjectManagerClient* manager, DBusObjectProxy* object_proxy, DBusProxy* interface_proxy, char* sender_name, char* signal_name, GLib2.Variant* parameters) interface_proxy_signal;
   extern (C) void function (DBusObjectManagerClient* manager, DBusObjectProxy* object_proxy, DBusProxy* interface_proxy, GLib2.Variant* changed_properties, char** invalidated_properties) interface_proxy_properties_changed;
   private void*[8] padding;
}

// Flags used when constructing a #GDBusObjectManagerClient.
enum DBusObjectManagerClientFlags /* Version 2.30 */ {
   NONE = 0,
   DO_NOT_AUTO_START = 1
}
struct DBusObjectManagerClientPrivate {
}

// Base type for D-Bus object managers.
struct DBusObjectManagerIface /* Version 2.30 */ {
   GObject2.TypeInterface parent_iface;
   // RETURNS: A string owned by @manager. Do not free.
   extern (C) char* function (DBusObjectManager* manager) get_object_path;
   // RETURNS: A list of
   extern (C) GLib2.List* /*new*/ function (DBusObjectManager* manager) get_objects;

   // RETURNS: A #GDBusObject or %NULL. Free with
   // <object_path>: Object path to lookup.
   extern (C) DBusObject* /*new*/ function (DBusObjectManager* manager, char* object_path) get_object;

   // RETURNS: A #GDBusInterface instance or %NULL. Free
   // <object_path>: Object path to lookup.
   // <interface_name>: D-Bus interface name to lookup.
   extern (C) DBusInterface* /*new*/ function (DBusObjectManager* manager, char* object_path, char* interface_name) get_interface;
   extern (C) void function (DBusObjectManager* manager, DBusObject* object) object_added;
   extern (C) void function (DBusObjectManager* manager, DBusObject* object) object_removed;
   extern (C) void function (DBusObjectManager* manager, DBusObject* object, DBusInterface* interface_) interface_added;
   extern (C) void function (DBusObjectManager* manager, DBusObject* object, DBusInterface* interface_) interface_removed;
}


// #GDBusObjectManagerServer is used to export #GDBusObject instances using
// the standardized <ulink
// url="http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager">org.freedesktop.DBus.ObjectManager</ulink>
// interface. For example, remote D-Bus clients can get all objects
// and properties in a single call. Additionally, any change in the
// object hierarchy is broadcast using signals. This means that D-Bus
// clients can keep caches up to date by only listening to D-Bus
// signals.
// 
// See #GDBusObjectManagerClient for the client-side code that is
// intended to be used with #GDBusObjectManagerServer or any D-Bus
// object implementing the org.freedesktop.DBus.ObjectManager
// interface.
struct DBusObjectManagerServer /* : GObject.Object */ /* Version 2.30 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private DBusObjectManagerServerPrivate* priv;


   // Creates a new #GDBusObjectManagerServer object.
   // 
   // The returned server isn't yet exported on any connection. To do so,
   // use g_dbus_object_manager_server_set_connection(). Normally you
   // want to export all of your objects before doing so to avoid <ulink
   // url="http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager">InterfacesAdded</ulink>
   // signals being emitted.
   // RETURNS: A #GDBusObjectManagerServer object. Free with g_object_unref().
   // <object_path>: The object path to export the manager object at.
   static DBusObjectManagerServer* /*new*/ new_(char* object_path) {
      return g_dbus_object_manager_server_new(object_path);
   }

   // Exports @object on @manager.
   // 
   // If there is already a #GDBusObject exported at the object path,
   // then the old object is removed.
   // 
   // The object path for @object must be in the hierarchy rooted by the
   // object path for @manager.
   // 
   // Note that @manager will take a reference on @object for as long as
   // it is exported.
   // <object>: A #GDBusObjectSkeleton.
   void export_(DBusObjectSkeleton* object) {
      g_dbus_object_manager_server_export(&this, object);
   }

   // Like g_dbus_object_manager_server_export() but appends a string of
   // the form <literal>_N</literal> (with N being a natural number) to
   // @object<!-- -->'s object path if an object with the given path
   // already exists. As such, the #GDBusObjectProxy:object-path property
   // of @object may be modified.
   // <object>: An object.
   void export_uniquely(DBusObjectSkeleton* object) {
      g_dbus_object_manager_server_export_uniquely(&this, object);
   }

   // Gets the #GDBusConnection used by @manager.
   // 
   // @manager isn't exported on a connection. The returned object should
   // be freed with g_object_unref().
   // RETURNS: A #GDBusConnection object or %NULL if
   DBusConnection* /*new*/ get_connection() {
      return g_dbus_object_manager_server_get_connection(&this);
   }

   // Exports all objects managed by @manager on @connection. If
   // @connection is %NULL, stops exporting objects.
   // <connection>: A #GDBusConnection or %NULL.
   void set_connection(DBusConnection* connection=null) {
      g_dbus_object_manager_server_set_connection(&this, connection);
   }

   // If @manager has an object at @path, removes the object. Otherwise
   // does nothing.
   // 
   // Note that @object_path must be in the hierarchy rooted by the
   // object path for @manager.
   // RETURNS: %TRUE if object at @object_path was removed, %FALSE otherwise.
   // <object_path>: An object path.
   int unexport(char* object_path) {
      return g_dbus_object_manager_server_unexport(&this, object_path);
   }
}

// Class structure for #GDBusObjectManagerServer.
struct DBusObjectManagerServerClass /* Version 2.30 */ {
   GObject2.ObjectClass parent_class;
   private void*[8] padding;
}

struct DBusObjectManagerServerPrivate {
}


// A #GDBusObjectProxy is an object used to represent a remote object
// with one or more D-Bus interfaces. Normally, you don't instantiate
// a #GDBusObjectProxy yourself - typically #GDBusObjectManagerClient
// is used to obtain it.
struct DBusObjectProxy /* : GObject.Object */ /* Version 2.30 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private DBusObjectProxyPrivate* priv;


   // Creates a new #GDBusObjectProxy for the given connection and
   // object path.
   // RETURNS: a new #GDBusObjectProxy
   // <connection>: a #GDBusConnection
   // <object_path>: the object path
   static DBusObjectProxy* /*new*/ new_(DBusConnection* connection, char* object_path) {
      return g_dbus_object_proxy_new(connection, object_path);
   }

   // Gets the connection that @proxy is for.
   // 
   // object is owned by @proxy.
   // RETURNS: A #GDBusConnection. Do not free, the
   DBusConnection* get_connection() {
      return g_dbus_object_proxy_get_connection(&this);
   }
}

// Class structure for #GDBusObjectProxy.
struct DBusObjectProxyClass /* Version 2.30 */ {
   GObject2.ObjectClass parent_class;
   private void*[8] padding;
}

struct DBusObjectProxyPrivate {
}


// A #GDBusObjectSkeleton instance is essentially a group of D-Bus
// interfaces. The set of exported interfaces on the object may be
// dynamic and change at runtime.
// 
// This type is intended to be used with #GDBusObjectManager.
struct DBusObjectSkeleton /* : GObject.Object */ /* Version 2.30 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private DBusObjectSkeletonPrivate* priv;


   // Creates a new #GDBusObjectSkeleton.
   // RETURNS: A #GDBusObjectSkeleton. Free with g_object_unref().
   // <object_path>: An object path.
   static DBusObjectSkeleton* /*new*/ new_(char* object_path) {
      return g_dbus_object_skeleton_new(object_path);
   }

   // Adds @interface_ to @object.
   // 
   // If @object already contains a #GDBusInterfaceSkeleton with the same
   // interface name, it is removed before @interface_ is added.
   // 
   // Note that @object takes its own reference on @interface_ and holds
   // it until removed.
   // <interface_>: A #GDBusInterfaceSkeleton.
   void add_interface(DBusInterfaceSkeleton* interface_) {
      g_dbus_object_skeleton_add_interface(&this, interface_);
   }

   // This method simply calls g_dbus_interface_skeleton_flush() on all
   // interfaces belonging to @object. See that method for when flushing
   // is useful.
   void flush() {
      g_dbus_object_skeleton_flush(&this);
   }

   // Removes @interface_ from @object.
   // <interface_>: A #GDBusInterfaceSkeleton.
   void remove_interface(DBusInterfaceSkeleton* interface_) {
      g_dbus_object_skeleton_remove_interface(&this, interface_);
   }

   // Removes the #GDBusInterface with @interface_name from @object.
   // 
   // If no D-Bus interface of the given interface exists, this function
   // does nothing.
   // <interface_name>: A D-Bus interface name.
   void remove_interface_by_name(char* interface_name) {
      g_dbus_object_skeleton_remove_interface_by_name(&this, interface_name);
   }

   // Sets the object path for @object.
   // <object_path>: A valid D-Bus object path.
   void set_object_path(char* object_path) {
      g_dbus_object_skeleton_set_object_path(&this, object_path);
   }

   // Emitted when a method is invoked by a remote caller and used to
   // determine if the method call is authorized.
   // 
   // This signal is like #GDBusInterfaceSkeleton<!-- -->'s
   // #GDBusInterfaceSkeleton::g-authorize-method signal, except that it is
   // for the enclosing object.
   // 
   // The default class handler just returns %TRUE.
   // RETURNS: %TRUE if the call is authorized, %FALSE otherwise.
   // <interface>: The #GDBusInterfaceSkeleton that @invocation is for.
   // <invocation>: A #GDBusMethodInvocation.
   extern (C) alias static c_int function (DBusObjectSkeleton* this_, DBusInterfaceSkeleton* interface_, DBusMethodInvocation* invocation, void* user_data=null) signal_authorize_method;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"authorize-method", CB:signal_authorize_method)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"authorize-method",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

// Class structure for #GDBusObjectSkeleton.
struct DBusObjectSkeletonClass /* Version 2.30 */ {
   GObject2.ObjectClass parent_class;
   extern (C) int function (DBusObjectSkeleton* object, DBusInterfaceSkeleton* interface_, DBusMethodInvocation* invocation) authorize_method;
   private void*[8] padding;
}

struct DBusObjectSkeletonPrivate {
}

// Information about a D-Bus property on a D-Bus interface.
struct DBusPropertyInfo /* Version 2.26 */ {
   int ref_count;
   char* name, signature;
   DBusPropertyInfoFlags flags;
   DBusAnnotationInfo*[666] annotations;


   // If @info is statically allocated does nothing. Otherwise increases
   // the reference count.
   // RETURNS: The same @info.
   DBusPropertyInfo* /*new*/ ref_() {
      return g_dbus_property_info_ref(&this);
   }

   // If @info is statically allocated, does nothing. Otherwise decreases
   // the reference count of @info. When its reference count drops to 0,
   // the memory used is freed.
   void unref() {
      g_dbus_property_info_unref(&this);
   }
}

// Flags describing the access control of a D-Bus property.
enum DBusPropertyInfoFlags /* Version 2.26 */ {
   NONE = 0,
   READABLE = 1,
   WRITABLE = 2
}

// #GDBusProxy is a base class used for proxies to access a D-Bus
// interface on a remote object. A #GDBusProxy can be constructed for
// both well-known and unique names.
// 
// By default, #GDBusProxy will cache all properties (and listen to
// changes) of the remote object, and proxy all signals that gets
// emitted. This behaviour can be changed by passing suitable
// #GDBusProxyFlags when the proxy is created. If the proxy is for a
// well-known name, the property cache is flushed when the name owner
// vanishes and reloaded when a name owner appears.
// 
// If a #GDBusProxy is used for a well-known name, the owner of the
// name is tracked and can be read from
// #GDBusProxy:g-name-owner. Connect to the #GObject::notify signal to
// get notified of changes. Additionally, only signals and property
// changes emitted from the current name owner are considered and
// calls are always sent to the current name owner. This avoids a
// number of race conditions when the name is lost by one owner and
// claimed by another. However, if no name owner currently exists,
// then calls will be sent to the well-known name which may result in
// the message bus launching an owner (unless
// %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START is set).
// 
// The generic #GDBusProxy::g-properties-changed and
// #GDBusProxy::g-signal signals are not very convenient to work
// with. Therefore, the recommended way of working with proxies is to
// subclass #GDBusProxy, and have more natural properties and signals
// in your derived class. See <xref linkend="gdbus-example-gdbus-codegen"/>
// for how this can easily be done using the
// <command><link linkend="gdbus-codegen">gdbus-codegen</link></command>
// tool.
// 
// A #GDBusProxy instance can be used from multiple threads but note
// that all signals (e.g. #GDBusProxy::g-signal, #GDBusProxy::g-properties-changed
// and #GObject::notify) are emitted in the
// <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
// of the thread where the instance was constructed.
// 
// <example id="gdbus-wellknown-proxy"><title>GDBusProxy for a well-known-name</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-watch-proxy.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
struct DBusProxy /* : GObject.Object */ /* Version 2.26 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private DBusProxyPrivate* priv;


   // Finishes creating a #GDBusProxy.
   // RETURNS: A #GDBusProxy or %NULL if @error is set. Free with g_object_unref().
   // <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback function passed to g_dbus_proxy_new().
   static DBusProxy* /*new*/ new_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_dbus_proxy_new_finish(res, error);
   }

   // Finishes creating a #GDBusProxy.
   // RETURNS: A #GDBusProxy or %NULL if @error is set. Free with g_object_unref().
   // <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback function passed to g_dbus_proxy_new_for_bus().
   static DBusProxy* /*new*/ new_for_bus_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_dbus_proxy_new_for_bus_finish(res, error);
   }

   // Like g_dbus_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
   // 
   // See <xref linkend="gdbus-wellknown-proxy"/> for an example of how #GDBusProxy can be used.
   // RETURNS: A #GDBusProxy or %NULL if error is set. Free with g_object_unref().
   // <bus_type>: A #GBusType.
   // <flags>: Flags used when constructing the proxy.
   // <info>: A #GDBusInterfaceInfo specifying the minimal interface that @proxy conforms to or %NULL.
   // <name>: A bus name (well-known or unique).
   // <object_path>: An object path.
   // <interface_name>: A D-Bus interface name.
   // <cancellable>: A #GCancellable or %NULL.
   static DBusProxy* /*new*/ new_for_bus_sync(BusType bus_type, DBusProxyFlags flags, DBusInterfaceInfo* info, char* name, char* object_path, char* interface_name, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_proxy_new_for_bus_sync(bus_type, flags, info, name, object_path, interface_name, cancellable, error);
   }

   // Creates a proxy for accessing @interface_name on the remote object
   // at @object_path owned by @name at @connection and synchronously
   // loads D-Bus properties unless the
   // %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used.
   // 
   // If the %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up
   // match rules for signals. Connect to the #GDBusProxy::g-signal signal
   // to handle signals from the remote object.
   // 
   // If @name is a well-known name and the
   // %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START flag isn't set and no name
   // owner currently exists, the message bus will be requested to launch
   // a name owner for the name.
   // 
   // This is a synchronous failable constructor. See g_dbus_proxy_new()
   // and g_dbus_proxy_new_finish() for the asynchronous version.
   // 
   // See <xref linkend="gdbus-wellknown-proxy"/> for an example of how #GDBusProxy can be used.
   // RETURNS: A #GDBusProxy or %NULL if error is set. Free with g_object_unref().
   // <connection>: A #GDBusConnection.
   // <flags>: Flags used when constructing the proxy.
   // <info>: A #GDBusInterfaceInfo specifying the minimal interface that @proxy conforms to or %NULL.
   // <name>: A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
   // <object_path>: An object path.
   // <interface_name>: A D-Bus interface name.
   // <cancellable>: A #GCancellable or %NULL.
   static DBusProxy* /*new*/ new_sync(DBusConnection* connection, DBusProxyFlags flags, DBusInterfaceInfo* info, char* name, char* object_path, char* interface_name, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_proxy_new_sync(connection, flags, info, name, object_path, interface_name, cancellable, error);
   }

   // Creates a proxy for accessing @interface_name on the remote object
   // at @object_path owned by @name at @connection and asynchronously
   // loads D-Bus properties unless the
   // %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used. Connect to
   // the #GDBusProxy::g-properties-changed signal to get notified about
   // property changes.
   // 
   // If the %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up
   // match rules for signals. Connect to the #GDBusProxy::g-signal signal
   // to handle signals from the remote object.
   // 
   // If @name is a well-known name and the
   // %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START flag isn't set and no name
   // owner currently exists, the message bus will be requested to launch
   // a name owner for the name.
   // 
   // This is a failable asynchronous constructor - when the proxy is
   // ready, @callback will be invoked and you can use
   // g_dbus_proxy_new_finish() to get the result.
   // 
   // See g_dbus_proxy_new_sync() and for a synchronous version of this constructor.
   // 
   // See <xref linkend="gdbus-wellknown-proxy"/> for an example of how #GDBusProxy can be used.
   // <connection>: A #GDBusConnection.
   // <flags>: Flags used when constructing the proxy.
   // <info>: A #GDBusInterfaceInfo specifying the minimal interface that @proxy conforms to or %NULL.
   // <name>: A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
   // <object_path>: An object path.
   // <interface_name>: A D-Bus interface name.
   // <cancellable>: A #GCancellable or %NULL.
   // <callback>: Callback function to invoke when the proxy is ready.
   // <user_data>: User data to pass to @callback.
   static void new_(DBusConnection* connection, DBusProxyFlags flags, DBusInterfaceInfo* info, char* name, char* object_path, char* interface_name, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_dbus_proxy_new(connection, flags, info, name, object_path, interface_name, cancellable, callback, user_data);
   }

   // Like g_dbus_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
   // 
   // See <xref linkend="gdbus-wellknown-proxy"/> for an example of how #GDBusProxy can be used.
   // <bus_type>: A #GBusType.
   // <flags>: Flags used when constructing the proxy.
   // <info>: A #GDBusInterfaceInfo specifying the minimal interface that @proxy conforms to or %NULL.
   // <name>: A bus name (well-known or unique).
   // <object_path>: An object path.
   // <interface_name>: A D-Bus interface name.
   // <cancellable>: A #GCancellable or %NULL.
   // <callback>: Callback function to invoke when the proxy is ready.
   // <user_data>: User data to pass to @callback.
   static void new_for_bus(BusType bus_type, DBusProxyFlags flags, DBusInterfaceInfo* info, char* name, char* object_path, char* interface_name, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_dbus_proxy_new_for_bus(bus_type, flags, info, name, object_path, interface_name, cancellable, callback, user_data);
   }

   // Asynchronously invokes the @method_name method on @proxy.
   // 
   // If @method_name contains any dots, then @name is split into interface and
   // method name parts. This allows using @proxy for invoking methods on
   // other interfaces.
   // 
   // If the #GDBusConnection associated with @proxy is closed then
   // the operation will fail with %G_IO_ERROR_CLOSED. If
   // @cancellable is canceled, the operation will fail with
   // %G_IO_ERROR_CANCELLED. If @parameters contains a value not
   // compatible with the D-Bus protocol, the operation fails with
   // %G_IO_ERROR_INVALID_ARGUMENT.
   // 
   // If the @parameters #GVariant is floating, it is consumed. This allows
   // convenient 'inline' use of g_variant_new(), e.g.:
   // |[
   // g_dbus_proxy_call (proxy,
   // "TwoStrings",
   // g_variant_new ("(ss)",
   // "Thing One",
   // "Thing Two"),
   // G_DBUS_CALL_FLAGS_NONE,
   // -1,
   // NULL,
   // (GAsyncReadyCallback) two_strings_done,
   // &amp;data);
   // ]|
   // 
   // This is an asynchronous method. When the operation is finished,
   // @callback will be invoked in the
   // <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
   // of the thread you are calling this method from.
   // You can then call g_dbus_proxy_call_finish() to get the result of
   // the operation. See g_dbus_proxy_call_sync() for the synchronous
   // version of this method.
   // <method_name>: Name of method to invoke.
   // <parameters>: A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
   // <flags>: Flags from the #GDBusCallFlags enumeration.
   // <timeout_msec>: The timeout in milliseconds (with %G_MAXINT meaning "infinite") or -1 to use the proxy default timeout.
   // <cancellable>: A #GCancellable or %NULL.
   // <callback>: A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation.
   // <user_data>: The data to pass to @callback.
   void call(char* method_name, GLib2.Variant* parameters, DBusCallFlags flags, int timeout_msec, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_dbus_proxy_call(&this, method_name, parameters, flags, timeout_msec, cancellable, callback, user_data);
   }

   // Finishes an operation started with g_dbus_proxy_call().
   // 
   // return values. Free with g_variant_unref().
   // RETURNS: %NULL if @error is set. Otherwise a #GVariant tuple with
   // <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_proxy_call().
   GLib2.Variant* /*new*/ call_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_dbus_proxy_call_finish(&this, res, error);
   }

   // Synchronously invokes the @method_name method on @proxy.
   // 
   // If @method_name contains any dots, then @name is split into interface and
   // method name parts. This allows using @proxy for invoking methods on
   // other interfaces.
   // 
   // If the #GDBusConnection associated with @proxy is disconnected then
   // the operation will fail with %G_IO_ERROR_CLOSED. If
   // @cancellable is canceled, the operation will fail with
   // %G_IO_ERROR_CANCELLED. If @parameters contains a value not
   // compatible with the D-Bus protocol, the operation fails with
   // %G_IO_ERROR_INVALID_ARGUMENT.
   // 
   // If the @parameters #GVariant is floating, it is consumed. This allows
   // convenient 'inline' use of g_variant_new(), e.g.:
   // |[
   // g_dbus_proxy_call_sync (proxy,
   // "TwoStrings",
   // g_variant_new ("(ss)",
   // "Thing One",
   // "Thing Two"),
   // G_DBUS_CALL_FLAGS_NONE,
   // -1,
   // NULL,
   // &amp;error);
   // ]|
   // 
   // The calling thread is blocked until a reply is received. See
   // g_dbus_proxy_call() for the asynchronous version of this
   // method.
   // 
   // return values. Free with g_variant_unref().
   // RETURNS: %NULL if @error is set. Otherwise a #GVariant tuple with
   // <method_name>: Name of method to invoke.
   // <parameters>: A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
   // <flags>: Flags from the #GDBusCallFlags enumeration.
   // <timeout_msec>: The timeout in milliseconds (with %G_MAXINT meaning "infinite") or -1 to use the proxy default timeout.
   // <cancellable>: A #GCancellable or %NULL.
   GLib2.Variant* /*new*/ call_sync(char* method_name, GLib2.Variant* parameters, DBusCallFlags flags, int timeout_msec, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_proxy_call_sync(&this, method_name, parameters, flags, timeout_msec, cancellable, error);
   }

   // Like g_dbus_proxy_call() but also takes a #GUnixFDList object.
   // 
   // This method is only available on UNIX.
   // <method_name>: Name of method to invoke.
   // <parameters>: A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
   // <flags>: Flags from the #GDBusCallFlags enumeration.
   // <timeout_msec>: The timeout in milliseconds (with %G_MAXINT meaning "infinite") or -1 to use the proxy default timeout.
   // <fd_list>: A #GUnixFDList or %NULL.
   // <cancellable>: A #GCancellable or %NULL.
   // <callback>: A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation.
   // <user_data>: The data to pass to @callback.
   void call_with_unix_fd_list(char* method_name, GLib2.Variant* parameters, DBusCallFlags flags, int timeout_msec, UnixFDList* fd_list, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_dbus_proxy_call_with_unix_fd_list(&this, method_name, parameters, flags, timeout_msec, fd_list, cancellable, callback, user_data);
   }

   // Finishes an operation started with g_dbus_proxy_call_with_unix_fd_list().
   // 
   // return values. Free with g_variant_unref().
   // RETURNS: %NULL if @error is set. Otherwise a #GVariant tuple with
   // <out_fd_list>: Return location for a #GUnixFDList or %NULL.
   // <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_proxy_call_with_unix_fd_list().
   GLib2.Variant* /*new*/ call_with_unix_fd_list_finish(/*out*/ UnixFDList** out_fd_list, AsyncResult* res, GLib2.Error** error=null) {
      return g_dbus_proxy_call_with_unix_fd_list_finish(&this, out_fd_list, res, error);
   }

   // Like g_dbus_proxy_call_sync() but also takes and returns #GUnixFDList objects.
   // 
   // This method is only available on UNIX.
   // 
   // return values. Free with g_variant_unref().
   // RETURNS: %NULL if @error is set. Otherwise a #GVariant tuple with
   // <method_name>: Name of method to invoke.
   // <parameters>: A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
   // <flags>: Flags from the #GDBusCallFlags enumeration.
   // <timeout_msec>: The timeout in milliseconds (with %G_MAXINT meaning "infinite") or -1 to use the proxy default timeout.
   // <fd_list>: A #GUnixFDList or %NULL.
   // <out_fd_list>: Return location for a #GUnixFDList or %NULL.
   // <cancellable>: A #GCancellable or %NULL.
   GLib2.Variant* /*new*/ call_with_unix_fd_list_sync(char* method_name, GLib2.Variant* parameters, DBusCallFlags flags, int timeout_msec, UnixFDList* fd_list, /*out*/ UnixFDList** out_fd_list, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_proxy_call_with_unix_fd_list_sync(&this, method_name, parameters, flags, timeout_msec, fd_list, out_fd_list, cancellable, error);
   }

   // Looks up the value for a property from the cache. This call does no
   // blocking IO.
   // 
   // If @proxy has an expected interface (see
   // #GDBusProxy:g-interface-info), then @property_name (for existence)
   // is checked against it.
   // 
   // for @property_name or %NULL if the value is not in the cache. The
   // returned reference must be freed with g_variant_unref().
   // RETURNS: A reference to the #GVariant instance that holds the value
   // <property_name>: Property name.
   GLib2.Variant* /*new*/ get_cached_property(char* property_name) {
      return g_dbus_proxy_get_cached_property(&this, property_name);
   }

   // Gets the names of all cached properties on @proxy.
   // 
   // @proxy has no cached properties. Free the returned array with
   // g_strfreev().
   // RETURNS: A %NULL-terminated array of strings or %NULL if
   char** /*new*/ get_cached_property_names() {
      return g_dbus_proxy_get_cached_property_names(&this);
   }

   // Gets the connection @proxy is for.
   // RETURNS: A #GDBusConnection owned by @proxy. Do not free.
   DBusConnection* get_connection() {
      return g_dbus_proxy_get_connection(&this);
   }

   // Gets the timeout to use if -1 (specifying default timeout) is
   // passed as @timeout_msec in the g_dbus_proxy_call() and
   // g_dbus_proxy_call_sync() functions.
   // 
   // See the #GDBusProxy:g-default-timeout property for more details.
   // RETURNS: Timeout to use for @proxy.
   int get_default_timeout() {
      return g_dbus_proxy_get_default_timeout(&this);
   }

   // Gets the flags that @proxy was constructed with.
   // RETURNS: Flags from the #GDBusProxyFlags enumeration.
   DBusProxyFlags get_flags() {
      return g_dbus_proxy_get_flags(&this);
   }

   // Returns the #GDBusInterfaceInfo, if any, specifying the minimal
   // interface that @proxy conforms to.
   // 
   // See the #GDBusProxy:g-interface-info property for more details.
   // 
   // object, it is owned by @proxy.
   // RETURNS: A #GDBusInterfaceInfo or %NULL. Do not unref the returned
   DBusInterfaceInfo* /*new*/ get_interface_info() {
      return g_dbus_proxy_get_interface_info(&this);
   }

   // Gets the D-Bus interface name @proxy is for.
   // RETURNS: A string owned by @proxy. Do not free.
   char* get_interface_name() {
      return g_dbus_proxy_get_interface_name(&this);
   }

   // Gets the name that @proxy was constructed for.
   // RETURNS: A string owned by @proxy. Do not free.
   char* get_name() {
      return g_dbus_proxy_get_name(&this);
   }

   // The unique name that owns the name that @proxy is for or %NULL if
   // no-one currently owns that name. You may connect to the
   // #GObject::notify signal to track changes to the
   // #GDBusProxy:g-name-owner property.
   // RETURNS: The name owner or %NULL if no name owner exists. Free with g_free().
   char* /*new*/ get_name_owner() {
      return g_dbus_proxy_get_name_owner(&this);
   }

   // Gets the object path @proxy is for.
   // RETURNS: A string owned by @proxy. Do not free.
   char* get_object_path() {
      return g_dbus_proxy_get_object_path(&this);
   }

   // If @value is not %NULL, sets the cached value for the property with
   // name @property_name to the value in @value.
   // 
   // If @value is %NULL, then the cached value is removed from the
   // property cache.
   // 
   // If @proxy has an expected interface (see
   // #GDBusProxy:g-interface-info), then @property_name (for existence)
   // and @value (for the type) is checked against it.
   // 
   // If the @value #GVariant is floating, it is consumed. This allows
   // convenient 'inline' use of g_variant_new(), e.g.
   // |[
   // g_dbus_proxy_set_cached_property (proxy,
   // "SomeProperty",
   // g_variant_new ("(si)",
   // "A String",
   // 42));
   // ]|
   // 
   // Normally you will not need to use this method since @proxy is
   // tracking changes using the
   // <literal>org.freedesktop.DBus.Properties.PropertiesChanged</literal>
   // D-Bus signal. However, for performance reasons an object may decide
   // to not use this signal for some properties and instead use a
   // proprietary out-of-band mechanism to transmit changes.
   // 
   // As a concrete example, consider an object with a property
   // <literal>ChatroomParticipants</literal> which is an array of
   // strings. Instead of transmitting the same (long) array every time
   // the property changes, it is more efficient to only transmit the
   // delta using e.g. signals <literal>ChatroomParticipantJoined(String
   // name)</literal> and <literal>ChatroomParticipantParted(String
   // name)</literal>.
   // <property_name>: Property name.
   // <value>: Value for the property or %NULL to remove it from the cache.
   void set_cached_property(char* property_name, GLib2.Variant* value=null) {
      g_dbus_proxy_set_cached_property(&this, property_name, value);
   }

   // Sets the timeout to use if -1 (specifying default timeout) is
   // passed as @timeout_msec in the g_dbus_proxy_call() and
   // g_dbus_proxy_call_sync() functions.
   // 
   // See the #GDBusProxy:g-default-timeout property for more details.
   // <timeout_msec>: Timeout in milliseconds.
   void set_default_timeout(int timeout_msec) {
      g_dbus_proxy_set_default_timeout(&this, timeout_msec);
   }

   // Ensure that interactions with @proxy conform to the given
   // interface.  For example, when completing a method call, if the type
   // signature of the message isn't what's expected, the given #GError
   // is set.  Signals that have a type signature mismatch are simply
   // dropped.
   // 
   // See the #GDBusProxy:g-interface-info property for more details.
   // <info>: Minimum interface this proxy conforms to or %NULL to unset.
   void set_interface_info(DBusInterfaceInfo* info=null) {
      g_dbus_proxy_set_interface_info(&this, info);
   }

   // Emitted when one or more D-Bus properties on @proxy changes. The
   // local cache has already been updated when this signal fires. Note
   // that both @changed_properties and @invalidated_properties are
   // guaranteed to never be %NULL (either may be empty though).
   // 
   // This signal corresponds to the
   // <literal>PropertiesChanged</literal> D-Bus signal on the
   // <literal>org.freedesktop.DBus.Properties</literal> interface.
   // <changed_properties>: A #GVariant containing the properties that changed
   // <invalidated_properties>: A %NULL terminated array of properties that was invalidated
   extern (C) alias static void function (DBusProxy* this_, GLib2.Variant* changed_properties, char* invalidated_properties, void* user_data=null) signal_g_properties_changed;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"g-properties-changed", CB:signal_g_properties_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"g-properties-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when a signal from the remote object and interface that @proxy is for, has been received.
   // <sender_name>: The sender of the signal or %NULL if the connection is not a bus connection.
   // <signal_name>: The name of the signal.
   // <parameters>: A #GVariant tuple with parameters for the signal.
   extern (C) alias static void function (DBusProxy* this_, char* sender_name, char* signal_name, GLib2.Variant* parameters, void* user_data=null) signal_g_signal;
   ulong signal_connect(string name:"g-signal", CB:signal_g_signal)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"g-signal",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

// Class structure for #GDBusProxy.
struct DBusProxyClass /* Version 2.26 */ {
   private GObject2.ObjectClass parent_class;
   extern (C) void function (DBusProxy* proxy, GLib2.Variant* changed_properties, char** invalidated_properties) g_properties_changed;
   extern (C) void function (DBusProxy* proxy, char* sender_name, char* signal_name, GLib2.Variant* parameters) g_signal;
   private void*[32] padding;
}

// Flags used when constructing an instance of a #GDBusProxy derived class.
enum DBusProxyFlags /* Version 2.26 */ {
   NONE = 0,
   DO_NOT_LOAD_PROPERTIES = 1,
   DO_NOT_CONNECT_SIGNALS = 2,
   DO_NOT_AUTO_START = 4
}
struct DBusProxyPrivate {
}


// Function signature for a function used to determine the #GType to
// use for an interface proxy (if @interface_name is not %NULL) or
// object proxy (if @interface_name is %NULL).
// 
// This function is called in the
// <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
// that @manager was constructed in.
// 
// must be a #GDBusProxy<!-- -->- or #GDBusObjectProxy<!-- -->-derived
// type.
// RETURNS: A #GType to use for the remote object. The returned type
// <manager>: A #GDBusObjectManagerClient.
// <object_path>: The object path of the remote object.
// <interface_name>: The interface name of the remote object or %NULL if a #GDBusObjectProxy #GType is requested.
// <user_data>: User data.
extern (C) alias Type function (DBusObjectManagerClient* manager, char* object_path, char* interface_name, void* user_data) DBusProxyTypeFunc;

// Flags used when sending #GDBusMessage<!-- -->s on a #GDBusConnection.
enum DBusSendMessageFlags /* Version 2.26 */ {
   NONE = 0,
   PRESERVE_SERIAL = 1
}

// #GDBusServer is a helper for listening to and accepting D-Bus
// connections. This can be used to create a new D-Bus server, allowing two
// peers to use the D-Bus protocol for their own specialized communication.
// A server instance provided in this way will not perform message routing or
// implement the org.freedesktop.DBus interface.
// 
// To just export an object on a well-known name on a message bus, such as the
// session or system bus, you should instead use g_bus_own_name().
// 
// <example id="gdbus-peer-to-peer"><title>D-Bus peer-to-peer example</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-peer.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
struct DBusServer /* : GObject.Object */ /* Version 2.26 */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new D-Bus server that listens on the first address in
   // @address that works.
   // 
   // Once constructed, you can use g_dbus_server_get_client_address() to
   // get a D-Bus address string that clients can use to connect.
   // 
   // Connect to the #GDBusServer::new-connection signal to handle
   // incoming connections.
   // 
   // The returned #GDBusServer isn't active - you have to start it with
   // g_dbus_server_start().
   // 
   // See <xref linkend="gdbus-peer-to-peer"/> for how #GDBusServer can
   // be used.
   // 
   // This is a synchronous failable constructor. See
   // g_dbus_server_new() for the asynchronous version.
   // 
   // g_object_unref().
   // RETURNS: A #GDBusServer or %NULL if @error is set. Free with
   // <address>: A D-Bus address.
   // <flags>: Flags from the #GDBusServerFlags enumeration.
   // <guid>: A D-Bus GUID.
   // <observer>: A #GDBusAuthObserver or %NULL.
   // <cancellable>: A #GCancellable or %NULL.
   static DBusServer* /*new*/ new_sync(char* address, DBusServerFlags flags, char* guid, DBusAuthObserver* observer, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_dbus_server_new_sync(address, flags, guid, observer, cancellable, error);
   }

   // Gets a D-Bus address string that can be used by clients to connect
   // to @server.
   // 
   // by @server.
   // RETURNS: A D-Bus address string. Do not free, the string is owned
   char* get_client_address() {
      return g_dbus_server_get_client_address(&this);
   }

   // Gets the flags for @server.
   // RETURNS: A set of flags from the #GDBusServerFlags enumeration.
   DBusServerFlags get_flags() {
      return g_dbus_server_get_flags(&this);
   }

   // Gets the GUID for @server.
   // RETURNS: A D-Bus GUID. Do not free this string, it is owned by @server.
   char* get_guid() {
      return g_dbus_server_get_guid(&this);
   }

   // Gets whether @server is active.
   // RETURNS: %TRUE if server is active, %FALSE otherwise.
   int is_active() {
      return g_dbus_server_is_active(&this);
   }
   // Starts @server.
   void start() {
      g_dbus_server_start(&this);
   }
   // Stops @server.
   void stop() {
      g_dbus_server_stop(&this);
   }

   // Emitted when a new authenticated connection has been made. Use
   // g_dbus_connection_get_peer_credentials() to figure out what
   // identity (if any), was authenticated.
   // 
   // If you want to accept the connection, take a reference to the
   // @connection object and return %TRUE. When you are done with the
   // connection call g_dbus_connection_close() and give up your
   // reference. Note that the other peer may disconnect at any time -
   // a typical thing to do when accepting a connection is to listen to
   // the #GDBusConnection::closed signal.
   // 
   // If #GDBusServer:flags contains %G_DBUS_SERVER_FLAGS_RUN_IN_THREAD
   // then the signal is emitted in a new thread dedicated to the
   // connection. Otherwise the signal is emitted in the <link
   // linkend="g-main-context-push-thread-default">thread-default main
   // loop</link> of the thread that @server was constructed in.
   // 
   // You are guaranteed that signal handlers for this signal runs
   // before incoming messages on @connection are processed. This means
   // that it's suitable to call g_dbus_connection_register_object() or
   // similar from the signal handler.
   // 
   // run.
   // RETURNS: %TRUE to claim @connection, %FALSE to let other handlers
   // <connection>: A #GDBusConnection for the new connection.
   extern (C) alias static c_int function (DBusServer* this_, DBusConnection* connection, void* user_data=null) signal_new_connection;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"new-connection", CB:signal_new_connection)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"new-connection",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

// Flags used when creating a #GDBusServer.
enum DBusServerFlags /* Version 2.26 */ {
   NONE = 0,
   RUN_IN_THREAD = 1,
   AUTHENTICATION_ALLOW_ANONYMOUS = 2
}

// Signature for callback function used in g_dbus_connection_signal_subscribe().
// <connection>: A #GDBusConnection.
// <sender_name>: The unique bus name of the sender of the signal.
// <object_path>: The object path that the signal was emitted on.
// <interface_name>: The name of the interface.
// <signal_name>: The name of the signal.
// <parameters>: A #GVariant tuple with parameters for the signal.
// <user_data>: User data passed when subscribing to the signal.
extern (C) alias void function (DBusConnection* connection, char* sender_name, char* object_path, char* interface_name, char* signal_name, GLib2.Variant* parameters, void* user_data) DBusSignalCallback;

// Flags used when subscribing to signals via g_dbus_connection_signal_subscribe().
enum DBusSignalFlags /* Version 2.26 */ {
   NONE = 0,
   NO_MATCH_RULE = 1
}
// Information about a signal on a D-Bus interface.
struct DBusSignalInfo /* Version 2.26 */ {
   int ref_count;
   char* name;
   DBusArgInfo*[666] args;
   DBusAnnotationInfo*[666] annotations;


   // If @info is statically allocated does nothing. Otherwise increases
   // the reference count.
   // RETURNS: The same @info.
   DBusSignalInfo* /*new*/ ref_() {
      return g_dbus_signal_info_ref(&this);
   }

   // If @info is statically allocated, does nothing. Otherwise decreases
   // the reference count of @info. When its reference count drops to 0,
   // the memory used is freed.
   void unref() {
      g_dbus_signal_info_unref(&this);
   }
}


// The type of the @dispatch function in #GDBusSubtreeVTable.
// 
// Subtrees are flat.  @node, if non-%NULL, is always exactly one
// segment of the object path (ie: it never contains a slash).
// RETURNS: A #GDBusInterfaceVTable or %NULL if you don't want to handle the methods.
// <connection>: A #GDBusConnection.
// <sender>: The unique bus name of the remote caller.
// <object_path>: The object path that was registered with g_dbus_connection_register_subtree().
// <interface_name>: The D-Bus interface name that the method call or property access is for.
// <node>: A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree.
// <out_user_data>: Return location for user data to pass to functions in the returned #GDBusInterfaceVTable (never %NULL).
// <user_data>: The @user_data #gpointer passed to g_dbus_connection_register_subtree().
extern (C) alias DBusInterfaceVTable* function (DBusConnection* connection, char* sender, char* object_path, char* interface_name, char* node, void** out_user_data, void* user_data) DBusSubtreeDispatchFunc;


// Unintrospectable callback: DBusSubtreeEnumerateFunc() / ()
// The type of the @enumerate function in #GDBusSubtreeVTable.
// 
// This function is called when generating introspection data and also
// when preparing to dispatch incoming messages in the event that the
// %G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is not
// specified (ie: to verify that the object path is valid).
// 
// Hierarchies are not supported; the items that you return should not
// contain the '/' character.
// 
// The return value will be freed with g_strfreev().
// RETURNS: A newly allocated array of strings for node names that are children of @object_path.
// <connection>: A #GDBusConnection.
// <sender>: The unique bus name of the remote caller.
// <object_path>: The object path that was registered with g_dbus_connection_register_subtree().
// <user_data>: The @user_data #gpointer passed to g_dbus_connection_register_subtree().
extern (C) alias char** function (DBusConnection* connection, char* sender, char* object_path, void* user_data) DBusSubtreeEnumerateFunc;

// Flags passed to g_dbus_connection_register_subtree().
enum DBusSubtreeFlags /* Version 2.26 */ {
   NONE = 0,
   DISPATCH_TO_UNENUMERATED_NODES = 1
}

// The type of the @introspect function in #GDBusSubtreeVTable.
// 
// Subtrees are flat.  @node, if non-%NULL, is always exactly one
// segment of the object path (ie: it never contains a slash).
// 
// This function should return %NULL to indicate that there is no object
// at this node.
// 
// If this function returns non-%NULL, the return value is expected to
// be a %NULL-terminated array of pointers to #GDBusInterfaceInfo
// structures describing the interfaces implemented by @node.  This
// array will have g_dbus_interface_info_unref() called on each item
// before being freed with g_free().
// 
// The difference between returning %NULL and an array containing zero
// items is that the standard DBus interfaces will returned to the
// remote introspector in the empty array case, but not in the %NULL
// case.
// RETURNS: A %NULL-terminated array of pointers to #GDBusInterfaceInfo, or %NULL.
// <connection>: A #GDBusConnection.
// <sender>: The unique bus name of the remote caller.
// <object_path>: The object path that was registered with g_dbus_connection_register_subtree().
// <node>: A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree.
// <user_data>: The @user_data #gpointer passed to g_dbus_connection_register_subtree().
extern (C) alias DBusInterfaceInfo** /*new*/ function (DBusConnection* connection, char* sender, char* object_path, char* node, void* user_data) DBusSubtreeIntrospectFunc;

// Virtual table for handling subtrees registered with g_dbus_connection_register_subtree().
struct DBusSubtreeVTable /* Version 2.26 */ {
   DBusSubtreeEnumerateFunc enumerate;
   DBusSubtreeIntrospectFunc introspect;
   DBusSubtreeDispatchFunc dispatch;
   private void*[8] padding;
}

enum DESKTOP_APP_INFO_LOOKUP_EXTENSION_POINT_NAME = "gio-desktop-app-info-lookup";

// Data input stream implements #GInputStream and includes functions for
// reading structured data directly from a binary input stream.
struct DataInputStream /* : BufferedInputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance bufferedinputstream;
   BufferedInputStream parent_instance;
   private DataInputStreamPrivate* priv;


   // Creates a new data input stream for the @base_stream.
   // RETURNS: a new #GDataInputStream.
   // <base_stream>: a #GInputStream.
   static DataInputStream* /*new*/ new_(InputStream* base_stream) {
      return g_data_input_stream_new(base_stream);
   }

   // Gets the byte order for the data input stream.
   // RETURNS: the @stream's current #GDataStreamByteOrder.
   DataStreamByteOrder get_byte_order() {
      return g_data_input_stream_get_byte_order(&this);
   }

   // Gets the current newline type for the @stream.
   // RETURNS: #GDataStreamNewlineType for the given @stream.
   DataStreamNewlineType get_newline_type() {
      return g_data_input_stream_get_newline_type(&this);
   }

   // Reads an unsigned 8-bit/1-byte value from @stream.
   // 
   // if an error occurred.
   // RETURNS: an unsigned 8-bit/1-byte value read from the @stream or %0
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   ubyte read_byte(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_input_stream_read_byte(&this, cancellable, error);
   }

   // Reads a 16-bit/2-byte value from @stream.
   // 
   // In order to get the correct byte order for this read operation,
   // see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
   // 
   // an error occurred.
   // RETURNS: a signed 16-bit/2-byte value read from @stream or %0 if
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   short read_int16(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_input_stream_read_int16(&this, cancellable, error);
   }

   // Reads a signed 32-bit/4-byte value from @stream.
   // 
   // In order to get the correct byte order for this read operation,
   // see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // an error occurred.
   // RETURNS: a signed 32-bit/4-byte value read from the @stream or %0 if
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int read_int32(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_input_stream_read_int32(&this, cancellable, error);
   }

   // Reads a 64-bit/8-byte value from @stream.
   // 
   // In order to get the correct byte order for this read operation,
   // see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // an error occurred.
   // RETURNS: a signed 64-bit/8-byte value read from @stream or %0 if
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   long read_int64(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_input_stream_read_int64(&this, cancellable, error);
   }

   // Reads a line from the data input stream.  Note that no encoding
   // checks or conversion is performed; the input is not guaranteed to
   // be UTF-8, and may in fact have embedded NUL characters.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // NUL terminated byte array with the line that was read in (without
   // the newlines).  Set @length to a #gsize to get the length of the
   // read line.  On an error, it will return %NULL and @error will be
   // set. If there's no content to read, it will still return %NULL,
   // but @error won't be set.
   // RETURNS: a
   // <length>: a #gsize to get the length of the data read in.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   ubyte* /*new*/ read_line(/*out*/ size_t* length, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_input_stream_read_line(&this, length, cancellable, error);
   }

   // The asynchronous version of g_data_input_stream_read_line().  It is
   // an error to have two outstanding calls to this function.
   // 
   // When the operation is finished, @callback will be called. You
   // can then call g_data_input_stream_read_line_finish() to get
   // the result of the operation.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied.
   // <user_data>: the data to pass to callback function.
   void read_line_async(int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_data_input_stream_read_line_async(&this, io_priority, cancellable, callback, user_data);
   }

   // Finish an asynchronous call started by
   // g_data_input_stream_read_line_async().  Note the warning about
   // string encoding in g_data_input_stream_read_line() applies here as
   // well.
   // 
   // NUL-terminated byte array with the line that was read in
   // (without the newlines).  Set @length to a #gsize to get the
   // length of the read line.  On an error, it will return %NULL and
   // @error will be set. If there's no content to read, it will
   // still return %NULL, but @error won't be set.
   // RETURNS: a
   // <result>: the #GAsyncResult that was provided to the callback.
   // <length>: a #gsize to get the length of the data read in.
   ubyte* /*new*/ read_line_finish(AsyncResult* result, /*out*/ size_t* length, GLib2.Error** error=null) {
      return g_data_input_stream_read_line_finish(&this, result, length, error);
   }

   // Finish an asynchronous call started by
   // g_data_input_stream_read_line_async().
   // 
   // (without the newlines).  Set @length to a #gsize to get the length
   // of the read line.  On an error, it will return %NULL and @error
   // will be set. For UTF-8 conversion errors, the set error domain is
   // %G_CONVERT_ERROR.  If there's no content to read, it will still
   // return %NULL, but @error won't be set.
   // RETURNS: a string with the line that was read in
   // <result>: the #GAsyncResult that was provided to the callback.
   // <length>: a #gsize to get the length of the data read in.
   char* /*new*/ read_line_finish_utf8(AsyncResult* result, /*out*/ size_t* length, GLib2.Error** error=null) {
      return g_data_input_stream_read_line_finish_utf8(&this, result, length, error);
   }

   // Reads a UTF-8 encoded line from the data input stream.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // line that was read in (without the newlines).  Set @length to a
   // #gsize to get the length of the read line.  On an error, it will
   // return %NULL and @error will be set.  For UTF-8 conversion errors,
   // the set error domain is %G_CONVERT_ERROR.  If there's no content to
   // read, it will still return %NULL, but @error won't be set.
   // RETURNS: a NUL terminated UTF-8 string with the
   // <length>: a #gsize to get the length of the data read in.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   char* /*new*/ read_line_utf8(/*out*/ size_t* length, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_input_stream_read_line_utf8(&this, length, cancellable, error);
   }

   // Reads an unsigned 16-bit/2-byte value from @stream.
   // 
   // In order to get the correct byte order for this read operation,
   // see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
   // 
   // an error occurred.
   // RETURNS: an unsigned 16-bit/2-byte value read from the @stream or %0 if
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   ushort read_uint16(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_input_stream_read_uint16(&this, cancellable, error);
   }

   // Reads an unsigned 32-bit/4-byte value from @stream.
   // 
   // In order to get the correct byte order for this read operation,
   // see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // an error occurred.
   // RETURNS: an unsigned 32-bit/4-byte value read from the @stream or %0 if
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   uint read_uint32(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_input_stream_read_uint32(&this, cancellable, error);
   }

   // Reads an unsigned 64-bit/8-byte value from @stream.
   // 
   // In order to get the correct byte order for this read operation,
   // see g_data_input_stream_get_byte_order().
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // an error occurred.
   // RETURNS: an unsigned 64-bit/8-byte read from @stream or %0 if
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   ulong read_uint64(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_input_stream_read_uint64(&this, cancellable, error);
   }

   // Reads a string from the data input stream, up to the first
   // occurrence of any of the stop characters.
   // 
   // Note that, in contrast to g_data_input_stream_read_until_async(),
   // this function consumes the stop character that it finds.
   // 
   // Don't use this function in new code.  Its functionality is
   // inconsistent with g_data_input_stream_read_until_async().  Both
   // functions will be marked as deprecated in a future release.  Use
   // g_data_input_stream_read_upto() instead, but note that that function
   // does not consume the stop character.
   // 
   // before encountering any of the stop characters. Set @length to
   // a #gsize to get the length of the string. This function will
   // return %NULL on an error.
   // RETURNS: a string with the data that was read
   // <stop_chars>: characters to terminate the read.
   // <length>: a #gsize to get the length of the data read in.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   char* /*new*/ read_until(char* stop_chars, /*out*/ size_t* length, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_input_stream_read_until(&this, stop_chars, length, cancellable, error);
   }

   // The asynchronous version of g_data_input_stream_read_until().
   // It is an error to have two outstanding calls to this function.
   // 
   // Note that, in contrast to g_data_input_stream_read_until(),
   // this function does not consume the stop character that it finds.  You
   // must read it for yourself.
   // 
   // When the operation is finished, @callback will be called. You
   // can then call g_data_input_stream_read_until_finish() to get
   // the result of the operation.
   // 
   // Don't use this function in new code.  Its functionality is
   // inconsistent with g_data_input_stream_read_until().  Both functions
   // will be marked as deprecated in a future release.  Use
   // g_data_input_stream_read_upto_async() instead.
   // <stop_chars>: characters to terminate the read.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied.
   // <user_data>: the data to pass to callback function.
   void read_until_async(char* stop_chars, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_data_input_stream_read_until_async(&this, stop_chars, io_priority, cancellable, callback, user_data);
   }

   // Finish an asynchronous call started by
   // g_data_input_stream_read_until_async().
   // 
   // 
   // before encountering any of the stop characters. Set @length to
   // a #gsize to get the length of the string. This function will
   // return %NULL on an error.
   // RETURNS: a string with the data that was read
   // <result>: the #GAsyncResult that was provided to the callback.
   // <length>: a #gsize to get the length of the data read in.
   char* /*new*/ read_until_finish(AsyncResult* result, /*out*/ size_t* length, GLib2.Error** error=null) {
      return g_data_input_stream_read_until_finish(&this, result, length, error);
   }

   // Reads a string from the data input stream, up to the first
   // occurrence of any of the stop characters.
   // 
   // In contrast to g_data_input_stream_read_until(), this function
   // does <emphasis>not</emphasis> consume the stop character. You have
   // to use g_data_input_stream_read_byte() to get it before calling
   // g_data_input_stream_read_upto() again.
   // 
   // Note that @stop_chars may contain '\0' if @stop_chars_len is
   // specified.
   // 
   // before encountering any of the stop characters. Set @length to
   // a #gsize to get the length of the string. This function will
   // return %NULL on an error
   // RETURNS: a string with the data that was read
   // <stop_chars>: characters to terminate the read
   // <stop_chars_len>: length of @stop_chars. May be -1 if @stop_chars is nul-terminated
   // <length>: a #gsize to get the length of the data read in
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   char* /*new*/ read_upto(char* stop_chars, ssize_t stop_chars_len, /*out*/ size_t* length, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_input_stream_read_upto(&this, stop_chars, stop_chars_len, length, cancellable, error);
   }

   // The asynchronous version of g_data_input_stream_read_upto().
   // It is an error to have two outstanding calls to this function.
   // 
   // In contrast to g_data_input_stream_read_until(), this function
   // does <emphasis>not</emphasis> consume the stop character. You have
   // to use g_data_input_stream_read_byte() to get it before calling
   // g_data_input_stream_read_upto() again.
   // 
   // Note that @stop_chars may contain '\0' if @stop_chars_len is
   // specified.
   // 
   // When the operation is finished, @callback will be called. You
   // can then call g_data_input_stream_read_upto_finish() to get
   // the result of the operation.
   // <stop_chars>: characters to terminate the read
   // <stop_chars_len>: length of @stop_chars. May be -1 if @stop_chars is nul-terminated
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void read_upto_async(char* stop_chars, ssize_t stop_chars_len, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_data_input_stream_read_upto_async(&this, stop_chars, stop_chars_len, io_priority, cancellable, callback, user_data);
   }

   // Finish an asynchronous call started by
   // g_data_input_stream_read_upto_async().
   // 
   // Note that this function does <emphasis>not</emphasis> consume the
   // stop character. You have to use g_data_input_stream_read_byte() to
   // get it before calling g_data_input_stream_read_upto_async() again.
   // 
   // before encountering any of the stop characters. Set @length to
   // a #gsize to get the length of the string. This function will
   // return %NULL on an error.
   // RETURNS: a string with the data that was read
   // <result>: the #GAsyncResult that was provided to the callback
   // <length>: a #gsize to get the length of the data read in
   char* /*new*/ read_upto_finish(AsyncResult* result, /*out*/ size_t* length, GLib2.Error** error=null) {
      return g_data_input_stream_read_upto_finish(&this, result, length, error);
   }

   // This function sets the byte order for the given @stream. All subsequent
   // reads from the @stream will be read in the given @order.
   // <order>: a #GDataStreamByteOrder to set.
   void set_byte_order(DataStreamByteOrder order) {
      g_data_input_stream_set_byte_order(&this, order);
   }

   // Sets the newline type for the @stream.
   // 
   // Note that using G_DATA_STREAM_NEWLINE_TYPE_ANY is slightly unsafe. If a read
   // chunk ends in "CR" we must read an additional byte to know if this is "CR" or
   // "CR LF", and this might block if there is no more data available.
   // <type>: the type of new line return as #GDataStreamNewlineType.
   void set_newline_type(DataStreamNewlineType type) {
      g_data_input_stream_set_newline_type(&this, type);
   }
}

struct DataInputStreamClass {
   BufferedInputStreamClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct DataInputStreamPrivate {
}


// Data output stream implements #GOutputStream and includes functions for
// writing data directly to an output stream.
struct DataOutputStream /* : FilterOutputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance filteroutputstream;
   FilterOutputStream parent_instance;
   private DataOutputStreamPrivate* priv;


   // Creates a new data output stream for @base_stream.
   // RETURNS: #GDataOutputStream.
   // <base_stream>: a #GOutputStream.
   static DataOutputStream* /*new*/ new_(OutputStream* base_stream) {
      return g_data_output_stream_new(base_stream);
   }

   // Gets the byte order for the stream.
   // RETURNS: the #GDataStreamByteOrder for the @stream.
   DataStreamByteOrder get_byte_order() {
      return g_data_output_stream_get_byte_order(&this);
   }

   // Puts a byte into the output stream.
   // RETURNS: %TRUE if @data was successfully added to the @stream.
   // <data>: a #guchar.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int put_byte(ubyte data, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_output_stream_put_byte(&this, data, cancellable, error);
   }

   // Puts a signed 16-bit integer into the output stream.
   // RETURNS: %TRUE if @data was successfully added to the @stream.
   // <data>: a #gint16.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int put_int16(short data, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_output_stream_put_int16(&this, data, cancellable, error);
   }

   // Puts a signed 32-bit integer into the output stream.
   // RETURNS: %TRUE if @data was successfully added to the @stream.
   // <data>: a #gint32.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int put_int32(int data, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_output_stream_put_int32(&this, data, cancellable, error);
   }

   // Puts a signed 64-bit integer into the stream.
   // RETURNS: %TRUE if @data was successfully added to the @stream.
   // <data>: a #gint64.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int put_int64(long data, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_output_stream_put_int64(&this, data, cancellable, error);
   }

   // Puts a string into the output stream.
   // RETURNS: %TRUE if @string was successfully added to the @stream.
   // <str>: a string.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int put_string(char* str, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_output_stream_put_string(&this, str, cancellable, error);
   }

   // Puts an unsigned 16-bit integer into the output stream.
   // RETURNS: %TRUE if @data was successfully added to the @stream.
   // <data>: a #guint16.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int put_uint16(ushort data, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_output_stream_put_uint16(&this, data, cancellable, error);
   }

   // Puts an unsigned 32-bit integer into the stream.
   // RETURNS: %TRUE if @data was successfully added to the @stream.
   // <data>: a #guint32.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int put_uint32(uint data, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_output_stream_put_uint32(&this, data, cancellable, error);
   }

   // Puts an unsigned 64-bit integer into the stream.
   // RETURNS: %TRUE if @data was successfully added to the @stream.
   // <data>: a #guint64.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int put_uint64(ulong data, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_data_output_stream_put_uint64(&this, data, cancellable, error);
   }

   // Sets the byte order of the data output stream to @order.
   // <order>: a %GDataStreamByteOrder.
   void set_byte_order(DataStreamByteOrder order) {
      g_data_output_stream_set_byte_order(&this, order);
   }
}

struct DataOutputStreamClass {
   FilterOutputStreamClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct DataOutputStreamPrivate {
}


// #GDataStreamByteOrder is used to ensure proper endianness of streaming data sources
// across various machine architectures.
enum DataStreamByteOrder {
   BIG_ENDIAN = 0,
   LITTLE_ENDIAN = 1,
   HOST_ENDIAN = 2
}
// #GDataStreamNewlineType is used when checking for or setting the line endings for a given file.
enum DataStreamNewlineType {
   LF = 0,
   CR = 1,
   CR_LF = 2,
   ANY = 3
}

// #GDesktopAppInfo is an implementation of #GAppInfo based on
// desktop files.
// 
// Note that <filename>&lt;gio/gdesktopappinfo.h&gt;</filename> belongs to
// the UNIX-specific GIO interfaces, thus you have to use the
// <filename>gio-unix-2.0.pc</filename> pkg-config file when using it.
struct DesktopAppInfo /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new #GDesktopAppInfo based on a desktop file id.
   // 
   // A desktop file id is the basename of the desktop file, including the
   // .desktop extension. GIO is looking for a desktop file with this name
   // in the <filename>applications</filename> subdirectories of the XDG data
   // directories (i.e. the directories specified in the
   // <envar>XDG_DATA_HOME</envar> and <envar>XDG_DATA_DIRS</envar> environment
   // variables). GIO also supports the prefix-to-subdirectory mapping that is
   // described in the <ulink url="http://standards.freedesktop.org/menu-spec/latest/">Menu Spec</ulink>
   // (i.e. a desktop id of kde-foo.desktop will match
   // <filename>/usr/share/applications/kde/foo.desktop</filename>).
   // RETURNS: a new #GDesktopAppInfo, or %NULL if no desktop file with that id
   // <desktop_id>: the desktop file id
   static DesktopAppInfo* /*new*/ new_(char* desktop_id) {
      return g_desktop_app_info_new(desktop_id);
   }

   // Creates a new #GDesktopAppInfo.
   // RETURNS: a new #GDesktopAppInfo or %NULL on error.
   // <filename>: the path of a desktop file, in the GLib filename encoding
   static DesktopAppInfo* /*new*/ new_from_filename(char* filename) {
      return g_desktop_app_info_new_from_filename(filename);
   }

   // Creates a new #GDesktopAppInfo.
   // RETURNS: a new #GDesktopAppInfo or %NULL on error.
   // <key_file>: an opened #GKeyFile
   static DesktopAppInfo* /*new*/ new_from_keyfile(GLib2.KeyFile* key_file) {
      return g_desktop_app_info_new_from_keyfile(key_file);
   }

   // Sets the name of the desktop that the application is running in.
   // This is used by g_app_info_should_show() and
   // g_desktop_app_info_get_show_in() to evaluate the
   // <literal>OnlyShowIn</literal> and <literal>NotShowIn</literal>
   // desktop entry fields.
   // 
   // The <ulink url="http://standards.freedesktop.org/menu-spec/latest/">Desktop
   // Menu specification</ulink> recognizes the following:
   // <simplelist>
   // <member>GNOME</member>
   // <member>KDE</member>
   // <member>ROX</member>
   // <member>XFCE</member>
   // <member>Old</member>
   // </simplelist>
   // 
   // Should be called only once; subsequent calls are ignored.
   // <desktop_env>: a string specifying what desktop this is
   static void set_desktop_env(char* desktop_env) {
      g_desktop_app_info_set_desktop_env(desktop_env);
   }

   // Gets the categories from the desktop file.
   // 
   // i.e. no attempt is made to split it by ';' or validate it.
   // RETURNS: The unparsed Categories key from the desktop file;
   char* get_categories() {
      return g_desktop_app_info_get_categories(&this);
   }

   // When @info was created from a known filename, return it.  In some
   // situations such as the #GDesktopAppInfo returned from
   // g_desktop_app_info_new_from_keyfile(), this function will return %NULL.
   // RETURNS: The full path to the file for @info, or %NULL if not known.
   char* get_filename() {
      return g_desktop_app_info_get_filename(&this);
   }

   // Gets the generic name from the destkop file.
   // RETURNS: The value of the GenericName key
   char* get_generic_name() {
      return g_desktop_app_info_get_generic_name(&this);
   }

   // A desktop file is hidden if the Hidden key in it is
   // set to True.
   // RETURNS: %TRUE if hidden, %FALSE otherwise.
   int get_is_hidden() {
      return g_desktop_app_info_get_is_hidden(&this);
   }

   // Gets the value of the NoDisplay key, which helps determine if the
   // application info should be shown in menus. See
   // #G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY and g_app_info_should_show().
   // RETURNS: The value of the NoDisplay key
   int get_nodisplay() {
      return g_desktop_app_info_get_nodisplay(&this);
   }

   // Checks if the application info should be shown in menus that list available
   // applications for a specific name of the desktop, based on the
   // <literal>OnlyShowIn</literal> and <literal>NotShowIn</literal> keys.
   // 
   // If @desktop_env is %NULL, then the name of the desktop set with
   // g_desktop_app_info_set_desktop_env() is used.
   // 
   // Note that g_app_info_should_show() for @info will include this check (with
   // %NULL for @desktop_env) as well as additional checks.
   // 
   // <literal>OnlyShowIn</literal> and <literal>NotShowIn</literal> keys, %FALSE
   // otherwise.
   // RETURNS: %TRUE if the @info should be shown in @desktop_env according to the
   // <desktop_env>: a string specifying a desktop name
   int get_show_in(char* desktop_env) {
      return g_desktop_app_info_get_show_in(&this, desktop_env);
   }

   // This function performs the equivalent of g_app_info_launch_uris(),
   // but is intended primarily for operating system components that
   // launch applications.  Ordinary applications should use
   // g_app_info_launch_uris().
   // 
   // In contrast to g_app_info_launch_uris(), all processes created will
   // always be run directly as children as if by the UNIX fork()/exec()
   // calls.
   // 
   // This guarantee allows additional control over the exact environment
   // of the child processes, which is provided via a setup function
   // @setup, as well as the process identifier of each child process via
   // @pid_callback.  See g_spawn_async() for more information about the
   // semantics of the @setup function.
   // RETURNS: %TRUE on successful launch, %FALSE otherwise.
   // <uris>: List of URIs
   // <launch_context>: a #GAppLaunchContext
   // <spawn_flags>: #GSpawnFlags, used for each process
   // <user_setup>: a #GSpawnChildSetupFunc, used once for each process.
   // <user_setup_data>: User data for @user_setup
   // <pid_callback>: Callback for child processes
   // <pid_callback_data>: User data for @callback
   int launch_uris_as_manager(GLib2.List* uris, AppLaunchContext* launch_context, GLib2.SpawnFlags spawn_flags, GLib2.SpawnChildSetupFunc user_setup, void* user_setup_data, DesktopAppLaunchCallback pid_callback, void* pid_callback_data, GLib2.Error** error=null) {
      return g_desktop_app_info_launch_uris_as_manager(&this, uris, launch_context, spawn_flags, user_setup, user_setup_data, pid_callback, pid_callback_data, error);
   }
}

struct DesktopAppInfoClass {
   GObject2.ObjectClass parent_class;
}


// Interface that is used by backends to associate default
// handlers with URI schemes.
struct DesktopAppInfoLookup {

   // Gets the default application for launching applications
   // using this URI scheme for a particular GDesktopAppInfoLookup
   // implementation.
   // 
   // The GDesktopAppInfoLookup interface and this function is used
   // to implement g_app_info_get_default_for_uri_scheme() backends
   // in a GIO module. There is no reason for applications to use it
   // directly. Applications should use g_app_info_get_default_for_uri_scheme().
   // RETURNS: #GAppInfo for given @uri_scheme or %NULL on error.
   // <uri_scheme>: a string containing a URI scheme.
   AppInfo* /*new*/ get_default_for_uri_scheme(char* uri_scheme) {
      return g_desktop_app_info_lookup_get_default_for_uri_scheme(&this, uri_scheme);
   }
}

struct DesktopAppInfoLookupIface {
   GObject2.TypeInterface g_iface;

   // RETURNS: #GAppInfo for given @uri_scheme or %NULL on error.
   // <uri_scheme>: a string containing a URI scheme.
   extern (C) AppInfo* /*new*/ function (DesktopAppInfoLookup* lookup, char* uri_scheme) get_default_for_uri_scheme;
}


// During invocation, g_desktop_app_info_launch_uris_as_manager() may
// create one or more child processes.  This callback is invoked once
// for each, providing the process ID.
// <appinfo>: a #GDesktopAppInfo
// <pid>: Process identifier
// <user_data>: User data
extern (C) alias void function (DesktopAppInfo* appinfo, GLib2.Pid pid, void* user_data) DesktopAppLaunchCallback;


// #GDrive - this represent a piece of hardware connected to the machine.
// It's generally only created for removable hardware or hardware with
// removable media.
// 
// #GDrive is a container class for #GVolume objects that stem from
// the same piece of media. As such, #GDrive abstracts a drive with
// (or without) removable media and provides operations for querying
// whether media is available, determing whether media change is
// automatically detected and ejecting the media.
// 
// If the #GDrive reports that media isn't automatically detected, one
// can poll for media; typically one should not do this periodically
// as a poll for media operation is potententially expensive and may
// spin up the drive creating noise.
// 
// #GDrive supports starting and stopping drives with authentication
// support for the former. This can be used to support a diverse set
// of use cases including connecting/disconnecting iSCSI devices,
// powering down external disk enclosures and starting/stopping
// multi-disk devices such as RAID devices. Note that the actual
// semantics and side-effects of starting/stopping a #GDrive may vary
// according to implementation. To choose the correct verbs in e.g. a
// file manager, use g_drive_get_start_stop_type().
// 
// For porting from GnomeVFS note that there is no equivalent of
// #GDrive in that API.
struct Drive {

   // Checks if a drive can be ejected.
   // RETURNS: %TRUE if the @drive can be ejected, %FALSE otherwise.
   int can_eject() {
      return g_drive_can_eject(&this);
   }

   // Checks if a drive can be polled for media changes.
   // 
   // %FALSE otherwise.
   // RETURNS: %TRUE if the @drive can be polled for media changes,
   int can_poll_for_media() {
      return g_drive_can_poll_for_media(&this);
   }

   // Checks if a drive can be started.
   // RETURNS: %TRUE if the @drive can be started, %FALSE otherwise.
   int can_start() {
      return g_drive_can_start(&this);
   }

   // Checks if a drive can be started degraded.
   // RETURNS: %TRUE if the @drive can be started degraded, %FALSE otherwise.
   int can_start_degraded() {
      return g_drive_can_start_degraded(&this);
   }

   // Checks if a drive can be stopped.
   // RETURNS: %TRUE if the @drive can be stopped, %FALSE otherwise.
   int can_stop() {
      return g_drive_can_stop(&this);
   }

   // Asynchronously ejects a drive.
   // 
   // When the operation is finished, @callback will be called.
   // You can then call g_drive_eject_finish() to obtain the
   // result of the operation.
   // <flags>: flags affecting the unmount if required for eject
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data to pass to @callback
   void eject(MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_drive_eject(&this, flags, cancellable, callback, user_data);
   }

   // Finishes ejecting a drive.
   // 
   // %FALSE otherwise.
   // RETURNS: %TRUE if the drive has been ejected successfully,
   // <result>: a #GAsyncResult.
   int eject_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_drive_eject_finish(&this, result, error);
   }

   // Ejects a drive. This is an asynchronous operation, and is
   // finished by calling g_drive_eject_with_operation_finish() with the @drive
   // and #GAsyncResult data returned in the @callback.
   // <flags>: flags affecting the unmount if required for eject
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   void eject_with_operation(MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_drive_eject_with_operation(&this, flags, mount_operation, cancellable, callback, user_data);
   }

   // Finishes ejecting a drive. If any errors occurred during the operation,
   // @error will be set to contain the errors and %FALSE will be returned.
   // RETURNS: %TRUE if the drive was successfully ejected. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   int eject_with_operation_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_drive_eject_with_operation_finish(&this, result, error);
   }

   // Gets the kinds of identifiers that @drive has.
   // Use g_drive_get_identifer() to obtain the identifiers
   // themselves.
   // 
   // array of strings containing kinds of identifiers. Use g_strfreev()
   // to free.
   // RETURNS: a %NULL-terminated
   char** /*new*/ enumerate_identifiers() {
      return g_drive_enumerate_identifiers(&this);
   }

   // Gets the icon for @drive.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: #GIcon for the @drive.
   Icon* /*new*/ get_icon() {
      return g_drive_get_icon(&this);
   }

   // Gets the identifier of the given kind for @drive.
   // 
   // requested identfier, or %NULL if the #GDrive
   // doesn't have this kind of identifier.
   // RETURNS: a newly allocated string containing the
   // <kind>: the kind of identifier to return
   char* /*new*/ get_identifier(char* kind) {
      return g_drive_get_identifier(&this, kind);
   }

   // Gets the name of @drive.
   // 
   // string should be freed when no longer needed.
   // RETURNS: a string containing @drive's name. The returned
   char* /*new*/ get_name() {
      return g_drive_get_name(&this);
   }

   // Gets a hint about how a drive can be started/stopped.
   // RETURNS: A value from the #GDriveStartStopType enumeration.
   DriveStartStopType get_start_stop_type() {
      return g_drive_get_start_stop_type(&this);
   }

   // Get a list of mountable volumes for @drive.
   // 
   // The returned list should be freed with g_list_free(), after
   // its elements have been unreffed with g_object_unref().
   // RETURNS: #GList containing any #GVolume objects on the given @drive.
   GLib2.List* /*new*/ get_volumes() {
      return g_drive_get_volumes(&this);
   }

   // Checks if the @drive has media. Note that the OS may not be polling
   // the drive for media changes; see g_drive_is_media_check_automatic()
   // for more details.
   // RETURNS: %TRUE if @drive has media, %FALSE otherwise.
   int has_media() {
      return g_drive_has_media(&this);
   }

   // Check if @drive has any mountable volumes.
   // RETURNS: %TRUE if the @drive contains volumes, %FALSE otherwise.
   int has_volumes() {
      return g_drive_has_volumes(&this);
   }

   // Checks if @drive is capabable of automatically detecting media changes.
   // 
   // media changes, %FALSE otherwise.
   // RETURNS: %TRUE if the @drive is capabable of automatically detecting
   int is_media_check_automatic() {
      return g_drive_is_media_check_automatic(&this);
   }

   // Checks if the @drive supports removable media.
   // RETURNS: %TRUE if @drive supports removable media, %FALSE otherwise.
   int is_media_removable() {
      return g_drive_is_media_removable(&this);
   }

   // Asynchronously polls @drive to see if media has been inserted or removed.
   // 
   // When the operation is finished, @callback will be called.
   // You can then call g_drive_poll_for_media_finish() to obtain the
   // result of the operation.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data to pass to @callback
   void poll_for_media(Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_drive_poll_for_media(&this, cancellable, callback, user_data);
   }

   // Finishes an operation started with g_drive_poll_for_media() on a drive.
   // 
   // %FALSE otherwise.
   // RETURNS: %TRUE if the drive has been poll_for_mediaed successfully,
   // <result>: a #GAsyncResult.
   int poll_for_media_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_drive_poll_for_media_finish(&this, result, error);
   }

   // Asynchronously starts a drive.
   // 
   // When the operation is finished, @callback will be called.
   // You can then call g_drive_start_finish() to obtain the
   // result of the operation.
   // <flags>: flags affecting the start operation.
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data to pass to @callback
   void start(DriveStartFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_drive_start(&this, flags, mount_operation, cancellable, callback, user_data);
   }

   // Finishes starting a drive.
   // 
   // %FALSE otherwise.
   // RETURNS: %TRUE if the drive has been started successfully,
   // <result>: a #GAsyncResult.
   int start_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_drive_start_finish(&this, result, error);
   }

   // Asynchronously stops a drive.
   // 
   // When the operation is finished, @callback will be called.
   // You can then call g_drive_stop_finish() to obtain the
   // result of the operation.
   // <flags>: flags affecting the unmount if required for stopping.
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data to pass to @callback
   void stop(MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_drive_stop(&this, flags, mount_operation, cancellable, callback, user_data);
   }

   // Finishes stopping a drive.
   // 
   // %FALSE otherwise.
   // RETURNS: %TRUE if the drive has been stopped successfully,
   // <result>: a #GAsyncResult.
   int stop_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_drive_stop_finish(&this, result, error);
   }
   // Emitted when the drive's state has changed.
   extern (C) alias static void function (Drive* this_, void* user_data=null) signal_changed;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"changed", CB:signal_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when the #GDrive have been
   // disconnected. If the recipient is holding references to the
   // object they should release them so the object can be
   // finalized.
   extern (C) alias static void function (Drive* this_, void* user_data=null) signal_disconnected;
   ulong signal_connect(string name:"disconnected", CB:signal_disconnected)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"disconnected",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when the physical eject button (if any) of a drive has
   // been pressed.
   extern (C) alias static void function (Drive* this_, void* user_data=null) signal_eject_button;
   ulong signal_connect(string name:"eject-button", CB:signal_eject_button)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"eject-button",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when the physical stop button (if any) of a drive has
   // been pressed.
   extern (C) alias static void function (Drive* this_, void* user_data=null) signal_stop_button;
   ulong signal_connect(string name:"stop-button", CB:signal_stop_button)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"stop-button",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

// Interface for creating #GDrive implementations.
struct DriveIface {
   GObject2.TypeInterface g_iface;
   extern (C) void function (Drive* drive) changed;
   extern (C) void function (Drive* drive) disconnected;
   extern (C) void function (Drive* drive) eject_button;
   // RETURNS: a string containing @drive's name. The returned
   extern (C) char* /*new*/ function (Drive* drive) get_name;
   // RETURNS: #GIcon for the @drive.
   extern (C) Icon* /*new*/ function (Drive* drive) get_icon;
   // RETURNS: %TRUE if the @drive contains volumes, %FALSE otherwise.
   extern (C) int function (Drive* drive) has_volumes;
   // RETURNS: #GList containing any #GVolume objects on the given @drive.
   extern (C) GLib2.List* /*new*/ function (Drive* drive) get_volumes;
   // RETURNS: %TRUE if @drive supports removable media, %FALSE otherwise.
   extern (C) int function (Drive* drive) is_media_removable;
   // RETURNS: %TRUE if @drive has media, %FALSE otherwise.
   extern (C) int function (Drive* drive) has_media;
   // RETURNS: %TRUE if the @drive is capabable of automatically detecting
   extern (C) int function (Drive* drive) is_media_check_automatic;
   // RETURNS: %TRUE if the @drive can be ejected, %FALSE otherwise.
   extern (C) int function (Drive* drive) can_eject;
   // RETURNS: %TRUE if the @drive can be polled for media changes,
   extern (C) int function (Drive* drive) can_poll_for_media;

   // <flags>: flags affecting the unmount if required for eject
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data to pass to @callback
   extern (C) void function (Drive* drive, MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) eject;

   // RETURNS: %TRUE if the drive has been ejected successfully,
   // <result>: a #GAsyncResult.
   extern (C) int function (Drive* drive, AsyncResult* result, GLib2.Error** error=null) eject_finish;

   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data to pass to @callback
   extern (C) void function (Drive* drive, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) poll_for_media;

   // RETURNS: %TRUE if the drive has been poll_for_mediaed successfully,
   // <result>: a #GAsyncResult.
   extern (C) int function (Drive* drive, AsyncResult* result, GLib2.Error** error=null) poll_for_media_finish;

   // RETURNS: a newly allocated string containing the
   // <kind>: the kind of identifier to return
   extern (C) char* /*new*/ function (Drive* drive, char* kind) get_identifier;
   // RETURNS: a %NULL-terminated
   extern (C) char** /*new*/ function (Drive* drive) enumerate_identifiers;
   // RETURNS: A value from the #GDriveStartStopType enumeration.
   extern (C) DriveStartStopType function (Drive* drive) get_start_stop_type;
   // RETURNS: %TRUE if the @drive can be started, %FALSE otherwise.
   extern (C) int function (Drive* drive) can_start;
   // RETURNS: %TRUE if the @drive can be started degraded, %FALSE otherwise.
   extern (C) int function (Drive* drive) can_start_degraded;

   // <flags>: flags affecting the start operation.
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data to pass to @callback
   extern (C) void function (Drive* drive, DriveStartFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) start;

   // RETURNS: %TRUE if the drive has been started successfully,
   // <result>: a #GAsyncResult.
   extern (C) int function (Drive* drive, AsyncResult* result, GLib2.Error** error=null) start_finish;
   // RETURNS: %TRUE if the @drive can be stopped, %FALSE otherwise.
   extern (C) int function (Drive* drive) can_stop;

   // <flags>: flags affecting the unmount if required for stopping.
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data to pass to @callback
   extern (C) void function (Drive* drive, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) stop;

   // RETURNS: %TRUE if the drive has been stopped successfully,
   // <result>: a #GAsyncResult.
   extern (C) int function (Drive* drive, AsyncResult* result, GLib2.Error** error=null) stop_finish;
   extern (C) void function (Drive* drive) stop_button;

   // <flags>: flags affecting the unmount if required for eject
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   extern (C) void function (Drive* drive, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) eject_with_operation;

   // RETURNS: %TRUE if the drive was successfully ejected. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   extern (C) int function (Drive* drive, AsyncResult* result, GLib2.Error** error=null) eject_with_operation_finish;
}

// Flags used when starting a drive.
enum DriveStartFlags /* Version 2.22 */ {
   NONE = 0
}
// Enumeration describing how a drive can be started/stopped.
enum DriveStartStopType /* Version 2.22 */ {
   UNKNOWN = 0,
   SHUTDOWN = 1,
   NETWORK = 2,
   MULTIDISK = 3,
   PASSWORD = 4
}

// #GEmblem is an implementation of #GIcon that supports
// having an emblem, which is an icon with additional properties.
// It can than be added to a #GEmblemedIcon.
// 
// Currently, only metainformation about the emblem's origin is
// supported. More may be added in the future.
struct Emblem /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new emblem for @icon.
   // RETURNS: a new #GEmblem.
   // <icon>: a GIcon containing the icon.
   static Emblem* /*new*/ new_(Icon* icon) {
      return g_emblem_new(icon);
   }

   // Creates a new emblem for @icon.
   // RETURNS: a new #GEmblem.
   // <icon>: a GIcon containing the icon.
   // <origin>: a GEmblemOrigin enum defining the emblem's origin
   static Emblem* /*new*/ new_with_origin(Icon* icon, EmblemOrigin origin) {
      return g_emblem_new_with_origin(icon, origin);
   }

   // Gives back the icon from @emblem.
   // 
   // the emblem and should not be modified or freed.
   // RETURNS: a #GIcon. The returned object belongs to
   Icon* get_icon() {
      return g_emblem_get_icon(&this);
   }

   // Gets the origin of the emblem.
   // RETURNS: the origin of the emblem
   EmblemOrigin get_origin() {
      return g_emblem_get_origin(&this);
   }
}

struct EmblemClass {
}


// GEmblemOrigin is used to add information about the origin of the emblem
// to #GEmblem.
enum EmblemOrigin /* Version 2.18 */ {
   UNKNOWN = 0,
   DEVICE = 1,
   LIVEMETADATA = 2,
   TAG = 3
}

// #GEmblemedIcon is an implementation of #GIcon that supports
// adding an emblem to an icon. Adding multiple emblems to an
// icon is ensured via g_emblemed_icon_add_emblem().
// 
// Note that #GEmblemedIcon allows no control over the position
// of the emblems. See also #GEmblem for more information.
struct EmblemedIcon /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private EmblemedIconPrivate* priv;


   // Creates a new emblemed icon for @icon with the emblem @emblem.
   // RETURNS: a new #GIcon
   // <icon>: a #GIcon
   // <emblem>: a #GEmblem, or %NULL
   static Icon* /*new*/ new_(Icon* icon, Emblem* emblem=null) {
      return g_emblemed_icon_new(icon, emblem);
   }

   // Adds @emblem to the #GList of #GEmblem <!-- -->s.
   // <emblem>: a #GEmblem
   void add_emblem(Emblem* emblem) {
      g_emblemed_icon_add_emblem(&this, emblem);
   }
   // Removes all the emblems from @icon.
   void clear_emblems() {
      g_emblemed_icon_clear_emblems(&this);
   }

   // Gets the list of emblems for the @icon.
   // 
   // #GEmblem <!-- -->s that is owned by @emblemed
   // RETURNS: a #GList of
   GLib2.List* get_emblems() {
      return g_emblemed_icon_get_emblems(&this);
   }

   // Gets the main icon for @emblemed.
   // RETURNS: a #GIcon that is owned by @emblemed
   Icon* get_icon() {
      return g_emblemed_icon_get_icon(&this);
   }
}

struct EmblemedIconClass {
   GObject2.ObjectClass parent_class;
}

struct EmblemedIconPrivate {
}

enum FILE_ATTRIBUTE_ACCESS_CAN_DELETE = "access::can-delete";
enum FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE = "access::can-execute";
enum FILE_ATTRIBUTE_ACCESS_CAN_READ = "access::can-read";
enum FILE_ATTRIBUTE_ACCESS_CAN_RENAME = "access::can-rename";
enum FILE_ATTRIBUTE_ACCESS_CAN_TRASH = "access::can-trash";
enum FILE_ATTRIBUTE_ACCESS_CAN_WRITE = "access::can-write";
enum FILE_ATTRIBUTE_DOS_IS_ARCHIVE = "dos::is-archive";
enum FILE_ATTRIBUTE_DOS_IS_SYSTEM = "dos::is-system";
enum FILE_ATTRIBUTE_ETAG_VALUE = "etag::value";
enum FILE_ATTRIBUTE_FILESYSTEM_FREE = "filesystem::free";
enum FILE_ATTRIBUTE_FILESYSTEM_READONLY = "filesystem::readonly";
enum FILE_ATTRIBUTE_FILESYSTEM_SIZE = "filesystem::size";
enum FILE_ATTRIBUTE_FILESYSTEM_TYPE = "filesystem::type";
enum FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW = "filesystem::use-preview";
enum FILE_ATTRIBUTE_GVFS_BACKEND = "gvfs::backend";
enum FILE_ATTRIBUTE_ID_FILE = "id::file";
enum FILE_ATTRIBUTE_ID_FILESYSTEM = "id::filesystem";
enum FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT = "mountable::can-eject";
enum FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT = "mountable::can-mount";
enum FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL = "mountable::can-poll";
enum FILE_ATTRIBUTE_MOUNTABLE_CAN_START = "mountable::can-start";
enum FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED = "mountable::can-start-degraded";
enum FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP = "mountable::can-stop";
enum FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT = "mountable::can-unmount";
enum FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI = "mountable::hal-udi";
enum FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC = "mountable::is-media-check-automatic";
enum FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE = "mountable::start-stop-type";
enum FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE = "mountable::unix-device";
enum FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE = "mountable::unix-device-file";
enum FILE_ATTRIBUTE_OWNER_GROUP = "owner::group";
enum FILE_ATTRIBUTE_OWNER_USER = "owner::user";
enum FILE_ATTRIBUTE_OWNER_USER_REAL = "owner::user-real";
enum FILE_ATTRIBUTE_PREVIEW_ICON = "preview::icon";
enum FILE_ATTRIBUTE_SELINUX_CONTEXT = "selinux::context";
enum FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE = "standard::allocated-size";
enum FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE = "standard::content-type";
enum FILE_ATTRIBUTE_STANDARD_COPY_NAME = "standard::copy-name";
enum FILE_ATTRIBUTE_STANDARD_DESCRIPTION = "standard::description";
enum FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME = "standard::display-name";
enum FILE_ATTRIBUTE_STANDARD_EDIT_NAME = "standard::edit-name";
enum FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE = "standard::fast-content-type";
enum FILE_ATTRIBUTE_STANDARD_ICON = "standard::icon";
enum FILE_ATTRIBUTE_STANDARD_IS_BACKUP = "standard::is-backup";
enum FILE_ATTRIBUTE_STANDARD_IS_HIDDEN = "standard::is-hidden";
enum FILE_ATTRIBUTE_STANDARD_IS_SYMLINK = "standard::is-symlink";
enum FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL = "standard::is-virtual";
enum FILE_ATTRIBUTE_STANDARD_NAME = "standard::name";
enum FILE_ATTRIBUTE_STANDARD_SIZE = "standard::size";
enum FILE_ATTRIBUTE_STANDARD_SORT_ORDER = "standard::sort-order";
enum FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET = "standard::symlink-target";
enum FILE_ATTRIBUTE_STANDARD_TARGET_URI = "standard::target-uri";
enum FILE_ATTRIBUTE_STANDARD_TYPE = "standard::type";
enum FILE_ATTRIBUTE_THUMBNAILING_FAILED = "thumbnail::failed";
enum FILE_ATTRIBUTE_THUMBNAIL_PATH = "thumbnail::path";
enum FILE_ATTRIBUTE_TIME_ACCESS = "time::access";
enum FILE_ATTRIBUTE_TIME_ACCESS_USEC = "time::access-usec";
enum FILE_ATTRIBUTE_TIME_CHANGED = "time::changed";
enum FILE_ATTRIBUTE_TIME_CHANGED_USEC = "time::changed-usec";
enum FILE_ATTRIBUTE_TIME_CREATED = "time::created";
enum FILE_ATTRIBUTE_TIME_CREATED_USEC = "time::created-usec";
enum FILE_ATTRIBUTE_TIME_MODIFIED = "time::modified";
enum FILE_ATTRIBUTE_TIME_MODIFIED_USEC = "time::modified-usec";
enum FILE_ATTRIBUTE_TRASH_DELETION_DATE = "trash::deletion-date";
enum FILE_ATTRIBUTE_TRASH_ITEM_COUNT = "trash::item-count";
enum FILE_ATTRIBUTE_TRASH_ORIG_PATH = "trash::orig-path";
enum FILE_ATTRIBUTE_UNIX_BLOCKS = "unix::blocks";
enum FILE_ATTRIBUTE_UNIX_BLOCK_SIZE = "unix::block-size";
enum FILE_ATTRIBUTE_UNIX_DEVICE = "unix::device";
enum FILE_ATTRIBUTE_UNIX_GID = "unix::gid";
enum FILE_ATTRIBUTE_UNIX_INODE = "unix::inode";
enum FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT = "unix::is-mountpoint";
enum FILE_ATTRIBUTE_UNIX_MODE = "unix::mode";
enum FILE_ATTRIBUTE_UNIX_NLINK = "unix::nlink";
enum FILE_ATTRIBUTE_UNIX_RDEV = "unix::rdev";
enum FILE_ATTRIBUTE_UNIX_UID = "unix::uid";

// #GFile is a high level abstraction for manipulating files on a
// virtual file system. #GFile<!-- -->s are lightweight, immutable
// objects that do no I/O upon creation. It is necessary to understand that
// #GFile objects do not represent files, merely an identifier for a file. All
// file content I/O is implemented as streaming operations (see #GInputStream and
// #GOutputStream).
// 
// To construct a #GFile, you can use:
// g_file_new_for_path() if you have a path.
// g_file_new_for_uri() if you have a URI.
// g_file_new_for_commandline_arg() for a command line argument.
// g_file_parse_name() from a utf8 string gotten from g_file_get_parse_name().
// 
// One way to think of a #GFile is as an abstraction of a pathname. For normal
// files the system pathname is what is stored internally, but as #GFile<!-- -->s
// are extensible it could also be something else that corresponds to a pathname
// in a userspace implementation of a filesystem.
// 
// #GFile<!-- -->s make up hierarchies of directories and files that correspond to the
// files on a filesystem. You can move through the file system with #GFile using
// g_file_get_parent() to get an identifier for the parent directory, g_file_get_child()
// to get a child within a directory, g_file_resolve_relative_path() to resolve a relative
// path between two #GFile<!-- -->s. There can be multiple hierarchies, so you may not
// end up at the same root if you repeatedly call g_file_get_parent() on two different
// files.
// 
// All #GFile<!-- -->s have a basename (get with g_file_get_basename()). These names
// are byte strings that are used to identify the file on the filesystem (relative to
// its parent directory) and there is no guarantees that they have any particular charset
// encoding or even make any sense at all. If you want to use filenames in a user
// interface you should use the display name that you can get by requesting the
// %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME attribute with g_file_query_info().
// This is guaranteed to be in utf8 and can be used in a user interface. But always
// store the real basename or the #GFile to use to actually access the file, because
// there is no way to go from a display name to the actual name.
// 
// Using #GFile as an identifier has the same weaknesses as using a path in that
// there may be multiple aliases for the same file. For instance, hard or
// soft links may cause two different #GFile<!-- -->s to refer to the same file.
// Other possible causes for aliases are: case insensitive filesystems, short
// and long names on Fat/NTFS, or bind mounts in Linux. If you want to check if
// two #GFile<!-- -->s point to the same file you can query for the
// %G_FILE_ATTRIBUTE_ID_FILE attribute. Note that #GFile does some trivial
// canonicalization of pathnames passed in, so that trivial differences in the
// path string used at creation (duplicated slashes, slash at end of path, "."
// or ".." path segments, etc) does not create different #GFile<!-- -->s.
// 
// Many #GFile operations have both synchronous and asynchronous versions
// to suit your application. Asynchronous versions of synchronous functions
// simply have _async() appended to their function names. The asynchronous
// I/O functions call a #GAsyncReadyCallback which is then used to finalize
// the operation, producing a GAsyncResult which is then passed to the
// function's matching _finish() operation.
// 
// Some #GFile operations do not have synchronous analogs, as they may
// take a very long time to finish, and blocking may leave an application
// unusable. Notable cases include:
// g_file_mount_mountable() to mount a mountable file.
// g_file_unmount_mountable_with_operation() to unmount a mountable file.
// g_file_eject_mountable_with_operation() to eject a mountable file.
// 
// <para id="gfile-etag"><indexterm><primary>entity tag</primary></indexterm>
// One notable feature of #GFile<!-- -->s are entity tags, or "etags" for
// short. Entity tags are somewhat like a more abstract version of the
// traditional mtime, and can be used to quickly determine if the file has
// been modified from the version on the file system. See the HTTP 1.1
// <ulink url="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html">specification</ulink>
// for HTTP Etag headers, which are a very similar concept.
// </para>
struct File {

   // Creates a hash value for a #GFile.
   // 
   // This call does no blocking i/o.
   // 
   // integer that can be used as hash value for the #GFile.
   // This function is intended for easily hashing a #GFile to
   // add to a #GHashTable or similar data structure.
   // RETURNS: 0 if @file is not a valid #GFile, otherwise an
   // <file>: #gconstpointer to a #GFile.
   static uint hash(const(void)* file) {
      return g_file_hash(file);
   }

   // Creates a #GFile with the given argument from the command line. The value of
   // @arg can be either a URI, an absolute path or a relative path resolved
   // relative to the current working directory.
   // This operation never fails, but the returned object might not support any
   // I/O operation if @arg points to a malformed path.
   // RETURNS: a new #GFile.
   // <arg>: a command line string.
   static File* /*new*/ new_for_commandline_arg(char* arg) {
      return g_file_new_for_commandline_arg(arg);
   }

   // Constructs a #GFile for a given path. This operation never
   // fails, but the returned object might not support any I/O
   // operation if @path is malformed.
   // RETURNS: a new #GFile for the given @path.
   // <path>: a string containing a relative or absolute path. The string must be encoded in the glib filename encoding.
   static File* /*new*/ new_for_path(char* path) {
      return g_file_new_for_path(path);
   }

   // Constructs a #GFile for a given URI. This operation never
   // fails, but the returned object might not support any I/O
   // operation if @uri is malformed or if the uri type is
   // not supported.
   // RETURNS: a #GFile for the given @uri.
   // <uri>: a UTF8 string containing a URI.
   static File* /*new*/ new_for_uri(char* uri) {
      return g_file_new_for_uri(uri);
   }

   // Constructs a #GFile with the given @parse_name (i.e. something given by g_file_get_parse_name()).
   // This operation never fails, but the returned object might not support any I/O
   // operation if the @parse_name cannot be parsed.
   // RETURNS: a new #GFile.
   // <parse_name>: a file name or path to be parsed.
   static File* /*new*/ parse_name(char* parse_name) {
      return g_file_parse_name(parse_name);
   }

   // Gets an output stream for appending data to the file. If
   // the file doesn't already exist it is created.
   // 
   // By default files created are generally readable by everyone,
   // but if you pass #G_FILE_CREATE_PRIVATE in @flags the file
   // will be made readable only to the current user, to the level that
   // is supported on the target filesystem.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // Some file systems don't allow all file names, and may
   // return an %G_IO_ERROR_INVALID_FILENAME error.
   // If the file is a directory the %G_IO_ERROR_IS_DIRECTORY error will be
   // returned. Other errors are possible too, and depend on what kind of
   // filesystem the file is on.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileOutputStream, or %NULL on error.
   // <flags>: a set of #GFileCreateFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileOutputStream* /*new*/ append_to(FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_append_to(&this, flags, cancellable, error);
   }

   // Asynchronously opens @file for appending.
   // 
   // For more details, see g_file_append_to() which is
   // the synchronous version of this call.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_append_to_finish() to get the result of the operation.
   // <flags>: a set of #GFileCreateFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void append_to_async(FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_append_to_async(&this, flags, io_priority, cancellable, callback, user_data);
   }

   // Finishes an asynchronous file append operation started with
   // g_file_append_to_async().
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a valid #GFileOutputStream or %NULL on error.
   // <res>: #GAsyncResult
   FileOutputStream* /*new*/ append_to_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_file_append_to_finish(&this, res, error);
   }

   // Copies the file @source to the location specified by @destination.
   // Can not handle recursive copies of directories.
   // 
   // If the flag #G_FILE_COPY_OVERWRITE is specified an already
   // existing @destination file is overwritten.
   // 
   // If the flag #G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks
   // will be copied as symlinks, otherwise the target of the
   // @source symlink will be copied.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // If @progress_callback is not %NULL, then the operation can be monitored by
   // setting this to a #GFileProgressCallback function. @progress_callback_data
   // will be passed to this function. It is guaranteed that this callback will
   // be called after all data has been transferred with the total number of bytes
   // copied during the operation.
   // 
   // If the @source file does not exist then the G_IO_ERROR_NOT_FOUND
   // error is returned, independent on the status of the @destination.
   // 
   // If #G_FILE_COPY_OVERWRITE is not specified and the target exists, then the
   // error G_IO_ERROR_EXISTS is returned.
   // 
   // If trying to overwrite a file over a directory the G_IO_ERROR_IS_DIRECTORY
   // error is returned. If trying to overwrite a directory with a directory the
   // G_IO_ERROR_WOULD_MERGE error is returned.
   // 
   // If the source is a directory and the target does not exist, or #G_FILE_COPY_OVERWRITE is
   // specified and the target is a file, then the G_IO_ERROR_WOULD_RECURSE error
   // is returned.
   // 
   // If you are interested in copying the #GFile object itself (not the on-disk
   // file), see g_file_dup().
   // RETURNS: %TRUE on success, %FALSE otherwise.
   // <destination>: destination #GFile
   // <flags>: set of #GFileCopyFlags
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <progress_callback>: function to callback with progress information
   // <progress_callback_data>: user data to pass to @progress_callback
   int copy(File* destination, FileCopyFlags flags, Cancellable* cancellable, FileProgressCallback progress_callback, void* progress_callback_data, GLib2.Error** error=null) {
      return g_file_copy(&this, destination, flags, cancellable, progress_callback, progress_callback_data, error);
   }

   // Unintrospectable method: copy_async() / g_file_copy_async()
   // Copies the file @source to the location specified by @destination
   // asynchronously. For details of the behaviour, see g_file_copy().
   // 
   // If @progress_callback is not %NULL, then that function that will be called
   // just like in g_file_copy(), however the callback will run in the main loop,
   // not in the thread that is doing the I/O operation.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_copy_finish() to get the result of the operation.
   // <destination>: destination #GFile
   // <flags>: set of #GFileCopyFlags
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <progress_callback>: function to callback with progress information
   // <progress_callback_data>: user data to pass to @progress_callback
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void copy_async(File* destination, FileCopyFlags flags, int io_priority, Cancellable* cancellable, FileProgressCallback progress_callback, void* progress_callback_data, AsyncReadyCallback callback, void* user_data) {
      g_file_copy_async(&this, destination, flags, io_priority, cancellable, progress_callback, progress_callback_data, callback, user_data);
   }

   // Copies the file attributes from @source to @destination.
   // 
   // Normally only a subset of the file attributes are copied,
   // those that are copies in a normal file copy operation
   // (which for instance does not include e.g. owner). However
   // if #G_FILE_COPY_ALL_METADATA is specified in @flags, then
   // all the metadata that is possible to copy is copied. This
   // is useful when implementing move by copy + delete source.
   // RETURNS: %TRUE if the attributes were copied successfully, %FALSE otherwise.
   // <destination>: a #GFile to copy attributes to.
   // <flags>: a set of #GFileCopyFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int copy_attributes(File* destination, FileCopyFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_copy_attributes(&this, destination, flags, cancellable, error);
   }

   // Finishes copying the file started with
   // g_file_copy_async().
   // RETURNS: a %TRUE on success, %FALSE on error.
   // <res>: a #GAsyncResult.
   int copy_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_file_copy_finish(&this, res, error);
   }

   // Creates a new file and returns an output stream for writing to it.
   // The file must not already exist.
   // 
   // By default files created are generally readable by everyone,
   // but if you pass #G_FILE_CREATE_PRIVATE in @flags the file
   // will be made readable only to the current user, to the level that
   // is supported on the target filesystem.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // If a file or directory with this name already exists the G_IO_ERROR_EXISTS
   // error will be returned.
   // Some file systems don't allow all file names, and may
   // return an G_IO_ERROR_INVALID_FILENAME error, and if the name
   // is to long G_IO_ERROR_FILENAME_TOO_LONG will be returned.
   // Other errors are possible too, and depend on what kind of
   // filesystem the file is on.
   // 
   // %NULL on error.
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileOutputStream for the newly created file, or
   // <flags>: a set of #GFileCreateFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileOutputStream* /*new*/ create(FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_create(&this, flags, cancellable, error);
   }

   // Asynchronously creates a new file and returns an output stream for writing to it.
   // The file must not already exist.
   // 
   // For more details, see g_file_create() which is
   // the synchronous version of this call.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_create_finish() to get the result of the operation.
   // <flags>: a set of #GFileCreateFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void create_async(FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_create_async(&this, flags, io_priority, cancellable, callback, user_data);
   }

   // Finishes an asynchronous file create operation started with
   // g_file_create_async().
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileOutputStream or %NULL on error.
   // <res>: a #GAsyncResult.
   FileOutputStream* /*new*/ create_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_file_create_finish(&this, res, error);
   }

   // Creates a new file and returns a stream for reading and writing to it.
   // The file must not already exist.
   // 
   // By default files created are generally readable by everyone,
   // but if you pass #G_FILE_CREATE_PRIVATE in @flags the file
   // will be made readable only to the current user, to the level that
   // is supported on the target filesystem.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // If a file or directory with this name already exists the %G_IO_ERROR_EXISTS
   // error will be returned. Some file systems don't allow all file names,
   // and may return an %G_IO_ERROR_INVALID_FILENAME error, and if the name
   // is too long, %G_IO_ERROR_FILENAME_TOO_LONG will be returned. Other errors
   // are possible too, and depend on what kind of filesystem the file is on.
   // 
   // Note that in many non-local file cases read and write streams are not
   // supported, so make sure you really need to do read and write streaming,
   // rather than just opening for reading or writing.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileIOStream for the newly created file, or %NULL on error.
   // <flags>: a set of #GFileCreateFlags
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   FileIOStream* /*new*/ create_readwrite(FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_create_readwrite(&this, flags, cancellable, error);
   }

   // Asynchronously creates a new file and returns a stream for reading and
   // writing to it. The file must not already exist.
   // 
   // For more details, see g_file_create_readwrite() which is
   // the synchronous version of this call.
   // 
   // When the operation is finished, @callback will be called. You can then
   // call g_file_create_readwrite_finish() to get the result of the operation.
   // <flags>: a set of #GFileCreateFlags
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void create_readwrite_async(FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_create_readwrite_async(&this, flags, io_priority, cancellable, callback, user_data);
   }

   // Finishes an asynchronous file create operation started with
   // g_file_create_readwrite_async().
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileIOStream or %NULL on error.
   // <res>: a #GAsyncResult
   FileIOStream* /*new*/ create_readwrite_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_file_create_readwrite_finish(&this, res, error);
   }

   // Deletes a file. If the @file is a directory, it will only be deleted if it
   // is empty.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // RETURNS: %TRUE if the file was deleted. %FALSE otherwise.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int delete_(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_delete(&this, cancellable, error);
   }

   // Duplicates a #GFile handle. This operation does not duplicate
   // the actual file or directory represented by the #GFile; see
   // g_file_copy() if attempting to copy a file.
   // 
   // This call does no blocking i/o.
   // RETURNS: a new #GFile that is a duplicate of the given #GFile.
   File* /*new*/ dup() {
      return g_file_dup(&this);
   }

   // Starts an asynchronous eject on a mountable.
   // When this operation has completed, @callback will be called with
   // @user_user data, and the operation can be finalized with
   // g_file_eject_mountable_finish().
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // <flags>: flags affecting the operation
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   void eject_mountable(MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_eject_mountable(&this, flags, cancellable, callback, user_data);
   }

   // Finishes an asynchronous eject operation started by
   // g_file_eject_mountable().
   // 
   // otherwise.
   // RETURNS: %TRUE if the @file was ejected successfully. %FALSE
   // <result>: a #GAsyncResult.
   int eject_mountable_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_eject_mountable_finish(&this, result, error);
   }

   // Starts an asynchronous eject on a mountable.
   // When this operation has completed, @callback will be called with
   // @user_user data, and the operation can be finalized with
   // g_file_eject_mountable_with_operation_finish().
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation, or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   void eject_mountable_with_operation(MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_eject_mountable_with_operation(&this, flags, mount_operation, cancellable, callback, user_data);
   }

   // Finishes an asynchronous eject operation started by
   // g_file_eject_mountable_with_operation().
   // 
   // otherwise.
   // RETURNS: %TRUE if the @file was ejected successfully. %FALSE
   // <result>: a #GAsyncResult.
   int eject_mountable_with_operation_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_eject_mountable_with_operation_finish(&this, result, error);
   }

   // Gets the requested information about the files in a directory. The result
   // is a #GFileEnumerator object that will give out #GFileInfo objects for
   // all the files in the directory.
   // 
   // The @attributes value is a string that specifies the file attributes that
   // should be gathered. It is not an error if it's not possible to read a particular
   // requested attribute from a file - it just won't be set. @attributes should
   // be a comma-separated list of attributes or attribute wildcards. The wildcard "*"
   // means all attributes, and a wildcard like "standard::*" means all attributes in the standard
   // namespace. An example attribute query be "standard::*,owner::user".
   // The standard attributes are available as defines, like #G_FILE_ATTRIBUTE_STANDARD_NAME.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
   // If the file is not a directory, the G_FILE_ERROR_NOTDIR error will be returned.
   // Other errors are possible too.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: A #GFileEnumerator if successful, %NULL on error.
   // <attributes>: an attribute query string.
   // <flags>: a set of #GFileQueryInfoFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileEnumerator* /*new*/ enumerate_children(char* attributes, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_enumerate_children(&this, attributes, flags, cancellable, error);
   }

   // Asynchronously gets the requested information about the files in a directory. The result
   // is a #GFileEnumerator object that will give out #GFileInfo objects for
   // all the files in the directory.
   // 
   // For more details, see g_file_enumerate_children() which is
   // the synchronous version of this call.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_enumerate_children_finish() to get the result of the operation.
   // <attributes>: an attribute query string.
   // <flags>: a set of #GFileQueryInfoFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void enumerate_children_async(char* attributes, FileQueryInfoFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_enumerate_children_async(&this, attributes, flags, io_priority, cancellable, callback, user_data);
   }

   // Finishes an async enumerate children operation.
   // See g_file_enumerate_children_async().
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileEnumerator or %NULL if an error occurred.
   // <res>: a #GAsyncResult.
   FileEnumerator* /*new*/ enumerate_children_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_file_enumerate_children_finish(&this, res, error);
   }

   // Checks equality of two given #GFile<!-- -->s. Note that two
   // #GFile<!-- -->s that differ can still refer to the same
   // file on the filesystem due to various forms of filename
   // aliasing.
   // 
   // This call does no blocking i/o.
   // 
   // %FALSE if either is not a #GFile.
   // RETURNS: %TRUE if @file1 and @file2 are equal.
   // <file2>: the second #GFile.
   int equal(File* file2) {
      return g_file_equal(&this, file2);
   }

   // Gets a #GMount for the #GFile.
   // 
   // If the #GFileIface for @file does not have a mount (e.g. possibly a
   // remote share), @error will be set to %G_IO_ERROR_NOT_FOUND and %NULL
   // will be returned.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GMount where the @file is located or %NULL on error.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   Mount* /*new*/ find_enclosing_mount(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_find_enclosing_mount(&this, cancellable, error);
   }

   // Asynchronously gets the mount for the file.
   // 
   // For more details, see g_file_find_enclosing_mount() which is
   // the synchronous version of this call.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_find_enclosing_mount_finish() to get the result of the operation.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void find_enclosing_mount_async(int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_find_enclosing_mount_async(&this, io_priority, cancellable, callback, user_data);
   }

   // Finishes an asynchronous find mount request.
   // See g_file_find_enclosing_mount_async().
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: #GMount for given @file or %NULL on error.
   // <res>: a #GAsyncResult
   Mount* /*new*/ find_enclosing_mount_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_file_find_enclosing_mount_finish(&this, res, error);
   }

   // Gets the base name (the last component of the path) for a given #GFile.
   // 
   // If called for the top level of a system (such as the filesystem root
   // or a uri like sftp://host/) it will return a single directory separator
   // (and on Windows, possibly a drive letter).
   // 
   // The base name is a byte string (*not* UTF-8). It has no defined encoding
   // or rules other than it may not contain zero bytes.  If you want to use
   // filenames in a user interface you should use the display name that you
   // can get by requesting the %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME
   // attribute with g_file_query_info().
   // 
   // This call does no blocking i/o.
   // 
   // if given #GFile is invalid. The returned string should be
   // freed with g_free() when no longer needed.
   // RETURNS: string containing the #GFile's base name, or %NULL
   char* /*new*/ get_basename() {
      return g_file_get_basename(&this);
   }

   // Gets a child of @file with basename equal to @name.
   // 
   // Note that the file with that specific name might not exist, but
   // you can still have a #GFile that points to it. You can use this
   // for instance to create that file.
   // 
   // This call does no blocking i/o.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFile to a child specified by @name.
   // <name>: string containing the child's basename.
   File* /*new*/ get_child(char* name) {
      return g_file_get_child(&this, name);
   }

   // Gets the child of @file for a given @display_name (i.e. a UTF8
   // version of the name). If this function fails, it returns %NULL and @error will be
   // set. This is very useful when constructing a GFile for a new file
   // and the user entered the filename in the user interface, for instance
   // when you select a directory and type a filename in the file selector.
   // 
   // This call does no blocking i/o.
   // 
   // %NULL if the display name couldn't be converted.
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFile to the specified child, or
   // <display_name>: string to a possible child.
   File* /*new*/ get_child_for_display_name(char* display_name, GLib2.Error** error=null) {
      return g_file_get_child_for_display_name(&this, display_name, error);
   }

   // Gets the parent directory for the @file.
   // If the @file represents the root directory of the
   // file system, then %NULL will be returned.
   // 
   // This call does no blocking i/o.
   // 
   // #GFile or %NULL if there is no parent.
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFile structure to the parent of the given
   File* /*new*/ get_parent() {
      return g_file_get_parent(&this);
   }

   // Gets the parse name of the @file.
   // A parse name is a UTF-8 string that describes the
   // file such that one can get the #GFile back using
   // g_file_parse_name().
   // 
   // This is generally used to show the #GFile as a nice
   // full-pathname kind of string in a user interface,
   // like in a location entry.
   // 
   // For local files with names that can safely be converted
   // to UTF8 the pathname is used, otherwise the IRI is used
   // (a form of URI that allows UTF8 characters unescaped).
   // 
   // This call does no blocking i/o.
   // 
   // string should be freed with g_free() when no longer needed.
   // RETURNS: a string containing the #GFile's parse name. The returned
   char* /*new*/ get_parse_name() {
      return g_file_get_parse_name(&this);
   }

   // Gets the local pathname for #GFile, if one exists.
   // 
   // This call does no blocking i/o.
   // 
   // no such path exists. The returned string should be
   // freed with g_free() when no longer needed.
   // RETURNS: string containing the #GFile's path, or %NULL if
   char* /*new*/ get_path() {
      return g_file_get_path(&this);
   }

   // Gets the path for @descendant relative to @parent.
   // 
   // This call does no blocking i/o.
   // 
   // to @parent, or %NULL if @descendant doesn't have @parent as prefix.
   // The returned string should be freed with g_free() when no longer needed.
   // RETURNS: string with the relative path from @descendant
   // <descendant>: input #GFile.
   char* /*new*/ get_relative_path(File* descendant) {
      return g_file_get_relative_path(&this, descendant);
   }

   // Gets the URI for the @file.
   // 
   // This call does no blocking i/o.
   // 
   // The returned string should be freed with g_free() when no longer needed.
   // RETURNS: a string containing the #GFile's URI.
   char* /*new*/ get_uri() {
      return g_file_get_uri(&this);
   }

   // Gets the URI scheme for a #GFile.
   // RFC 3986 decodes the scheme as:
   // <programlisting>
   // URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
   // </programlisting>
   // Common schemes include "file", "http", "ftp", etc.
   // 
   // This call does no blocking i/o.
   // 
   // #GFile. The returned string should be freed with g_free()
   // when no longer needed.
   // RETURNS: a string containing the URI scheme for the given
   char* /*new*/ get_uri_scheme() {
      return g_file_get_uri_scheme(&this);
   }

   // Checks if @file has a parent, and optionally, if it is @parent.
   // 
   // If @parent is %NULL then this function returns %TRUE if @file has any
   // parent at all.  If @parent is non-%NULL then %TRUE is only returned
   // if @file is a child of @parent.
   // 
   // case that @parent is %NULL).
   // RETURNS: %TRUE if @file is a child of @parent (or any parent in the
   // <parent>: the parent to check for, or %NULL
   int has_parent(File* parent) {
      return g_file_has_parent(&this, parent);
   }

   // Checks whether @file has the prefix specified by @prefix. In other word,
   // if the names of initial elements of @file<!-- -->s pathname match @prefix.
   // Only full pathname elements are matched, so a path like /foo is not
   // considered a prefix of /foobar, only of /foo/bar.
   // 
   // This call does no i/o, as it works purely on names. As such it can
   // sometimes return %FALSE even if @file is inside a @prefix (from a
   // filesystem point of view), because the prefix of @file is an alias
   // of @prefix.
   // 
   // %FALSE otherwise.
   // RETURNS: %TRUE if the @files's parent, grandparent, etc is @prefix.
   // <prefix>: input #GFile.
   int has_prefix(File* prefix) {
      return g_file_has_prefix(&this, prefix);
   }

   // Checks to see if a #GFile has a given URI scheme.
   // 
   // This call does no blocking i/o.
   // 
   // given URI scheme, %FALSE if URI scheme is %NULL,
   // not supported, or #GFile is invalid.
   // RETURNS: %TRUE if #GFile's backend supports the
   // <uri_scheme>: a string containing a URI scheme.
   int has_uri_scheme(char* uri_scheme) {
      return g_file_has_uri_scheme(&this, uri_scheme);
   }

   // Creates a new icon for a file.
   // RETURNS: a #GIcon for the given @file, or %NULL on error.
   Icon* /*new*/ icon_new() {
      return g_file_icon_new(&this);
   }

   // Checks to see if a file is native to the platform.
   // 
   // A native file s one expressed in the platform-native filename format,
   // e.g. "C:\Windows" or "/usr/bin/". This does not mean the file is local,
   // as it might be on a locally mounted remote filesystem.
   // 
   // On some systems non-native files may be available using
   // the native filesystem via a userspace filesystem (FUSE), in
   // these cases this call will return %FALSE, but g_file_get_path()
   // will still return a native path.
   // 
   // This call does no blocking i/o.
   // RETURNS: %TRUE if file is native.
   int is_native() {
      return g_file_is_native(&this);
   }

   // Loads the content of the file into memory. The data is always
   // zero-terminated, but this is not included in the resultant @length.
   // The returned @content should be freed with g_free() when no longer
   // needed.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // %FALSE if there were errors.
   // RETURNS: %TRUE if the @file's contents were successfully loaded.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <contents>: a location to place the contents of the file.
   // <length>: a location to place the length of the contents of the file, or %NULL if the length is not needed
   // <etag_out>: a location to place the current entity tag for the file, or %NULL if the entity tag is not needed
   int load_contents(Cancellable* cancellable, /*out*/ ubyte** contents, /*out*/ size_t* length, /*out*/ char** etag_out, GLib2.Error** error=null) {
      return g_file_load_contents(&this, cancellable, contents, length, etag_out, error);
   }

   // Starts an asynchronous load of the @file's contents.
   // 
   // For more details, see g_file_load_contents() which is
   // the synchronous version of this call.
   // 
   // When the load operation has completed, @callback will be called
   // with @user data. To finish the operation, call
   // g_file_load_contents_finish() with the #GAsyncResult returned by
   // the @callback.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void load_contents_async(Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_load_contents_async(&this, cancellable, callback, user_data);
   }

   // Finishes an asynchronous load of the @file's contents.
   // The contents are placed in @contents, and @length is set to the
   // size of the @contents string. The @content should be freed with
   // g_free() when no longer needed. If @etag_out is present, it will be
   // set to the new entity tag for the @file.
   // 
   // present, it will be set appropriately.
   // RETURNS: %TRUE if the load was successful. If %FALSE and @error is
   // <res>: a #GAsyncResult.
   // <contents>: a location to place the contents of the file.
   // <length>: a location to place the length of the contents of the file, or %NULL if the length is not needed
   // <etag_out>: a location to place the current entity tag for the file, or %NULL if the entity tag is not needed
   int load_contents_finish(AsyncResult* res, /*out*/ ubyte** contents, /*out*/ size_t* length, /*out*/ char** etag_out, GLib2.Error** error=null) {
      return g_file_load_contents_finish(&this, res, contents, length, etag_out, error);
   }

   // Unintrospectable method: load_partial_contents_async() / g_file_load_partial_contents_async()
   // Reads the partial contents of a file. A #GFileReadMoreCallback should be
   // used to stop reading from the file when appropriate, else this function
   // will behave exactly as g_file_load_contents_async(). This operation
   // can be finished by g_file_load_partial_contents_finish().
   // 
   // Users of this function should be aware that @user_data is passed to
   // both the @read_more_callback and the @callback.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <read_more_callback>: a #GFileReadMoreCallback to receive partial data and to specify whether further data should be read.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to the callback functions.
   void load_partial_contents_async(Cancellable* cancellable, FileReadMoreCallback read_more_callback, AsyncReadyCallback callback, void* user_data) {
      g_file_load_partial_contents_async(&this, cancellable, read_more_callback, callback, user_data);
   }

   // Finishes an asynchronous partial load operation that was started
   // with g_file_load_partial_contents_async(). The data is always
   // zero-terminated, but this is not included in the resultant @length.
   // The returned @content should be freed with g_free() when no longer
   // needed.
   // 
   // present, it will be set appropriately.
   // RETURNS: %TRUE if the load was successful. If %FALSE and @error is
   // <res>: a #GAsyncResult.
   // <contents>: a location to place the contents of the file.
   // <length>: a location to place the length of the contents of the file, or %NULL if the length is not needed
   // <etag_out>: a location to place the current entity tag for the file, or %NULL if the entity tag is not needed
   int load_partial_contents_finish(AsyncResult* res, /*out*/ ubyte** contents, /*out*/ size_t* length, /*out*/ char** etag_out, GLib2.Error** error=null) {
      return g_file_load_partial_contents_finish(&this, res, contents, length, etag_out, error);
   }

   // Creates a directory. Note that this will only create a child directory of
   // the immediate parent directory of the path or URI given by the #GFile. To
   // recursively create directories, see g_file_make_directory_with_parents().
   // This function will fail if the parent directory does not exist, setting
   // @error to %G_IO_ERROR_NOT_FOUND. If the file system doesn't support creating
   // directories, this function will fail, setting @error to
   // %G_IO_ERROR_NOT_SUPPORTED.
   // 
   // For a local #GFile the newly created directory will have the default
   // (current) ownership and permissions of the current process.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // RETURNS: %TRUE on successful creation, %FALSE otherwise.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int make_directory(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_make_directory(&this, cancellable, error);
   }

   // Creates a directory and any parent directories that may not exist similar to
   // 'mkdir -p'. If the file system does not support creating directories, this
   // function will fail, setting @error to %G_IO_ERROR_NOT_SUPPORTED.
   // 
   // For a local #GFile the newly created directories will have the default
   // (current) ownership and permissions of the current process.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // otherwise.
   // RETURNS: %TRUE if all directories have been successfully created, %FALSE
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int make_directory_with_parents(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_make_directory_with_parents(&this, cancellable, error);
   }

   // Creates a symbolic link named @file which contains the string
   // @symlink_value.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // RETURNS: %TRUE on the creation of a new symlink, %FALSE otherwise.
   // <symlink_value>: a string with the path for the target of the new symlink
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int make_symbolic_link(char* symlink_value, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_make_symbolic_link(&this, symlink_value, cancellable, error);
   }

   // Obtains a file or directory monitor for the given file, depending
   // on the type of the file.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileMonitor for the given @file, or %NULL on error.
   // <flags>: a set of #GFileMonitorFlags
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   FileMonitor* /*new*/ monitor(FileMonitorFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_monitor(&this, flags, cancellable, error);
   }

   // Obtains a directory monitor for the given file.
   // This may fail if directory monitoring is not supported.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileMonitor for the given @file, or %NULL on error.
   // <flags>: a set of #GFileMonitorFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileMonitor* /*new*/ monitor_directory(FileMonitorFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_monitor_directory(&this, flags, cancellable, error);
   }

   // Obtains a file monitor for the given file. If no file notification
   // mechanism exists, then regular polling of the file is used.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileMonitor for the given @file, or %NULL on error.
   // <flags>: a set of #GFileMonitorFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileMonitor* /*new*/ monitor_file(FileMonitorFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_monitor_file(&this, flags, cancellable, error);
   }

   // Starts a @mount_operation, mounting the volume that contains the file @location.
   // 
   // When this operation has completed, @callback will be called with
   // @user_user data, and the operation can be finalized with
   // g_file_mount_enclosing_volume_finish().
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   void mount_enclosing_volume(MountMountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_mount_enclosing_volume(&this, flags, mount_operation, cancellable, callback, user_data);
   }

   // Finishes a mount operation started by g_file_mount_enclosing_volume().
   // 
   // has occurred, this function will return %FALSE and set @error
   // appropriately if present.
   // RETURNS: %TRUE if successful. If an error
   // <result>: a #GAsyncResult.
   int mount_enclosing_volume_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_mount_enclosing_volume_finish(&this, result, error);
   }

   // Mounts a file of type G_FILE_TYPE_MOUNTABLE.
   // Using @mount_operation, you can request callbacks when, for instance,
   // passwords are needed during authentication.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_mount_mountable_finish() to get the result of the operation.
   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation, or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   void mount_mountable(MountMountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_mount_mountable(&this, flags, mount_operation, cancellable, callback, user_data);
   }

   // Finishes a mount operation. See g_file_mount_mountable() for details.
   // 
   // Finish an asynchronous mount operation that was started
   // with g_file_mount_mountable().
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFile or %NULL on error.
   // <result>: a #GAsyncResult.
   File* /*new*/ mount_mountable_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_mount_mountable_finish(&this, result, error);
   }

   // Tries to move the file or directory @source to the location specified by @destination.
   // If native move operations are supported then this is used, otherwise a copy + delete
   // fallback is used. The native implementation may support moving directories (for instance
   // on moves inside the same filesystem), but the fallback code does not.
   // 
   // If the flag #G_FILE_COPY_OVERWRITE is specified an already
   // existing @destination file is overwritten.
   // 
   // If the flag #G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks
   // will be copied as symlinks, otherwise the target of the
   // @source symlink will be copied.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // If @progress_callback is not %NULL, then the operation can be monitored by
   // setting this to a #GFileProgressCallback function. @progress_callback_data
   // will be passed to this function. It is guaranteed that this callback will
   // be called after all data has been transferred with the total number of bytes
   // copied during the operation.
   // 
   // If the @source file does not exist then the G_IO_ERROR_NOT_FOUND
   // error is returned, independent on the status of the @destination.
   // 
   // If #G_FILE_COPY_OVERWRITE is not specified and the target exists, then the
   // error G_IO_ERROR_EXISTS is returned.
   // 
   // If trying to overwrite a file over a directory the G_IO_ERROR_IS_DIRECTORY
   // error is returned. If trying to overwrite a directory with a directory the
   // G_IO_ERROR_WOULD_MERGE error is returned.
   // 
   // If the source is a directory and the target does not exist, or #G_FILE_COPY_OVERWRITE is
   // specified and the target is a file, then the G_IO_ERROR_WOULD_RECURSE error
   // may be returned (if the native move operation isn't available).
   // RETURNS: %TRUE on successful move, %FALSE otherwise.
   // <destination>: #GFile pointing to the destination location.
   // <flags>: set of #GFileCopyFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <progress_callback>: #GFileProgressCallback function for updates.
   // <progress_callback_data>: gpointer to user data for the callback function.
   int move(File* destination, FileCopyFlags flags, Cancellable* cancellable, FileProgressCallback progress_callback, void* progress_callback_data, GLib2.Error** error=null) {
      return g_file_move(&this, destination, flags, cancellable, progress_callback, progress_callback_data, error);
   }

   // Opens an existing file for reading and writing. The result is
   // a #GFileIOStream that can be used to read and write the contents of the file.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
   // If the file is a directory, the G_IO_ERROR_IS_DIRECTORY error will be returned.
   // Other errors are possible too, and depend on what kind of filesystem the file is on.
   // Note that in many non-local file cases read and write streams are not supported,
   // so make sure you really need to do read and write streaming, rather than
   // just opening for reading or writing.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: #GFileIOStream or %NULL on error.
   // <cancellable>: a #GCancellable
   FileIOStream* /*new*/ open_readwrite(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_open_readwrite(&this, cancellable, error);
   }

   // Asynchronously opens @file for reading and writing.
   // 
   // For more details, see g_file_open_readwrite() which is
   // the synchronous version of this call.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_open_readwrite_finish() to get the result of the operation.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void open_readwrite_async(int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_open_readwrite_async(&this, io_priority, cancellable, callback, user_data);
   }

   // Finishes an asynchronous file read operation started with
   // g_file_open_readwrite_async().
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileIOStream or %NULL on error.
   // <res>: a #GAsyncResult.
   FileIOStream* /*new*/ open_readwrite_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_file_open_readwrite_finish(&this, res, error);
   }

   // Polls a file of type G_FILE_TYPE_MOUNTABLE.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_mount_mountable_finish() to get the result of the operation.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   void poll_mountable(Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_poll_mountable(&this, cancellable, callback, user_data);
   }

   // Finishes a poll operation. See g_file_poll_mountable() for details.
   // 
   // Finish an asynchronous poll operation that was polled
   // with g_file_poll_mountable().
   // 
   // otherwise.
   // RETURNS: %TRUE if the operation finished successfully. %FALSE
   // <result>: a #GAsyncResult.
   int poll_mountable_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_poll_mountable_finish(&this, result, error);
   }

   // Returns the #GAppInfo that is registered as the default
   // application to handle the file specified by @file.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // When you are done with it, release it with g_object_unref()
   // RETURNS: a #GAppInfo if the handle was found, %NULL if there were errors.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   AppInfo* /*new*/ query_default_handler(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_query_default_handler(&this, cancellable, error);
   }

   // Utility function to check if a particular file exists. This is
   // implemented using g_file_query_info() and as such does blocking I/O.
   // 
   // Note that in many cases it is racy to first check for file existence
   // and then execute something based on the outcome of that, because the
   // file might have been created or removed in between the operations. The
   // general approach to handling that is to not check, but just do the
   // operation and handle the errors as they come.
   // 
   // As an example of race-free checking, take the case of reading a file, and
   // if it doesn't exist, creating it. There are two racy versions: read it, and
   // on error create it; and: check if it exists, if not create it. These
   // can both result in two processes creating the file (with perhaps a partially
   // written file as the result). The correct approach is to always try to create
   // the file with g_file_create() which will either atomically create the file
   // or fail with a G_IO_ERROR_EXISTS error.
   // 
   // However, in many cases an existence check is useful in a user
   // interface, for instance to make a menu item sensitive/insensitive, so that
   // you don't have to fool users that something is possible and then just show
   // and error dialog. If you do this, you should make sure to also handle the
   // errors that can happen due to races when you execute the operation.
   // RETURNS: %TRUE if the file exists (and can be detected without error), %FALSE otherwise (or if cancelled).
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int query_exists(Cancellable* cancellable=null) {
      return g_file_query_exists(&this, cancellable);
   }

   // Utility function to inspect the #GFileType of a file. This is
   // implemented using g_file_query_info() and as such does blocking I/O.
   // 
   // The primary use case of this method is to check if a file is a regular file,
   // directory, or symlink.
   // 
   // does not exist
   // RETURNS: The #GFileType of the file and #G_FILE_TYPE_UNKNOWN if the file
   // <flags>: a set of #GFileQueryInfoFlags passed to g_file_query_info().
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileType query_file_type(FileQueryInfoFlags flags, Cancellable* cancellable=null) {
      return g_file_query_file_type(&this, flags, cancellable);
   }

   // Similar to g_file_query_info(), but obtains information
   // about the filesystem the @file is on, rather than the file itself.
   // For instance the amount of space available and the type of
   // the filesystem.
   // 
   // The @attributes value is a string that specifies the file attributes that
   // should be gathered. It is not an error if it's not possible to read a particular
   // requested attribute from a file - it just won't be set. @attributes should
   // be a comma-separated list of attributes or attribute wildcards. The wildcard "*"
   // means all attributes, and a wildcard like "filesystem::*" means all attributes in the
   // filesystem namespace. The standard namespace for filesystem attributes is "filesystem".
   // Common attributes of interest are #G_FILE_ATTRIBUTE_FILESYSTEM_SIZE
   // (the total size of the filesystem in bytes), #G_FILE_ATTRIBUTE_FILESYSTEM_FREE (number of
   // bytes available), and #G_FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem).
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
   // Other errors are possible too, and depend on what kind of filesystem the file is on.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileInfo or %NULL if there was an error.
   // <attributes>: an attribute query string.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileInfo* /*new*/ query_filesystem_info(char* attributes, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_query_filesystem_info(&this, attributes, cancellable, error);
   }

   // Asynchronously gets the requested information about the filesystem
   // that the specified @file is on. The result is a #GFileInfo object
   // that contains key-value attributes (such as type or size for the
   // file).
   // 
   // For more details, see g_file_query_filesystem_info() which is the
   // synchronous version of this call.
   // 
   // When the operation is finished, @callback will be called. You can
   // then call g_file_query_info_finish() to get the result of the
   // operation.
   // <attributes>: an attribute query string.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void query_filesystem_info_async(char* attributes, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_query_filesystem_info_async(&this, attributes, io_priority, cancellable, callback, user_data);
   }

   // Finishes an asynchronous filesystem info query.  See
   // g_file_query_filesystem_info_async().
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: #GFileInfo for given @file or %NULL on error.
   // <res>: a #GAsyncResult.
   FileInfo* /*new*/ query_filesystem_info_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_file_query_filesystem_info_finish(&this, res, error);
   }

   // Gets the requested information about specified @file. The result
   // is a #GFileInfo object that contains key-value attributes (such as
   // the type or size of the file).
   // 
   // The @attributes value is a string that specifies the file attributes that
   // should be gathered. It is not an error if it's not possible to read a particular
   // requested attribute from a file - it just won't be set. @attributes should
   // be a comma-separated list of attributes or attribute wildcards. The wildcard "*"
   // means all attributes, and a wildcard like "standard::*" means all attributes in the standard
   // namespace. An example attribute query be "standard::*,owner::user".
   // The standard attributes are available as defines, like #G_FILE_ATTRIBUTE_STANDARD_NAME.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // For symlinks, normally the information about the target of the
   // symlink is returned, rather than information about the symlink itself.
   // However if you pass #G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS in @flags the
   // information about the symlink itself will be returned. Also, for symlinks
   // that point to non-existing files the information about the symlink itself
   // will be returned.
   // 
   // If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
   // Other errors are possible too, and depend on what kind of filesystem the file is on.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileInfo for the given @file, or %NULL on error.
   // <attributes>: an attribute query string.
   // <flags>: a set of #GFileQueryInfoFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileInfo* /*new*/ query_info(char* attributes, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_query_info(&this, attributes, flags, cancellable, error);
   }

   // Asynchronously gets the requested information about specified @file. The result
   // is a #GFileInfo object that contains key-value attributes (such as type or size
   // for the file).
   // 
   // For more details, see g_file_query_info() which is
   // the synchronous version of this call.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_query_info_finish() to get the result of the operation.
   // <attributes>: an attribute query string.
   // <flags>: a set of #GFileQueryInfoFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void query_info_async(char* attributes, FileQueryInfoFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_query_info_async(&this, attributes, flags, io_priority, cancellable, callback, user_data);
   }

   // Finishes an asynchronous file info query.
   // See g_file_query_info_async().
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: #GFileInfo for given @file or %NULL on error.
   // <res>: a #GAsyncResult.
   FileInfo* /*new*/ query_info_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_file_query_info_finish(&this, res, error);
   }

   // Obtain the list of settable attributes for the file.
   // 
   // Returns the type and full attribute name of all the attributes
   // that can be set on this file. This doesn't mean setting it will always
   // succeed though, you might get an access failure, or some specific
   // file may not support a specific attribute.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // When you are done with it, release it with g_file_attribute_info_list_unref()
   // RETURNS: a #GFileAttributeInfoList describing the settable attributes.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileAttributeInfoList* /*new*/ query_settable_attributes(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_query_settable_attributes(&this, cancellable, error);
   }

   // Obtain the list of attribute namespaces where new attributes
   // can be created by a user. An example of this is extended
   // attributes (in the "xattr" namespace).
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // When you are done with it, release it with g_file_attribute_info_list_unref()
   // RETURNS: a #GFileAttributeInfoList describing the writable namespaces.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileAttributeInfoList* /*new*/ query_writable_namespaces(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_query_writable_namespaces(&this, cancellable, error);
   }

   // Opens a file for reading. The result is a #GFileInputStream that
   // can be used to read the contents of the file.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // If the file does not exist, the G_IO_ERROR_NOT_FOUND error will be returned.
   // If the file is a directory, the G_IO_ERROR_IS_DIRECTORY error will be returned.
   // Other errors are possible too, and depend on what kind of filesystem the file is on.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: #GFileInputStream or %NULL on error.
   // <cancellable>: a #GCancellable
   FileInputStream* /*new*/ read(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_read(&this, cancellable, error);
   }

   // Asynchronously opens @file for reading.
   // 
   // For more details, see g_file_read() which is
   // the synchronous version of this call.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_read_finish() to get the result of the operation.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void read_async(int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_read_async(&this, io_priority, cancellable, callback, user_data);
   }

   // Finishes an asynchronous file read operation started with
   // g_file_read_async().
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileInputStream or %NULL on error.
   // <res>: a #GAsyncResult.
   FileInputStream* /*new*/ read_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_file_read_finish(&this, res, error);
   }

   // Returns an output stream for overwriting the file, possibly
   // creating a backup copy of the file first. If the file doesn't exist,
   // it will be created.
   // 
   // This will try to replace the file in the safest way possible so
   // that any errors during the writing will not affect an already
   // existing copy of the file. For instance, for local files it
   // may write to a temporary file and then atomically rename over
   // the destination when the stream is closed.
   // 
   // By default files created are generally readable by everyone,
   // but if you pass #G_FILE_CREATE_PRIVATE in @flags the file
   // will be made readable only to the current user, to the level that
   // is supported on the target filesystem.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // If you pass in a non-#NULL @etag value, then this value is
   // compared to the current entity tag of the file, and if they differ
   // an G_IO_ERROR_WRONG_ETAG error is returned. This generally means
   // that the file has been changed since you last read it. You can get
   // the new etag from g_file_output_stream_get_etag() after you've
   // finished writing and closed the #GFileOutputStream. When you load
   // a new file you can use g_file_input_stream_query_info() to get
   // the etag of the file.
   // 
   // If @make_backup is %TRUE, this function will attempt to make a backup
   // of the current file before overwriting it. If this fails a G_IO_ERROR_CANT_CREATE_BACKUP
   // error will be returned. If you want to replace anyway, try again with
   // @make_backup set to %FALSE.
   // 
   // If the file is a directory the G_IO_ERROR_IS_DIRECTORY error will be returned,
   // and if the file is some other form of non-regular file then a
   // G_IO_ERROR_NOT_REGULAR_FILE error will be returned.
   // Some file systems don't allow all file names, and may
   // return an G_IO_ERROR_INVALID_FILENAME error, and if the name
   // is to long G_IO_ERROR_FILENAME_TOO_LONG will be returned.
   // Other errors are possible too, and depend on what kind of
   // filesystem the file is on.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileOutputStream or %NULL on error.
   // <etag>: an optional <link linkend="gfile-etag">entity tag</link> for the current #GFile, or #NULL to ignore.
   // <make_backup>: %TRUE if a backup should be created.
   // <flags>: a set of #GFileCreateFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileOutputStream* /*new*/ replace(char* etag, int make_backup, FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_replace(&this, etag, make_backup, flags, cancellable, error);
   }

   // Asynchronously overwrites the file, replacing the contents, possibly
   // creating a backup copy of the file first.
   // 
   // For more details, see g_file_replace() which is
   // the synchronous version of this call.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_replace_finish() to get the result of the operation.
   // <etag>: an <link linkend="gfile-etag">entity tag</link> for the current #GFile, or NULL to ignore.
   // <make_backup>: %TRUE if a backup should be created.
   // <flags>: a set of #GFileCreateFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void replace_async(char* etag, int make_backup, FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_replace_async(&this, etag, make_backup, flags, io_priority, cancellable, callback, user_data);
   }

   // Replaces the contents of @file with @contents of @length bytes.
   // If @etag is specified (not %NULL) any existing file must have that etag, or
   // the error %G_IO_ERROR_WRONG_ETAG will be returned.
   // 
   // If @make_backup is %TRUE, this function will attempt to make a backup of @file.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // The returned @new_etag can be used to verify that the file hasn't changed the
   // next time it is saved over.
   // 
   // has occurred, this function will return %FALSE and set @error
   // appropriately if present.
   // RETURNS: %TRUE if successful. If an error
   // <contents>: a string containing the new contents for @file.
   // <length>: the length of @contents in bytes.
   // <etag>: the old <link linkend="gfile-etag">entity tag</link> for the document, or %NULL
   // <make_backup>: %TRUE if a backup should be created.
   // <flags>: a set of #GFileCreateFlags.
   // <new_etag>: a location to a new <link linkend="gfile-etag">entity tag</link> for the document. This should be freed with g_free() when no longer needed, or %NULL
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int replace_contents(ubyte* contents, size_t length, char* etag, int make_backup, FileCreateFlags flags, /*out*/ char** new_etag, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_replace_contents(&this, contents, length, etag, make_backup, flags, new_etag, cancellable, error);
   }

   // Starts an asynchronous replacement of @file with the given
   // @contents of @length bytes. @etag will replace the document's
   // current entity tag.
   // 
   // When this operation has completed, @callback will be called with
   // @user_user data, and the operation can be finalized with
   // g_file_replace_contents_finish().
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // If @make_backup is %TRUE, this function will attempt to
   // make a backup of @file.
   // <contents>: string of contents to replace the file with.
   // <length>: the length of @contents in bytes.
   // <etag>: a new <link linkend="gfile-etag">entity tag</link> for the @file, or %NULL
   // <make_backup>: %TRUE if a backup should be created.
   // <flags>: a set of #GFileCreateFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void replace_contents_async(ubyte* contents, size_t length, char* etag, int make_backup, FileCreateFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_replace_contents_async(&this, contents, length, etag, make_backup, flags, cancellable, callback, user_data);
   }

   // Finishes an asynchronous replace of the given @file. See
   // g_file_replace_contents_async(). Sets @new_etag to the new entity
   // tag for the document, if present.
   // RETURNS: %TRUE on success, %FALSE on failure.
   // <res>: a #GAsyncResult.
   // <new_etag>: a location of a new <link linkend="gfile-etag">entity tag</link> for the document. This should be freed with g_free() when it is no longer needed, or %NULL
   int replace_contents_finish(AsyncResult* res, /*out*/ char** new_etag, GLib2.Error** error=null) {
      return g_file_replace_contents_finish(&this, res, new_etag, error);
   }

   // Finishes an asynchronous file replace operation started with
   // g_file_replace_async().
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileOutputStream, or %NULL on error.
   // <res>: a #GAsyncResult.
   FileOutputStream* /*new*/ replace_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_file_replace_finish(&this, res, error);
   }

   // Returns an output stream for overwriting the file in readwrite mode,
   // possibly creating a backup copy of the file first. If the file doesn't
   // exist, it will be created.
   // 
   // For details about the behaviour, see g_file_replace() which does the same
   // thing but returns an output stream only.
   // 
   // Note that in many non-local file cases read and write streams are not
   // supported, so make sure you really need to do read and write streaming,
   // rather than just opening for reading or writing.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileIOStream or %NULL on error.
   // <etag>: an optional <link linkend="gfile-etag">entity tag</link> for the current #GFile, or #NULL to ignore
   // <make_backup>: %TRUE if a backup should be created
   // <flags>: a set of #GFileCreateFlags
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   FileIOStream* /*new*/ replace_readwrite(char* etag, int make_backup, FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_replace_readwrite(&this, etag, make_backup, flags, cancellable, error);
   }

   // Asynchronously overwrites the file in read-write mode, replacing the
   // contents, possibly creating a backup copy of the file first.
   // 
   // For more details, see g_file_replace_readwrite() which is
   // the synchronous version of this call.
   // 
   // When the operation is finished, @callback will be called. You can then
   // call g_file_replace_readwrite_finish() to get the result of the operation.
   // <etag>: an <link linkend="gfile-etag">entity tag</link> for the current #GFile, or NULL to ignore.
   // <make_backup>: %TRUE if a backup should be created.
   // <flags>: a set of #GFileCreateFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void replace_readwrite_async(char* etag, int make_backup, FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_replace_readwrite_async(&this, etag, make_backup, flags, io_priority, cancellable, callback, user_data);
   }

   // Finishes an asynchronous file replace operation started with
   // g_file_replace_readwrite_async().
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFileIOStream, or %NULL on error.
   // <res>: a #GAsyncResult.
   FileIOStream* /*new*/ replace_readwrite_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_file_replace_readwrite_finish(&this, res, error);
   }

   // Resolves a relative path for @file to an absolute path.
   // 
   // This call does no blocking i/o.
   // 
   // is %NULL or if @file is invalid.
   // Free the returned object with g_object_unref().
   // RETURNS: #GFile to the resolved path. %NULL if @relative_path
   // <relative_path>: a given relative path string.
   File* /*new*/ resolve_relative_path(char* relative_path) {
      return g_file_resolve_relative_path(&this, relative_path);
   }

   // Sets an attribute in the file with attribute name @attribute to @value.
   // 
   // Some attributes can be unset by setting @attribute to
   // %G_FILE_ATTRIBUTE_TYPE_INVALID and @value to %NULL.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // RETURNS: %TRUE if the attribute was set, %FALSE otherwise.
   // <attribute>: a string containing the attribute's name.
   // <type>: The type of the attribute
   // <value_p>: a pointer to the value (or the pointer itself if the type is a pointer type)
   // <flags>: a set of #GFileQueryInfoFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int set_attribute(char* attribute, FileAttributeType type, void* value_p, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_set_attribute(&this, attribute, type, value_p, flags, cancellable, error);
   }

   // Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING to @value.
   // If @attribute is of a different type, this operation will fail,
   // returning %FALSE.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // in the @file, %FALSE otherwise.
   // RETURNS: %TRUE if the @attribute was successfully set to @value
   // <attribute>: a string containing the attribute's name.
   // <value>: a string containing the attribute's new value.
   // <flags>: a #GFileQueryInfoFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int set_attribute_byte_string(char* attribute, char* value, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_set_attribute_byte_string(&this, attribute, value, flags, cancellable, error);
   }

   // Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_INT32 to @value.
   // If @attribute is of a different type, this operation will fail.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // in the @file, %FALSE otherwise.
   // RETURNS: %TRUE if the @attribute was successfully set to @value
   // <attribute>: a string containing the attribute's name.
   // <value>: a #gint32 containing the attribute's new value.
   // <flags>: a #GFileQueryInfoFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int set_attribute_int32(char* attribute, int value, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_set_attribute_int32(&this, attribute, value, flags, cancellable, error);
   }

   // Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_INT64 to @value.
   // If @attribute is of a different type, this operation will fail.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // RETURNS: %TRUE if the @attribute was successfully set, %FALSE otherwise.
   // <attribute>: a string containing the attribute's name.
   // <value>: a #guint64 containing the attribute's new value.
   // <flags>: a #GFileQueryInfoFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int set_attribute_int64(char* attribute, long value, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_set_attribute_int64(&this, attribute, value, flags, cancellable, error);
   }

   // Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_STRING to @value.
   // If @attribute is of a different type, this operation will fail.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // RETURNS: %TRUE if the @attribute was successfully set, %FALSE otherwise.
   // <attribute>: a string containing the attribute's name.
   // <value>: a string containing the attribute's value.
   // <flags>: #GFileQueryInfoFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int set_attribute_string(char* attribute, char* value, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_set_attribute_string(&this, attribute, value, flags, cancellable, error);
   }

   // Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_UINT32 to @value.
   // If @attribute is of a different type, this operation will fail.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // in the @file, %FALSE otherwise.
   // RETURNS: %TRUE if the @attribute was successfully set to @value
   // <attribute>: a string containing the attribute's name.
   // <value>: a #guint32 containing the attribute's new value.
   // <flags>: a #GFileQueryInfoFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int set_attribute_uint32(char* attribute, uint value, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_set_attribute_uint32(&this, attribute, value, flags, cancellable, error);
   }

   // Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_UINT64 to @value.
   // If @attribute is of a different type, this operation will fail.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // in the @file, %FALSE otherwise.
   // RETURNS: %TRUE if the @attribute was successfully set to @value
   // <attribute>: a string containing the attribute's name.
   // <value>: a #guint64 containing the attribute's new value.
   // <flags>: a #GFileQueryInfoFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int set_attribute_uint64(char* attribute, ulong value, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_set_attribute_uint64(&this, attribute, value, flags, cancellable, error);
   }

   // Asynchronously sets the attributes of @file with @info.
   // 
   // For more details, see g_file_set_attributes_from_info() which is
   // the synchronous version of this call.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_set_attributes_finish() to get the result of the operation.
   // <info>: a #GFileInfo.
   // <flags>: a #GFileQueryInfoFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback.
   // <user_data>: a #gpointer.
   void set_attributes_async(FileInfo* info, FileQueryInfoFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_set_attributes_async(&this, info, flags, io_priority, cancellable, callback, user_data);
   }

   // Finishes setting an attribute started in g_file_set_attributes_async().
   // RETURNS: %TRUE if the attributes were set correctly, %FALSE otherwise.
   // <result>: a #GAsyncResult.
   // <info>: a #GFileInfo.
   int set_attributes_finish(AsyncResult* result, /*out*/ FileInfo** info, GLib2.Error** error=null) {
      return g_file_set_attributes_finish(&this, result, info, error);
   }

   // Tries to set all attributes in the #GFileInfo on the target values,
   // not stopping on the first error.
   // 
   // If there is any error during this operation then @error will be set to
   // the first error. Error on particular fields are flagged by setting
   // the "status" field in the attribute value to
   // %G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can also detect
   // further errors.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // RETURNS: %TRUE if there was any error, %FALSE otherwise.
   // <info>: a #GFileInfo.
   // <flags>: #GFileQueryInfoFlags
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int set_attributes_from_info(FileInfo* info, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_set_attributes_from_info(&this, info, flags, cancellable, error);
   }

   // Renames @file to the specified display name.
   // 
   // The display name is converted from UTF8 to the correct encoding for the target
   // filesystem if possible and the @file is renamed to this.
   // 
   // If you want to implement a rename operation in the user interface the edit name
   // (#G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME) should be used as the initial value in the rename
   // widget, and then the result after editing should be passed to g_file_set_display_name().
   // 
   // On success the resulting converted filename is returned.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // if there was an error.
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFile specifying what @file was renamed to, or %NULL
   // <display_name>: a string.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   File* /*new*/ set_display_name(char* display_name, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_set_display_name(&this, display_name, cancellable, error);
   }

   // Asynchronously sets the display name for a given #GFile.
   // 
   // For more details, see g_file_set_display_name() which is
   // the synchronous version of this call.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_set_display_name_finish() to get the result of the operation.
   // <display_name>: a string.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void set_display_name_async(char* display_name, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_set_display_name_async(&this, display_name, io_priority, cancellable, callback, user_data);
   }

   // Finishes setting a display name started with
   // g_file_set_display_name_async().
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFile or %NULL on error.
   // <res>: a #GAsyncResult.
   File* /*new*/ set_display_name_finish(AsyncResult* res, GLib2.Error** error=null) {
      return g_file_set_display_name_finish(&this, res, error);
   }

   // Starts a file of type G_FILE_TYPE_MOUNTABLE.
   // Using @start_operation, you can request callbacks when, for instance,
   // passwords are needed during authentication.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_mount_mountable_finish() to get the result of the operation.
   // <flags>: flags affecting the operation
   // <start_operation>: a #GMountOperation, or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   void start_mountable(DriveStartFlags flags, MountOperation* start_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_start_mountable(&this, flags, start_operation, cancellable, callback, user_data);
   }

   // Finishes a start operation. See g_file_start_mountable() for details.
   // 
   // Finish an asynchronous start operation that was started
   // with g_file_start_mountable().
   // 
   // otherwise.
   // RETURNS: %TRUE if the operation finished successfully. %FALSE
   // <result>: a #GAsyncResult.
   int start_mountable_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_start_mountable_finish(&this, result, error);
   }

   // Stops a file of type G_FILE_TYPE_MOUNTABLE.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_stop_mountable_finish() to get the result of the operation.
   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation, or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   void stop_mountable(MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_stop_mountable(&this, flags, mount_operation, cancellable, callback, user_data);
   }

   // Finishes an stop operation, see g_file_stop_mountable() for details.
   // 
   // Finish an asynchronous stop operation that was started
   // with g_file_stop_mountable().
   // 
   // otherwise.
   // RETURNS: %TRUE if the operation finished successfully. %FALSE
   // <result>: a #GAsyncResult.
   int stop_mountable_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_stop_mountable_finish(&this, result, error);
   }

   // Checks if @file supports <link
   // linkend="g-main-context-push-thread-default-context">thread-default
   // contexts</link>. If this returns %FALSE, you cannot perform
   // asynchronous operations on @file in a thread that has a
   // thread-default context.
   // RETURNS: Whether or not @file supports thread-default contexts.
   int supports_thread_contexts() {
      return g_file_supports_thread_contexts(&this);
   }

   // Sends @file to the "Trashcan", if possible. This is similar to
   // deleting it, but the user can recover it before emptying the trashcan.
   // Not all file systems support trashing, so this call can return the
   // %G_IO_ERROR_NOT_SUPPORTED error.
   // 
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // RETURNS: %TRUE on successful trash, %FALSE otherwise.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int trash(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_trash(&this, cancellable, error);
   }

   // Unmounts a file of type G_FILE_TYPE_MOUNTABLE.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_unmount_mountable_finish() to get the result of the operation.
   // <flags>: flags affecting the operation
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   void unmount_mountable(MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_unmount_mountable(&this, flags, cancellable, callback, user_data);
   }

   // Finishes an unmount operation, see g_file_unmount_mountable() for details.
   // 
   // Finish an asynchronous unmount operation that was started
   // with g_file_unmount_mountable().
   // 
   // otherwise.
   // RETURNS: %TRUE if the operation finished successfully. %FALSE
   // <result>: a #GAsyncResult.
   int unmount_mountable_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_unmount_mountable_finish(&this, result, error);
   }

   // Unmounts a file of type G_FILE_TYPE_MOUNTABLE.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // When the operation is finished, @callback will be called. You can then call
   // g_file_unmount_mountable_finish() to get the result of the operation.
   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation, or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   void unmount_mountable_with_operation(MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_unmount_mountable_with_operation(&this, flags, mount_operation, cancellable, callback, user_data);
   }

   // Finishes an unmount operation, see g_file_unmount_mountable_with_operation() for details.
   // 
   // Finish an asynchronous unmount operation that was started
   // with g_file_unmount_mountable_with_operation().
   // 
   // otherwise.
   // RETURNS: %TRUE if the operation finished successfully. %FALSE
   // <result>: a #GAsyncResult.
   int unmount_mountable_with_operation_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_unmount_mountable_with_operation_finish(&this, result, error);
   }
}

// Information about a specific attribute.
struct FileAttributeInfo {
   char* name;
   FileAttributeType type;
   FileAttributeInfoFlags flags;
}

// Flags specifying the behaviour of an attribute.
enum FileAttributeInfoFlags {
   NONE = 0,
   COPY_WITH_FILE = 1,
   COPY_WHEN_MOVED = 2
}

// Acts as a lightweight registry for possible valid file attributes.
// The registry stores Key-Value pair formats as #GFileAttributeInfo<!-- -->s.
struct FileAttributeInfoList {
   FileAttributeInfo* infos;
   int n_infos;


   // Creates a new file attribute info list.
   // RETURNS: a #GFileAttributeInfoList.
   static FileAttributeInfoList* /*new*/ new_() {
      return g_file_attribute_info_list_new();
   }

   // Adds a new attribute with @name to the @list, setting
   // its @type and @flags.
   // <name>: the name of the attribute to add.
   // <type>: the #GFileAttributeType for the attribute.
   // <flags>: #GFileAttributeInfoFlags for the attribute.
   void add(char* name, FileAttributeType type, FileAttributeInfoFlags flags) {
      g_file_attribute_info_list_add(&this, name, type, flags);
   }

   // Makes a duplicate of a file attribute info list.
   // RETURNS: a copy of the given @list.
   FileAttributeInfoList* /*new*/ dup() {
      return g_file_attribute_info_list_dup(&this);
   }

   // Gets the file attribute with the name @name from @list.
   // 
   // attribute isn't found.
   // RETURNS: a #GFileAttributeInfo for the @name, or %NULL if an
   // <name>: the name of the attribute to lookup.
   FileAttributeInfo* lookup(char* name) {
      return g_file_attribute_info_list_lookup(&this, name);
   }

   // References a file attribute info list.
   // RETURNS: #GFileAttributeInfoList or %NULL on error.
   FileAttributeInfoList* /*new*/ ref_() {
      return g_file_attribute_info_list_ref(&this);
   }

   // Removes a reference from the given @list. If the reference count
   // falls to zero, the @list is deleted.
   void unref() {
      g_file_attribute_info_list_unref(&this);
   }
}

// Determines if a string matches a file attribute.
struct FileAttributeMatcher {

   // Creates a new file attribute matcher, which matches attributes
   // against a given string. #GFileAttributeMatcher<!-- -->s are reference
   // counted structures, and are created with a reference count of 1. If
   // the number of references falls to 0, the #GFileAttributeMatcher is
   // automatically destroyed.
   // 
   // The @attribute string should be formatted with specific keys separated
   // from namespaces with a double colon. Several "namespace::key" strings may be
   // concatenated with a single comma (e.g. "standard::type,standard::is-hidden").
   // The wildcard "*" may be used to match all keys and namespaces, or
   // "namespace::*" will match all keys in a given namespace.
   // 
   // Examples of strings to use:
   // <table>
   // <title>File Attribute Matcher strings and results</title>
   // <tgroup cols='2' align='left'><thead>
   // <row><entry> Matcher String </entry><entry> Matches </entry></row></thead>
   // <tbody>
   // <row><entry>"*"</entry><entry>matches all attributes.</entry></row>
   // <row><entry>"standard::is-hidden"</entry><entry>matches only the key is-hidden in the standard namespace.</entry></row>
   // <row><entry>"standard::type,unix::*"</entry><entry>matches the type key in the standard namespace and
   // all keys in the unix namespace.</entry></row>
   // </tbody></tgroup>
   // </table>
   // RETURNS: a #GFileAttributeMatcher.
   // <attributes>: an attribute string to match.
   static FileAttributeMatcher* /*new*/ new_(char* attributes) {
      return g_file_attribute_matcher_new(attributes);
   }

   // Checks if the matcher will match all of the keys in a given namespace.
   // This will always return %TRUE if a wildcard character is in use (e.g. if
   // matcher was created with "standard::*" and @ns is "standard", or if matcher was created
   // using "*" and namespace is anything.)
   // 
   // TODO: this is awkwardly worded.
   // 
   // in the given @ns, %FALSE otherwise.
   // RETURNS: %TRUE if the matcher matches all of the entries
   // <ns>: a string containing a file attribute namespace.
   int enumerate_namespace(char* ns) {
      return g_file_attribute_matcher_enumerate_namespace(&this, ns);
   }

   // Gets the next matched attribute from a #GFileAttributeMatcher.
   // 
   // no more attribute exist.
   // RETURNS: a string containing the next attribute or %NULL if
   char* enumerate_next() {
      return g_file_attribute_matcher_enumerate_next(&this);
   }

   // Checks if an attribute will be matched by an attribute matcher. If
   // the matcher was created with the "*" matching string, this function
   // will always return %TRUE.
   // RETURNS: %TRUE if @attribute matches @matcher. %FALSE otherwise.
   // <attribute>: a file attribute key.
   int matches(char* attribute) {
      return g_file_attribute_matcher_matches(&this, attribute);
   }

   // Checks if a attribute matcher only matches a given attribute. Always
   // returns %FALSE if "*" was used when creating the matcher.
   // RETURNS: %TRUE if the matcher only matches @attribute. %FALSE otherwise.
   // <attribute>: a file attribute key.
   int matches_only(char* attribute) {
      return g_file_attribute_matcher_matches_only(&this, attribute);
   }

   // References a file attribute matcher.
   // RETURNS: a #GFileAttributeMatcher.
   FileAttributeMatcher* /*new*/ ref_() {
      return g_file_attribute_matcher_ref(&this);
   }

   // Unreferences @matcher. If the reference count falls below 1,
   // the @matcher is automatically freed.
   void unref() {
      g_file_attribute_matcher_unref(&this);
   }
}

// Used by g_file_set_attributes_from_info() when setting file attributes.
enum FileAttributeStatus {
   UNSET = 0,
   SET = 1,
   ERROR_SETTING = 2
}
// The data types for file attributes.
enum FileAttributeType {
   INVALID = 0,
   STRING = 1,
   BYTE_STRING = 2,
   BOOLEAN = 3,
   UINT32 = 4,
   INT32 = 5,
   UINT64 = 6,
   INT64 = 7,
   OBJECT = 8,
   STRINGV = 9
}
// Flags used when copying or moving files.
enum FileCopyFlags {
   NONE = 0,
   OVERWRITE = 1,
   BACKUP = 2,
   NOFOLLOW_SYMLINKS = 4,
   ALL_METADATA = 8,
   NO_FALLBACK_FOR_MOVE = 16,
   TARGET_DEFAULT_PERMS = 32
}
// Flags used when an operation may create a file.
enum FileCreateFlags {
   NONE = 0,
   PRIVATE = 1,
   REPLACE_DESTINATION = 2
}

// #GFileDescriptorBased is implemented by streams (implementations of
// #GInputStream or #GOutputStream) that are based on file descriptors.
// 
// Note that <filename>&lt;gio/gfiledescriptorbased.h&gt;</filename> belongs to
// the UNIX-specific GIO interfaces, thus you have to use the
// <filename>gio-unix-2.0.pc</filename> pkg-config file when using it.
struct FileDescriptorBased {

   // Gets the underlying file descriptor.
   // RETURNS: The file descriptor
   int get_fd() {
      return g_file_descriptor_based_get_fd(&this);
   }
}

struct FileDescriptorBasedIface {
   GObject2.TypeInterface g_iface;
   // RETURNS: The file descriptor
   extern (C) int function (FileDescriptorBased* fd_based) get_fd;
}


// #GFileEnumerator allows you to operate on a set of #GFile<!-- -->s,
// returning a #GFileInfo structure for each file enumerated (e.g.
// g_file_enumerate_children() will return a #GFileEnumerator for each
// of the children within a directory).
// 
// To get the next file's information from a #GFileEnumerator, use
// g_file_enumerator_next_file() or its asynchronous version,
// g_file_enumerator_next_files_async(). Note that the asynchronous
// version will return a list of #GFileInfo<!---->s, whereas the
// synchronous will only return the next file in the enumerator.
// 
// To close a #GFileEnumerator, use g_file_enumerator_close(), or
// its asynchronous version, g_file_enumerator_close_async(). Once
// a #GFileEnumerator is closed, no further actions may be performed
// on it, and it should be freed with g_object_unref().
struct FileEnumerator /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private FileEnumeratorPrivate* priv;


   // Releases all resources used by this enumerator, making the
   // enumerator return %G_IO_ERROR_CLOSED on all calls.
   // 
   // This will be automatically called when the last reference
   // is dropped, but you might want to call this function to make
   // sure resources are released as early as possible.
   // RETURNS: #TRUE on success or #FALSE on error.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int close(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_enumerator_close(&this, cancellable, error);
   }

   // Asynchronously closes the file enumerator.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned in
   // g_file_enumerator_close_finish().
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void close_async(int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_enumerator_close_async(&this, io_priority, cancellable, callback, user_data);
   }

   // Finishes closing a file enumerator, started from g_file_enumerator_close_async().
   // 
   // If the file enumerator was already closed when g_file_enumerator_close_async()
   // was called, then this function will report %G_IO_ERROR_CLOSED in @error, and
   // return %FALSE. If the file enumerator had pending operation when the close
   // operation was started, then this function will report %G_IO_ERROR_PENDING, and
   // return %FALSE.  If @cancellable was not %NULL, then the operation may have been
   // cancelled by triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %FALSE will be
   // returned.
   // RETURNS: %TRUE if the close operation has finished successfully.
   // <result>: a #GAsyncResult.
   int close_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_enumerator_close_finish(&this, result, error);
   }

   // Get the #GFile container which is being enumerated.
   // RETURNS: the #GFile which is being enumerated.
   File* get_container() {
      return g_file_enumerator_get_container(&this);
   }

   // Checks if the file enumerator has pending operations.
   // RETURNS: %TRUE if the @enumerator has pending operations.
   int has_pending() {
      return g_file_enumerator_has_pending(&this);
   }

   // Checks if the file enumerator has been closed.
   // RETURNS: %TRUE if the @enumerator is closed.
   int is_closed() {
      return g_file_enumerator_is_closed(&this);
   }

   // Returns information for the next file in the enumerated object.
   // Will block until the information is available. The #GFileInfo
   // returned from this function will contain attributes that match the
   // attribute string that was passed when the #GFileEnumerator was created.
   // 
   // On error, returns %NULL and sets @error to the error. If the
   // enumerator is at the end, %NULL will be returned and @error will
   // be unset.
   // 
   // Free the returned object with g_object_unref() when no longer needed.
   // RETURNS: A #GFileInfo or %NULL on error or end of enumerator.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileInfo* /*new*/ next_file(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_enumerator_next_file(&this, cancellable, error);
   }

   // Request information for a number of files from the enumerator asynchronously.
   // When all i/o for the operation is finished the @callback will be called with
   // the requested information.
   // 
   // The callback can be called with less than @num_files files in case of error
   // or at the end of the enumerator. In case of a partial error the callback will
   // be called with any succeeding items and no error, and on the next request the
   // error will be reported. If a request is cancelled the callback will be called
   // with %G_IO_ERROR_CANCELLED.
   // 
   // During an async request no other sync and async calls are allowed, and will
   // result in %G_IO_ERROR_PENDING errors.
   // 
   // Any outstanding i/o request with higher priority (lower numerical value) will
   // be executed before an outstanding request with lower priority. Default
   // priority is %G_PRIORITY_DEFAULT.
   // <num_files>: the number of file info objects to request
   // <io_priority>: the <link linkend="gioscheduler">io priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void next_files_async(int num_files, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_enumerator_next_files_async(&this, num_files, io_priority, cancellable, callback, user_data);
   }

   // Finishes the asynchronous operation started with g_file_enumerator_next_files_async().
   // 
   // g_list_free() and unref the infos with g_object_unref() when you're
   // done with them.
   // RETURNS: a #GList of #GFileInfo<!---->s. You must free the list with
   // <result>: a #GAsyncResult.
   GLib2.List* /*new*/ next_files_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_enumerator_next_files_finish(&this, result, error);
   }

   // Sets the file enumerator as having pending operations.
   // <pending>: a boolean value.
   void set_pending(int pending) {
      g_file_enumerator_set_pending(&this, pending);
   }
}

struct FileEnumeratorClass {
   GObject2.ObjectClass parent_class;

   // RETURNS: A #GFileInfo or %NULL on error or end of enumerator.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileInfo* /*new*/ function (FileEnumerator* enumerator, Cancellable* cancellable, GLib2.Error** error=null) next_file;
   extern (C) int function (FileEnumerator* enumerator, Cancellable* cancellable, GLib2.Error** error=null) close_fn;

   // <num_files>: the number of file info objects to request
   // <io_priority>: the <link linkend="gioscheduler">io priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (FileEnumerator* enumerator, int num_files, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) next_files_async;

   // RETURNS: a #GList of #GFileInfo<!---->s. You must free the list with
   // <result>: a #GAsyncResult.
   extern (C) GLib2.List* /*new*/ function (FileEnumerator* enumerator, AsyncResult* result, GLib2.Error** error=null) next_files_finish;

   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (FileEnumerator* enumerator, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) close_async;

   // RETURNS: %TRUE if the close operation has finished successfully.
   // <result>: a #GAsyncResult.
   extern (C) int function (FileEnumerator* enumerator, AsyncResult* result, GLib2.Error** error=null) close_finish;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
   extern (C) void function () _g_reserved6;
   extern (C) void function () _g_reserved7;
}

struct FileEnumeratorPrivate {
}


// GFileIOStream provides io streams that both read and write to the same
// file handle.
// 
// GFileIOStream implements #GSeekable, which allows the io
// stream to jump to arbitrary positions in the file and to truncate
// the file, provided the filesystem of the file supports these
// operations.
// 
// To find the position of a file io stream, use
// g_seekable_tell().
// 
// To find out if a file io stream supports seeking, use g_seekable_can_seek().
// To position a file io stream, use g_seekable_seek().
// To find out if a file io stream supports truncating, use
// g_seekable_can_truncate(). To truncate a file io
// stream, use g_seekable_truncate().
// 
// The default implementation of all the #GFileIOStream operations
// and the implementation of #GSeekable just call into the same operations
// on the output stream.
struct FileIOStream /* : IOStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance iostream;
   IOStream parent_instance;
   private FileIOStreamPrivate* priv;


   // Gets the entity tag for the file when it has been written.
   // This must be called after the stream has been written
   // and closed, as the etag can change while writing.
   // RETURNS: the entity tag for the stream.
   char* /*new*/ get_etag() {
      return g_file_io_stream_get_etag(&this);
   }

   // Queries a file io stream for the given @attributes.
   // This function blocks while querying the stream. For the asynchronous
   // version of this function, see g_file_io_stream_query_info_async().
   // While the stream is blocked, the stream will set the pending flag
   // internally, and any other operations on the stream will fail with
   // %G_IO_ERROR_PENDING.
   // 
   // Can fail if the stream was already closed (with @error being set to
   // %G_IO_ERROR_CLOSED), the stream has pending operations (with @error being
   // set to %G_IO_ERROR_PENDING), or if querying info is not supported for
   // the stream's interface (with @error being set to %G_IO_ERROR_NOT_SUPPORTED). I
   // all cases of failure, %NULL will be returned.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will
   // be returned.
   // RETURNS: a #GFileInfo for the @stream, or %NULL on error.
   // <attributes>: a file attribute query string.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileInfo* /*new*/ query_info(char* attributes, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_io_stream_query_info(&this, attributes, cancellable, error);
   }

   // Asynchronously queries the @stream for a #GFileInfo. When completed,
   // @callback will be called with a #GAsyncResult which can be used to
   // finish the operation with g_file_io_stream_query_info_finish().
   // 
   // For the synchronous version of this function, see
   // g_file_io_stream_query_info().
   // <attributes>: a file attribute query string.
   // <io_priority>: the <link linkend="gio-GIOScheduler">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void query_info_async(char* attributes, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_io_stream_query_info_async(&this, attributes, io_priority, cancellable, callback, user_data);
   }

   // Finalizes the asynchronous query started
   // by g_file_io_stream_query_info_async().
   // RETURNS: A #GFileInfo for the finished query.
   // <result>: a #GAsyncResult.
   FileInfo* /*new*/ query_info_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_io_stream_query_info_finish(&this, result, error);
   }
}

struct FileIOStreamClass {
   IOStreamClass parent_class;
   extern (C) long function (FileIOStream* stream) tell;
   extern (C) int function (FileIOStream* stream) can_seek;
   extern (C) int function (FileIOStream* stream, long offset, GLib2.SeekType type, Cancellable* cancellable, GLib2.Error** error=null) seek;
   extern (C) int function (FileIOStream* stream) can_truncate;
   extern (C) int function (FileIOStream* stream, long size, Cancellable* cancellable, GLib2.Error** error=null) truncate_fn;

   // RETURNS: a #GFileInfo for the @stream, or %NULL on error.
   // <attributes>: a file attribute query string.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileInfo* /*new*/ function (FileIOStream* stream, char* attributes, Cancellable* cancellable, GLib2.Error** error=null) query_info;

   // <attributes>: a file attribute query string.
   // <io_priority>: the <link linkend="gio-GIOScheduler">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (FileIOStream* stream, char* attributes, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) query_info_async;

   // RETURNS: A #GFileInfo for the finished query.
   // <result>: a #GAsyncResult.
   extern (C) FileInfo* /*new*/ function (FileIOStream* stream, AsyncResult* result, GLib2.Error** error=null) query_info_finish;
   // RETURNS: the entity tag for the stream.
   extern (C) char* /*new*/ function (FileIOStream* stream) get_etag;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct FileIOStreamPrivate {
}


// #GFileIcon specifies an icon by pointing to an image file
// to be used as icon.
struct FileIcon /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Gets the #GFile associated with the given @icon.
   // RETURNS: a #GFile, or %NULL.
   File* get_file() {
      return g_file_icon_get_file(&this);
   }
}

struct FileIconClass {
}

// An interface for writing VFS file handles.
struct FileIface {
   GObject2.TypeInterface g_iface;
   // RETURNS: a new #GFile that is a duplicate of the given #GFile.
   extern (C) File* /*new*/ function (File* file) dup;
   // RETURNS: 0 if @file is not a valid #GFile, otherwise an
   extern (C) uint function (File* file) hash;

   // RETURNS: %TRUE if @file1 and @file2 are equal.
   // <file2>: the second #GFile.
   extern (C) int function (File* file1, File* file2) equal;
   // RETURNS: %TRUE if file is native.
   extern (C) int function (File* file) is_native;

   // RETURNS: %TRUE if #GFile's backend supports the
   // <uri_scheme>: a string containing a URI scheme.
   extern (C) int function (File* file, char* uri_scheme) has_uri_scheme;
   // RETURNS: a string containing the URI scheme for the given
   extern (C) char* /*new*/ function (File* file) get_uri_scheme;
   // RETURNS: string containing the #GFile's base name, or %NULL
   extern (C) char* /*new*/ function (File* file) get_basename;
   // RETURNS: string containing the #GFile's path, or %NULL if
   extern (C) char* /*new*/ function (File* file) get_path;
   // RETURNS: a string containing the #GFile's URI.
   extern (C) char* /*new*/ function (File* file) get_uri;
   // RETURNS: a string containing the #GFile's parse name. The returned
   extern (C) char* /*new*/ function (File* file) get_parse_name;
   // RETURNS: a #GFile structure to the parent of the given
   extern (C) File* /*new*/ function (File* file) get_parent;

   // RETURNS: %TRUE if the @files's parent, grandparent, etc is @prefix.
   // <file>: input #GFile.
   extern (C) int function (File* prefix, File* file) prefix_matches;

   // RETURNS: string with the relative path from @descendant
   // <descendant>: input #GFile.
   extern (C) char* /*new*/ function (File* parent, File* descendant) get_relative_path;

   // RETURNS: #GFile to the resolved path. %NULL if @relative_path
   // <relative_path>: a given relative path string.
   extern (C) File* /*new*/ function (File* file, char* relative_path) resolve_relative_path;

   // RETURNS: a #GFile to the specified child, or
   // <display_name>: string to a possible child.
   extern (C) File* /*new*/ function (File* file, char* display_name, GLib2.Error** error=null) get_child_for_display_name;

   // RETURNS: A #GFileEnumerator if successful, %NULL on error.
   // <attributes>: an attribute query string.
   // <flags>: a set of #GFileQueryInfoFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileEnumerator* /*new*/ function (File* file, char* attributes, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) enumerate_children;

   // <attributes>: an attribute query string.
   // <flags>: a set of #GFileQueryInfoFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, char* attributes, FileQueryInfoFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) enumerate_children_async;

   // RETURNS: a #GFileEnumerator or %NULL if an error occurred.
   // <res>: a #GAsyncResult.
   extern (C) FileEnumerator* /*new*/ function (File* file, AsyncResult* res, GLib2.Error** error=null) enumerate_children_finish;

   // RETURNS: a #GFileInfo for the given @file, or %NULL on error.
   // <attributes>: an attribute query string.
   // <flags>: a set of #GFileQueryInfoFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileInfo* /*new*/ function (File* file, char* attributes, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) query_info;

   // <attributes>: an attribute query string.
   // <flags>: a set of #GFileQueryInfoFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, char* attributes, FileQueryInfoFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) query_info_async;

   // RETURNS: #GFileInfo for given @file or %NULL on error.
   // <res>: a #GAsyncResult.
   extern (C) FileInfo* /*new*/ function (File* file, AsyncResult* res, GLib2.Error** error=null) query_info_finish;

   // RETURNS: a #GFileInfo or %NULL if there was an error.
   // <attributes>: an attribute query string.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileInfo* /*new*/ function (File* file, char* attributes, Cancellable* cancellable, GLib2.Error** error=null) query_filesystem_info;

   // <attributes>: an attribute query string.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, char* attributes, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) query_filesystem_info_async;

   // RETURNS: #GFileInfo for given @file or %NULL on error.
   // <res>: a #GAsyncResult.
   extern (C) FileInfo* /*new*/ function (File* file, AsyncResult* res, GLib2.Error** error=null) query_filesystem_info_finish;

   // RETURNS: a #GMount where the @file is located or %NULL on error.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) Mount* /*new*/ function (File* file, Cancellable* cancellable, GLib2.Error** error=null) find_enclosing_mount;

   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) find_enclosing_mount_async;

   // RETURNS: #GMount for given @file or %NULL on error.
   // <res>: a #GAsyncResult
   extern (C) Mount* /*new*/ function (File* file, AsyncResult* res, GLib2.Error** error=null) find_enclosing_mount_finish;

   // RETURNS: a #GFile specifying what @file was renamed to, or %NULL
   // <display_name>: a string.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) File* /*new*/ function (File* file, char* display_name, Cancellable* cancellable, GLib2.Error** error=null) set_display_name;

   // <display_name>: a string.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, char* display_name, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) set_display_name_async;

   // RETURNS: a #GFile or %NULL on error.
   // <res>: a #GAsyncResult.
   extern (C) File* /*new*/ function (File* file, AsyncResult* res, GLib2.Error** error=null) set_display_name_finish;

   // RETURNS: a #GFileAttributeInfoList describing the settable attributes.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileAttributeInfoList* /*new*/ function (File* file, Cancellable* cancellable, GLib2.Error** error=null) query_settable_attributes;
   extern (C) void function () _query_settable_attributes_async;
   extern (C) void function () _query_settable_attributes_finish;

   // RETURNS: a #GFileAttributeInfoList describing the writable namespaces.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileAttributeInfoList* /*new*/ function (File* file, Cancellable* cancellable, GLib2.Error** error=null) query_writable_namespaces;
   extern (C) void function () _query_writable_namespaces_async;
   extern (C) void function () _query_writable_namespaces_finish;

   // RETURNS: %TRUE if the attribute was set, %FALSE otherwise.
   // <attribute>: a string containing the attribute's name.
   // <type>: The type of the attribute
   // <value_p>: a pointer to the value (or the pointer itself if the type is a pointer type)
   // <flags>: a set of #GFileQueryInfoFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) int function (File* file, char* attribute, FileAttributeType type, void* value_p, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) set_attribute;

   // RETURNS: %TRUE if there was any error, %FALSE otherwise.
   // <info>: a #GFileInfo.
   // <flags>: #GFileQueryInfoFlags
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) int function (File* file, FileInfo* info, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) set_attributes_from_info;

   // <info>: a #GFileInfo.
   // <flags>: a #GFileQueryInfoFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback.
   // <user_data>: a #gpointer.
   extern (C) void function (File* file, FileInfo* info, FileQueryInfoFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) set_attributes_async;

   // RETURNS: %TRUE if the attributes were set correctly, %FALSE otherwise.
   // <result>: a #GAsyncResult.
   // <info>: a #GFileInfo.
   extern (C) int function (File* file, AsyncResult* result, /*out*/ FileInfo** info, GLib2.Error** error=null) set_attributes_finish;

   // RETURNS: #GFileInputStream or %NULL on error.
   // <cancellable>: a #GCancellable
   extern (C) FileInputStream* /*new*/ function (File* file, Cancellable* cancellable, GLib2.Error** error=null) read_fn;

   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) read_async;

   // RETURNS: a #GFileInputStream or %NULL on error.
   // <res>: a #GAsyncResult.
   extern (C) FileInputStream* /*new*/ function (File* file, AsyncResult* res, GLib2.Error** error=null) read_finish;

   // RETURNS: a #GFileOutputStream, or %NULL on error.
   // <flags>: a set of #GFileCreateFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileOutputStream* /*new*/ function (File* file, FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error=null) append_to;

   // <flags>: a set of #GFileCreateFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) append_to_async;

   // RETURNS: a valid #GFileOutputStream or %NULL on error.
   // <res>: #GAsyncResult
   extern (C) FileOutputStream* /*new*/ function (File* file, AsyncResult* res, GLib2.Error** error=null) append_to_finish;

   // RETURNS: a #GFileOutputStream for the newly created file, or
   // <flags>: a set of #GFileCreateFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileOutputStream* /*new*/ function (File* file, FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error=null) create;

   // <flags>: a set of #GFileCreateFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) create_async;

   // RETURNS: a #GFileOutputStream or %NULL on error.
   // <res>: a #GAsyncResult.
   extern (C) FileOutputStream* /*new*/ function (File* file, AsyncResult* res, GLib2.Error** error=null) create_finish;

   // RETURNS: a #GFileOutputStream or %NULL on error.
   // <etag>: an optional <link linkend="gfile-etag">entity tag</link> for the current #GFile, or #NULL to ignore.
   // <make_backup>: %TRUE if a backup should be created.
   // <flags>: a set of #GFileCreateFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileOutputStream* /*new*/ function (File* file, char* etag, int make_backup, FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error=null) replace;

   // <etag>: an <link linkend="gfile-etag">entity tag</link> for the current #GFile, or NULL to ignore.
   // <make_backup>: %TRUE if a backup should be created.
   // <flags>: a set of #GFileCreateFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, char* etag, int make_backup, FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) replace_async;

   // RETURNS: a #GFileOutputStream, or %NULL on error.
   // <res>: a #GAsyncResult.
   extern (C) FileOutputStream* /*new*/ function (File* file, AsyncResult* res, GLib2.Error** error=null) replace_finish;

   // RETURNS: %TRUE if the file was deleted. %FALSE otherwise.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) int function (File* file, Cancellable* cancellable, GLib2.Error** error=null) delete_file;
   extern (C) void function () _delete_file_async;
   extern (C) void function () _delete_file_finish;

   // RETURNS: %TRUE on successful trash, %FALSE otherwise.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) int function (File* file, Cancellable* cancellable, GLib2.Error** error=null) trash;
   extern (C) void function () _trash_async;
   extern (C) void function () _trash_finish;

   // RETURNS: %TRUE on successful creation, %FALSE otherwise.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) int function (File* file, Cancellable* cancellable, GLib2.Error** error=null) make_directory;
   extern (C) void function () _make_directory_async;
   extern (C) void function () _make_directory_finish;

   // RETURNS: %TRUE on the creation of a new symlink, %FALSE otherwise.
   // <symlink_value>: a string with the path for the target of the new symlink
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) int function (File* file, char* symlink_value, Cancellable* cancellable, GLib2.Error** error=null) make_symbolic_link;
   extern (C) void function () _make_symbolic_link_async;
   extern (C) void function () _make_symbolic_link_finish;

   // RETURNS: %TRUE on success, %FALSE otherwise.
   // <destination>: destination #GFile
   // <flags>: set of #GFileCopyFlags
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <progress_callback>: function to callback with progress information
   // <progress_callback_data>: user data to pass to @progress_callback
   extern (C) int function (File* source, File* destination, FileCopyFlags flags, Cancellable* cancellable, FileProgressCallback progress_callback, void* progress_callback_data, GLib2.Error** error=null) copy;

   // Unintrospectable functionp: copy_async() / ()
   // 
   // <destination>: destination #GFile
   // <flags>: set of #GFileCopyFlags
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <progress_callback>: function to callback with progress information
   // <progress_callback_data>: user data to pass to @progress_callback
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* source, File* destination, FileCopyFlags flags, int io_priority, Cancellable* cancellable, FileProgressCallback progress_callback, void* progress_callback_data, AsyncReadyCallback callback, void* user_data) copy_async;

   // RETURNS: a %TRUE on success, %FALSE on error.
   // <res>: a #GAsyncResult.
   extern (C) int function (File* file, AsyncResult* res, GLib2.Error** error=null) copy_finish;

   // RETURNS: %TRUE on successful move, %FALSE otherwise.
   // <destination>: #GFile pointing to the destination location.
   // <flags>: set of #GFileCopyFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <progress_callback>: #GFileProgressCallback function for updates.
   // <progress_callback_data>: gpointer to user data for the callback function.
   extern (C) int function (File* source, File* destination, FileCopyFlags flags, Cancellable* cancellable, FileProgressCallback progress_callback, void* progress_callback_data, GLib2.Error** error=null) move;
   extern (C) void function () _move_async;
   extern (C) void function () _move_finish;

   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation, or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, MountMountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) mount_mountable;

   // RETURNS: a #GFile or %NULL on error.
   // <result>: a #GAsyncResult.
   extern (C) File* /*new*/ function (File* file, AsyncResult* result, GLib2.Error** error=null) mount_mountable_finish;

   // <flags>: flags affecting the operation
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) unmount_mountable;

   // RETURNS: %TRUE if the operation finished successfully. %FALSE
   // <result>: a #GAsyncResult.
   extern (C) int function (File* file, AsyncResult* result, GLib2.Error** error=null) unmount_mountable_finish;

   // <flags>: flags affecting the operation
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) eject_mountable;

   // RETURNS: %TRUE if the @file was ejected successfully. %FALSE
   // <result>: a #GAsyncResult.
   extern (C) int function (File* file, AsyncResult* result, GLib2.Error** error=null) eject_mountable_finish;

   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* location, MountMountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) mount_enclosing_volume;

   // RETURNS: %TRUE if successful. If an error
   // <result>: a #GAsyncResult.
   extern (C) int function (File* location, AsyncResult* result, GLib2.Error** error=null) mount_enclosing_volume_finish;

   // RETURNS: a #GFileMonitor for the given @file, or %NULL on error.
   // <flags>: a set of #GFileMonitorFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileMonitor* /*new*/ function (File* file, FileMonitorFlags flags, Cancellable* cancellable, GLib2.Error** error=null) monitor_dir;

   // RETURNS: a #GFileMonitor for the given @file, or %NULL on error.
   // <flags>: a set of #GFileMonitorFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileMonitor* /*new*/ function (File* file, FileMonitorFlags flags, Cancellable* cancellable, GLib2.Error** error=null) monitor_file;

   // RETURNS: #GFileIOStream or %NULL on error.
   // <cancellable>: a #GCancellable
   extern (C) FileIOStream* /*new*/ function (File* file, Cancellable* cancellable, GLib2.Error** error=null) open_readwrite;

   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) open_readwrite_async;

   // RETURNS: a #GFileIOStream or %NULL on error.
   // <res>: a #GAsyncResult.
   extern (C) FileIOStream* /*new*/ function (File* file, AsyncResult* res, GLib2.Error** error=null) open_readwrite_finish;

   // RETURNS: a #GFileIOStream for the newly created file, or %NULL on error.
   // <flags>: a set of #GFileCreateFlags
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   extern (C) FileIOStream* /*new*/ function (File* file, FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error=null) create_readwrite;

   // <flags>: a set of #GFileCreateFlags
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) create_readwrite_async;

   // RETURNS: a #GFileIOStream or %NULL on error.
   // <res>: a #GAsyncResult
   extern (C) FileIOStream* /*new*/ function (File* file, AsyncResult* res, GLib2.Error** error=null) create_readwrite_finish;

   // RETURNS: a #GFileIOStream or %NULL on error.
   // <etag>: an optional <link linkend="gfile-etag">entity tag</link> for the current #GFile, or #NULL to ignore
   // <make_backup>: %TRUE if a backup should be created
   // <flags>: a set of #GFileCreateFlags
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   extern (C) FileIOStream* /*new*/ function (File* file, char* etag, int make_backup, FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error=null) replace_readwrite;

   // <etag>: an <link linkend="gfile-etag">entity tag</link> for the current #GFile, or NULL to ignore.
   // <make_backup>: %TRUE if a backup should be created.
   // <flags>: a set of #GFileCreateFlags.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, char* etag, int make_backup, FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) replace_readwrite_async;

   // RETURNS: a #GFileIOStream, or %NULL on error.
   // <res>: a #GAsyncResult.
   extern (C) FileIOStream* /*new*/ function (File* file, AsyncResult* res, GLib2.Error** error=null) replace_readwrite_finish;

   // <flags>: flags affecting the operation
   // <start_operation>: a #GMountOperation, or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, DriveStartFlags flags, MountOperation* start_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) start_mountable;

   // RETURNS: %TRUE if the operation finished successfully. %FALSE
   // <result>: a #GAsyncResult.
   extern (C) int function (File* file, AsyncResult* result, GLib2.Error** error=null) start_mountable_finish;

   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation, or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) stop_mountable;

   // RETURNS: %TRUE if the operation finished successfully. %FALSE
   // <result>: a #GAsyncResult.
   extern (C) int function (File* file, AsyncResult* result, GLib2.Error** error=null) stop_mountable_finish;
   int supports_thread_contexts;

   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation, or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) unmount_mountable_with_operation;

   // RETURNS: %TRUE if the operation finished successfully. %FALSE
   // <result>: a #GAsyncResult.
   extern (C) int function (File* file, AsyncResult* result, GLib2.Error** error=null) unmount_mountable_with_operation_finish;

   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation, or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) eject_mountable_with_operation;

   // RETURNS: %TRUE if the @file was ejected successfully. %FALSE
   // <result>: a #GAsyncResult.
   extern (C) int function (File* file, AsyncResult* result, GLib2.Error** error=null) eject_mountable_with_operation_finish;

   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied, or %NULL.
   // <user_data>: the data to pass to callback function
   extern (C) void function (File* file, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) poll_mountable;

   // RETURNS: %TRUE if the operation finished successfully. %FALSE
   // <result>: a #GAsyncResult.
   extern (C) int function (File* file, AsyncResult* result, GLib2.Error** error=null) poll_mountable_finish;
}


// Functionality for manipulating basic metadata for files. #GFileInfo
// implements methods for getting information that all files should
// contain, and allows for manipulation of extended attributes.
// 
// See <link linkend="gio-GFileAttribute">GFileAttribute</link> for more
// information on how GIO handles file attributes.
// 
// To obtain a #GFileInfo for a #GFile, use g_file_query_info() (or its
// async variant). To obtain a #GFileInfo for a file input or output
// stream, use g_file_input_stream_query_info() or
// g_file_output_stream_query_info() (or their async variants).
// 
// To change the actual attributes of a file, you should then set the
// attribute in the #GFileInfo and call g_file_set_attributes_from_info()
// or g_file_set_attributes_async() on a GFile.
// 
// However, not all attributes can be changed in the file. For instance,
// the actual size of a file cannot be changed via g_file_info_set_size().
// You may call g_file_query_settable_attributes() and
// g_file_query_writable_namespaces() to discover the settable attributes
// of a particular file at runtime.
// 
// #GFileAttributeMatcher allows for searching through a #GFileInfo for
// attributes.
struct FileInfo /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new file info structure.
   // RETURNS: a #GFileInfo.
   static FileInfo* /*new*/ new_() {
      return g_file_info_new();
   }
   // Clears the status information from @info.
   void clear_status() {
      g_file_info_clear_status(&this);
   }

   // Copies all of the #GFileAttribute<!-- -->s from @src_info to @dest_info.
   // <dest_info>: destination to copy attributes to.
   void copy_into(FileInfo* dest_info) {
      g_file_info_copy_into(&this, dest_info);
   }

   // Duplicates a file info structure.
   // RETURNS: a duplicate #GFileInfo of @other.
   FileInfo* /*new*/ dup() {
      return g_file_info_dup(&this);
   }

   // Gets the value of a attribute, formated as a string.
   // This escapes things as needed to make the string valid
   // utf8.
   // 
   // When you're done with the string it must be freed with g_free().
   // RETURNS: a UTF-8 string associated with the given @attribute.
   // <attribute>: a file attribute key.
   char* /*new*/ get_attribute_as_string(char* attribute) {
      return g_file_info_get_attribute_as_string(&this, attribute);
   }

   // Gets the value of a boolean attribute. If the attribute does not
   // contain a boolean value, %FALSE will be returned.
   // RETURNS: the boolean value contained within the attribute.
   // <attribute>: a file attribute key.
   int get_attribute_boolean(char* attribute) {
      return g_file_info_get_attribute_boolean(&this, attribute);
   }

   // Gets the value of a byte string attribute. If the attribute does
   // not contain a byte string, %NULL will be returned.
   // 
   // %NULL otherwise.
   // RETURNS: the contents of the @attribute value as a byte string, or
   // <attribute>: a file attribute key.
   char* get_attribute_byte_string(char* attribute) {
      return g_file_info_get_attribute_byte_string(&this, attribute);
   }

   // Gets the attribute type, value and status for an attribute key.
   // 
   // %FALSE otherwise.
   // RETURNS: %TRUE if @info has an attribute named @attribute,
   // <attribute>: a file attribute key
   // <type>: return location for the attribute type, or %NULL
   // <value_pp>: return location for the attribute value, or %NULL
   // <status>: return location for the attribute status, or %NULL
   int get_attribute_data(char* attribute, /*out*/ FileAttributeType* type=null, /*out*/ void** value_pp=null, /*out*/ FileAttributeStatus* status=null) {
      return g_file_info_get_attribute_data(&this, attribute, type, value_pp, status);
   }

   // Gets a signed 32-bit integer contained within the attribute. If the
   // attribute does not contain a signed 32-bit integer, or is invalid,
   // 0 will be returned.
   // RETURNS: a signed 32-bit integer from the attribute.
   // <attribute>: a file attribute key.
   int get_attribute_int32(char* attribute) {
      return g_file_info_get_attribute_int32(&this, attribute);
   }

   // Gets a signed 64-bit integer contained within the attribute. If the
   // attribute does not contain an signed 64-bit integer, or is invalid,
   // 0 will be returned.
   // RETURNS: a signed 64-bit integer from the attribute.
   // <attribute>: a file attribute key.
   long get_attribute_int64(char* attribute) {
      return g_file_info_get_attribute_int64(&this, attribute);
   }

   // Gets the value of a #GObject attribute. If the attribute does
   // not contain a #GObject, %NULL will be returned.
   // 
   // %NULL otherwise.
   // RETURNS: a #GObject associated with the given @attribute, or
   // <attribute>: a file attribute key.
   GObject2.Object* get_attribute_object(char* attribute) {
      return g_file_info_get_attribute_object(&this, attribute);
   }

   // Gets the attribute status for an attribute key.
   // 
   // %G_FILE_ATTRIBUTE_STATUS_UNSET if the key is invalid.
   // RETURNS: a #GFileAttributeStatus for the given @attribute, or
   // <attribute>: a file attribute key
   FileAttributeStatus get_attribute_status(char* attribute) {
      return g_file_info_get_attribute_status(&this, attribute);
   }

   // Gets the value of a string attribute. If the attribute does
   // not contain a string, %NULL will be returned.
   // 
   // %NULL otherwise.
   // RETURNS: the contents of the @attribute value as a UTF-8 string, or
   // <attribute>: a file attribute key.
   char* get_attribute_string(char* attribute) {
      return g_file_info_get_attribute_string(&this, attribute);
   }

   // Gets the value of a stringv attribute. If the attribute does
   // not contain a stringv, %NULL will be returned.
   // 
   // %NULL otherwise. Do not free. These returned strings are UTF-8.
   // RETURNS: the contents of the @attribute value as a stringv, or
   // <attribute>: a file attribute key.
   char** get_attribute_stringv(char* attribute) {
      return g_file_info_get_attribute_stringv(&this, attribute);
   }

   // Gets the attribute type for an attribute key.
   // 
   // %G_FILE_ATTRIBUTE_TYPE_INVALID if the key is not set.
   // RETURNS: a #GFileAttributeType for the given @attribute, or
   // <attribute>: a file attribute key.
   FileAttributeType get_attribute_type(char* attribute) {
      return g_file_info_get_attribute_type(&this, attribute);
   }

   // Gets an unsigned 32-bit integer contained within the attribute. If the
   // attribute does not contain an unsigned 32-bit integer, or is invalid,
   // 0 will be returned.
   // RETURNS: an unsigned 32-bit integer from the attribute.
   // <attribute>: a file attribute key.
   uint get_attribute_uint32(char* attribute) {
      return g_file_info_get_attribute_uint32(&this, attribute);
   }

   // Gets a unsigned 64-bit integer contained within the attribute. If the
   // attribute does not contain an unsigned 64-bit integer, or is invalid,
   // 0 will be returned.
   // RETURNS: a unsigned 64-bit integer from the attribute.
   // <attribute>: a file attribute key.
   ulong get_attribute_uint64(char* attribute) {
      return g_file_info_get_attribute_uint64(&this, attribute);
   }

   // Gets the file's content type.
   // RETURNS: a string containing the file's content type.
   char* get_content_type() {
      return g_file_info_get_content_type(&this);
   }

   // Gets a display name for a file.
   // RETURNS: a string containing the display name.
   char* get_display_name() {
      return g_file_info_get_display_name(&this);
   }

   // Gets the edit name for a file.
   // RETURNS: a string containing the edit name.
   char* get_edit_name() {
      return g_file_info_get_edit_name(&this);
   }

   // Gets the <link linkend="gfile-etag">entity tag</link> for a given
   // #GFileInfo. See %G_FILE_ATTRIBUTE_ETAG_VALUE.
   // RETURNS: a string containing the value of the "etag:value" attribute.
   char* get_etag() {
      return g_file_info_get_etag(&this);
   }

   // Gets a file's type (whether it is a regular file, symlink, etc).
   // This is different from the file's content type, see g_file_info_get_content_type().
   // RETURNS: a #GFileType for the given file.
   FileType get_file_type() {
      return g_file_info_get_file_type(&this);
   }

   // Gets the icon for a file.
   // RETURNS: #GIcon for the given @info.
   Icon* get_icon() {
      return g_file_info_get_icon(&this);
   }

   // Checks if a file is a backup file.
   // RETURNS: %TRUE if file is a backup file, %FALSE otherwise.
   int get_is_backup() {
      return g_file_info_get_is_backup(&this);
   }

   // Checks if a file is hidden.
   // RETURNS: %TRUE if the file is a hidden file, %FALSE otherwise.
   int get_is_hidden() {
      return g_file_info_get_is_hidden(&this);
   }

   // Checks if a file is a symlink.
   // RETURNS: %TRUE if the given @info is a symlink.
   int get_is_symlink() {
      return g_file_info_get_is_symlink(&this);
   }

   // Gets the modification time of the current @info and sets it
   // in @result.
   // <result>: a #GTimeVal.
   void get_modification_time(GLib2.TimeVal* result) {
      g_file_info_get_modification_time(&this, result);
   }

   // Gets the name for a file.
   // RETURNS: a string containing the file name.
   char* get_name() {
      return g_file_info_get_name(&this);
   }

   // Gets the file's size.
   // RETURNS: a #goffset containing the file's size.
   long get_size() {
      return g_file_info_get_size(&this);
   }

   // Gets the value of the sort_order attribute from the #GFileInfo.
   // See %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER.
   // RETURNS: a #gint32 containing the value of the "standard::sort_order" attribute.
   int get_sort_order() {
      return g_file_info_get_sort_order(&this);
   }

   // Gets the symlink target for a given #GFileInfo.
   // RETURNS: a string containing the symlink target.
   char* get_symlink_target() {
      return g_file_info_get_symlink_target(&this);
   }

   // Checks if a file info structure has an attribute named @attribute.
   // 
   // %FALSE otherwise.
   // RETURNS: %TRUE if @Ginfo has an attribute named @attribute,
   // <attribute>: a file attribute key.
   int has_attribute(char* attribute) {
      return g_file_info_has_attribute(&this, attribute);
   }

   // Checks if a file info structure has an attribute in the
   // specified @name_space.
   // 
   // %FALSE otherwise.
   // RETURNS: %TRUE if @Ginfo has an attribute in @name_space,
   // <name_space>: a file attribute namespace.
   int has_namespace(char* name_space) {
      return g_file_info_has_namespace(&this, name_space);
   }

   // Lists the file info structure's attributes.
   // 
   // possible attribute types for the given @name_space, or
   // %NULL on error.
   // RETURNS: a null-terminated array of strings of all of the
   // <name_space>: a file attribute key's namespace.
   char** /*new*/ list_attributes(char* name_space) {
      return g_file_info_list_attributes(&this, name_space);
   }

   // Removes all cases of @attribute from @info if it exists.
   // <attribute>: a file attribute key.
   void remove_attribute(char* attribute) {
      g_file_info_remove_attribute(&this, attribute);
   }

   // Sets the @attribute to contain the given value, if possible.
   // <attribute>: a file attribute key.
   // <type>: a #GFileAttributeType
   // <value_p>: pointer to the value
   void set_attribute(char* attribute, FileAttributeType type, void* value_p) {
      g_file_info_set_attribute(&this, attribute, type, value_p);
   }

   // Sets the @attribute to contain the given @attr_value,
   // if possible.
   // <attribute>: a file attribute key.
   // <attr_value>: a boolean value.
   void set_attribute_boolean(char* attribute, int attr_value) {
      g_file_info_set_attribute_boolean(&this, attribute, attr_value);
   }

   // Sets the @attribute to contain the given @attr_value,
   // if possible.
   // <attribute>: a file attribute key.
   // <attr_value>: a byte string.
   void set_attribute_byte_string(char* attribute, char* attr_value) {
      g_file_info_set_attribute_byte_string(&this, attribute, attr_value);
   }

   // Sets the @attribute to contain the given @attr_value,
   // if possible.
   // <attribute>: a file attribute key.
   // <attr_value>: a signed 32-bit integer
   void set_attribute_int32(char* attribute, int attr_value) {
      g_file_info_set_attribute_int32(&this, attribute, attr_value);
   }

   // Sets the @attribute to contain the given @attr_value,
   // if possible.
   // <attribute>: attribute name to set.
   // <attr_value>: int64 value to set attribute to.
   void set_attribute_int64(char* attribute, long attr_value) {
      g_file_info_set_attribute_int64(&this, attribute, attr_value);
   }

   // Sets @mask on @info to match specific attribute types.
   // <mask>: a #GFileAttributeMatcher.
   void set_attribute_mask(FileAttributeMatcher* mask) {
      g_file_info_set_attribute_mask(&this, mask);
   }

   // Sets the @attribute to contain the given @attr_value,
   // if possible.
   // <attribute>: a file attribute key.
   // <attr_value>: a #GObject.
   void set_attribute_object(char* attribute, GObject2.Object* attr_value) {
      g_file_info_set_attribute_object(&this, attribute, attr_value);
   }

   // Sets the attribute status for an attribute key. This is only
   // needed by external code that implement g_file_set_attributes_from_info()
   // or similar functions.
   // 
   // The attribute must exist in @info for this to work. Otherwise %FALSE
   // is returned and @info is unchanged.
   // RETURNS: %TRUE if the status was changed, %FALSE if the key was not set.
   // <attribute>: a file attribute key
   // <status>: a #GFileAttributeStatus
   int set_attribute_status(char* attribute, FileAttributeStatus status) {
      return g_file_info_set_attribute_status(&this, attribute, status);
   }

   // Sets the @attribute to contain the given @attr_value,
   // if possible.
   // <attribute>: a file attribute key.
   // <attr_value>: a UTF-8 string.
   void set_attribute_string(char* attribute, char* attr_value) {
      g_file_info_set_attribute_string(&this, attribute, attr_value);
   }

   // Sets the @attribute to contain the given @attr_value,
   // if possible.
   // 
   // Sinze: 2.22
   // <attribute>: a file attribute key
   // <attr_value>: a %NULL terminated array of UTF-8 strings.
   void set_attribute_stringv(char* attribute, char** attr_value) {
      g_file_info_set_attribute_stringv(&this, attribute, attr_value);
   }

   // Sets the @attribute to contain the given @attr_value,
   // if possible.
   // <attribute>: a file attribute key.
   // <attr_value>: an unsigned 32-bit integer.
   void set_attribute_uint32(char* attribute, uint attr_value) {
      g_file_info_set_attribute_uint32(&this, attribute, attr_value);
   }

   // Sets the @attribute to contain the given @attr_value,
   // if possible.
   // <attribute>: a file attribute key.
   // <attr_value>: an unsigned 64-bit integer.
   void set_attribute_uint64(char* attribute, ulong attr_value) {
      g_file_info_set_attribute_uint64(&this, attribute, attr_value);
   }

   // Sets the content type attribute for a given #GFileInfo.
   // See %G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE.
   // <content_type>: a content type. See <link linkend="gio-GContentType">GContentType</link>.
   void set_content_type(char* content_type) {
      g_file_info_set_content_type(&this, content_type);
   }

   // Sets the display name for the current #GFileInfo.
   // See %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME.
   // <display_name>: a string containing a display name.
   void set_display_name(char* display_name) {
      g_file_info_set_display_name(&this, display_name);
   }

   // Sets the edit name for the current file.
   // See %G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME.
   // <edit_name>: a string containing an edit name.
   void set_edit_name(char* edit_name) {
      g_file_info_set_edit_name(&this, edit_name);
   }

   // Sets the file type in a #GFileInfo to @type.
   // See %G_FILE_ATTRIBUTE_STANDARD_TYPE.
   // <type>: a #GFileType.
   void set_file_type(FileType type) {
      g_file_info_set_file_type(&this, type);
   }

   // Sets the icon for a given #GFileInfo.
   // See %G_FILE_ATTRIBUTE_STANDARD_ICON.
   // <icon>: a #GIcon.
   void set_icon(Icon* icon) {
      g_file_info_set_icon(&this, icon);
   }

   // Sets the "is_hidden" attribute in a #GFileInfo according to @is_symlink.
   // See %G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN.
   // <is_hidden>: a #gboolean.
   void set_is_hidden(int is_hidden) {
      g_file_info_set_is_hidden(&this, is_hidden);
   }

   // Sets the "is_symlink" attribute in a #GFileInfo according to @is_symlink.
   // See %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK.
   // <is_symlink>: a #gboolean.
   void set_is_symlink(int is_symlink) {
      g_file_info_set_is_symlink(&this, is_symlink);
   }

   // Sets the %G_FILE_ATTRIBUTE_TIME_MODIFIED attribute in the file
   // info to the given time value.
   // <mtime>: a #GTimeVal.
   void set_modification_time(GLib2.TimeVal* mtime) {
      g_file_info_set_modification_time(&this, mtime);
   }

   // Sets the name attribute for the current #GFileInfo.
   // See %G_FILE_ATTRIBUTE_STANDARD_NAME.
   // <name>: a string containing a name.
   void set_name(char* name) {
      g_file_info_set_name(&this, name);
   }

   // Sets the %G_FILE_ATTRIBUTE_STANDARD_SIZE attribute in the file info
   // to the given size.
   // <size>: a #goffset containing the file's size.
   void set_size(long size) {
      g_file_info_set_size(&this, size);
   }

   // Sets the sort order attribute in the file info structure. See
   // %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER.
   // <sort_order>: a sort order integer.
   void set_sort_order(int sort_order) {
      g_file_info_set_sort_order(&this, sort_order);
   }

   // Sets the %G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET attribute in the file info
   // to the given symlink target.
   // <symlink_target>: a static string containing a path to a symlink target.
   void set_symlink_target(char* symlink_target) {
      g_file_info_set_symlink_target(&this, symlink_target);
   }

   // Unsets a mask set by g_file_info_set_attribute_mask(), if one
   // is set.
   void unset_attribute_mask() {
      g_file_info_unset_attribute_mask(&this);
   }
}

struct FileInfoClass {
}


// GFileInputStream provides input streams that take their
// content from a file.
// 
// GFileInputStream implements #GSeekable, which allows the input
// stream to jump to arbitrary positions in the file, provided the
// filesystem of the file allows it. To find the position of a file
// input stream, use g_seekable_tell(). To find out if a file input
// stream supports seeking, use g_seekable_stream_can_seek().
// To position a file input stream, use g_seekable_seek().
struct FileInputStream /* : InputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance inputstream;
   InputStream parent_instance;
   private FileInputStreamPrivate* priv;


   // Queries a file input stream the given @attributes. This function blocks
   // while querying the stream. For the asynchronous (non-blocking) version
   // of this function, see g_file_input_stream_query_info_async(). While the
   // stream is blocked, the stream will set the pending flag internally, and
   // any other operations on the stream will fail with %G_IO_ERROR_PENDING.
   // RETURNS: a #GFileInfo, or %NULL on error.
   // <attributes>: a file attribute query string.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileInfo* /*new*/ query_info(char* attributes, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_input_stream_query_info(&this, attributes, cancellable, error);
   }

   // Queries the stream information asynchronously.
   // When the operation is finished @callback will be called.
   // You can then call g_file_input_stream_query_info_finish()
   // to get the result of the operation.
   // 
   // For the synchronous version of this function,
   // see g_file_input_stream_query_info().
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be set
   // <attributes>: a file attribute query string.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void query_info_async(char* attributes, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_input_stream_query_info_async(&this, attributes, io_priority, cancellable, callback, user_data);
   }

   // Finishes an asynchronous info query operation.
   // RETURNS: #GFileInfo.
   // <result>: a #GAsyncResult.
   FileInfo* /*new*/ query_info_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_input_stream_query_info_finish(&this, result, error);
   }
}

struct FileInputStreamClass {
   InputStreamClass parent_class;
   extern (C) long function (FileInputStream* stream) tell;
   extern (C) int function (FileInputStream* stream) can_seek;
   extern (C) int function (FileInputStream* stream, long offset, GLib2.SeekType type, Cancellable* cancellable, GLib2.Error** error=null) seek;

   // RETURNS: a #GFileInfo, or %NULL on error.
   // <attributes>: a file attribute query string.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileInfo* /*new*/ function (FileInputStream* stream, char* attributes, Cancellable* cancellable, GLib2.Error** error=null) query_info;

   // <attributes>: a file attribute query string.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (FileInputStream* stream, char* attributes, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) query_info_async;

   // RETURNS: #GFileInfo.
   // <result>: a #GAsyncResult.
   extern (C) FileInfo* /*new*/ function (FileInputStream* stream, AsyncResult* result, GLib2.Error** error=null) query_info_finish;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct FileInputStreamPrivate {
}


// Monitors a file or directory for changes.
// 
// To obtain a #GFileMonitor for a file or directory, use
// g_file_monitor(), g_file_monitor_file(), or
// g_file_monitor_directory().
// 
// To get informed about changes to the file or directory you are
// monitoring, connect to the #GFileMonitor::changed signal. The
// signal will be emitted in the <link
// linkend="g-main-context-push-thread-default">thread-default main
// context</link> of the thread that the monitor was created in
// (though if the global default main context is blocked, this may
// cause notifications to be blocked even if the thread-default
// context is still running).
struct FileMonitor /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private FileMonitorPrivate* priv;


   // Cancels a file monitor.
   // RETURNS: %TRUE if monitor was cancelled.
   int cancel() {
      return g_file_monitor_cancel(&this);
   }

   // Emits the #GFileMonitor::changed signal if a change
   // has taken place. Should be called from file monitor
   // implementations only.
   // 
   // The signal will be emitted from an idle handler (in the <link
   // linkend="g-main-context-push-thread-default">thread-default main
   // context</link>).
   // <child>: a #GFile.
   // <other_file>: a #GFile.
   // <event_type>: a set of #GFileMonitorEvent flags.
   void emit_event(File* child, File* other_file, FileMonitorEvent event_type) {
      g_file_monitor_emit_event(&this, child, other_file, event_type);
   }

   // Returns whether the monitor is canceled.
   // RETURNS: %TRUE if monitor is canceled. %FALSE otherwise.
   int is_cancelled() {
      return g_file_monitor_is_cancelled(&this);
   }

   // Sets the rate limit to which the @monitor will report
   // consecutive change events to the same file.
   // <limit_msecs>: a non-negative integer with the limit in milliseconds to poll for changes
   void set_rate_limit(int limit_msecs) {
      g_file_monitor_set_rate_limit(&this, limit_msecs);
   }

   // Emitted when @file has been changed.
   // 
   // If using #G_FILE_MONITOR_SEND_MOVED flag and @event_type is
   // #G_FILE_MONITOR_SEND_MOVED, @file will be set to a #GFile containing the
   // old path, and @other_file will be set to a #GFile containing the new path.
   // 
   // In all the other cases, @other_file will be set to #NULL.
   // <file>: a #GFile.
   // <other_file>: a #GFile or #NULL.
   // <event_type>: a #GFileMonitorEvent.
   extern (C) alias static void function (FileMonitor* this_, File* file, File* other_file, FileMonitorEvent* event_type, void* user_data=null) signal_changed;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"changed", CB:signal_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct FileMonitorClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (FileMonitor* monitor, File* file, File* other_file, FileMonitorEvent event_type) changed;
   // RETURNS: %TRUE if monitor was cancelled.
   extern (C) int function (FileMonitor* monitor) cancel;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

// Specifies what type of event a monitor event is.
enum FileMonitorEvent {
   CHANGED = 0,
   CHANGES_DONE_HINT = 1,
   DELETED = 2,
   CREATED = 3,
   ATTRIBUTE_CHANGED = 4,
   PRE_UNMOUNT = 5,
   UNMOUNTED = 6,
   MOVED = 7
}
// Flags used to set what a #GFileMonitor will watch for.
enum FileMonitorFlags {
   NONE = 0,
   WATCH_MOUNTS = 1,
   SEND_MOVED = 2
}
struct FileMonitorPrivate {
}


// GFileOutputStream provides output streams that write their
// content to a file.
// 
// GFileOutputStream implements #GSeekable, which allows the output
// stream to jump to arbitrary positions in the file and to truncate
// the file, provided the filesystem of the file supports these
// operations.
// 
// To find the position of a file output stream, use g_seekable_tell().
// To find out if a file output stream supports seeking, use
// g_seekable_can_seek().To position a file output stream, use
// g_seekable_seek(). To find out if a file output stream supports
// truncating, use g_seekable_can_truncate(). To truncate a file output
// stream, use g_seekable_truncate().
struct FileOutputStream /* : OutputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance outputstream;
   OutputStream parent_instance;
   private FileOutputStreamPrivate* priv;


   // Gets the entity tag for the file when it has been written.
   // This must be called after the stream has been written
   // and closed, as the etag can change while writing.
   // RETURNS: the entity tag for the stream.
   char* /*new*/ get_etag() {
      return g_file_output_stream_get_etag(&this);
   }

   // Queries a file output stream for the given @attributes.
   // This function blocks while querying the stream. For the asynchronous
   // version of this function, see g_file_output_stream_query_info_async().
   // While the stream is blocked, the stream will set the pending flag
   // internally, and any other operations on the stream will fail with
   // %G_IO_ERROR_PENDING.
   // 
   // Can fail if the stream was already closed (with @error being set to
   // %G_IO_ERROR_CLOSED), the stream has pending operations (with @error being
   // set to %G_IO_ERROR_PENDING), or if querying info is not supported for
   // the stream's interface (with @error being set to %G_IO_ERROR_NOT_SUPPORTED). In
   // all cases of failure, %NULL will be returned.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will
   // be returned.
   // RETURNS: a #GFileInfo for the @stream, or %NULL on error.
   // <attributes>: a file attribute query string.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   FileInfo* /*new*/ query_info(char* attributes, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_file_output_stream_query_info(&this, attributes, cancellable, error);
   }

   // Asynchronously queries the @stream for a #GFileInfo. When completed,
   // @callback will be called with a #GAsyncResult which can be used to
   // finish the operation with g_file_output_stream_query_info_finish().
   // 
   // For the synchronous version of this function, see
   // g_file_output_stream_query_info().
   // <attributes>: a file attribute query string.
   // <io_priority>: the <link linkend="gio-GIOScheduler">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void query_info_async(char* attributes, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_file_output_stream_query_info_async(&this, attributes, io_priority, cancellable, callback, user_data);
   }

   // Finalizes the asynchronous query started
   // by g_file_output_stream_query_info_async().
   // RETURNS: A #GFileInfo for the finished query.
   // <result>: a #GAsyncResult.
   FileInfo* /*new*/ query_info_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_file_output_stream_query_info_finish(&this, result, error);
   }
}

struct FileOutputStreamClass {
   OutputStreamClass parent_class;
   extern (C) long function (FileOutputStream* stream) tell;
   extern (C) int function (FileOutputStream* stream) can_seek;
   extern (C) int function (FileOutputStream* stream, long offset, GLib2.SeekType type, Cancellable* cancellable, GLib2.Error** error=null) seek;
   extern (C) int function (FileOutputStream* stream) can_truncate;
   extern (C) int function (FileOutputStream* stream, long size, Cancellable* cancellable, GLib2.Error** error=null) truncate_fn;

   // RETURNS: a #GFileInfo for the @stream, or %NULL on error.
   // <attributes>: a file attribute query string.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) FileInfo* /*new*/ function (FileOutputStream* stream, char* attributes, Cancellable* cancellable, GLib2.Error** error=null) query_info;

   // <attributes>: a file attribute query string.
   // <io_priority>: the <link linkend="gio-GIOScheduler">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (FileOutputStream* stream, char* attributes, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) query_info_async;

   // RETURNS: A #GFileInfo for the finished query.
   // <result>: a #GAsyncResult.
   extern (C) FileInfo* /*new*/ function (FileOutputStream* stream, AsyncResult* result, GLib2.Error** error=null) query_info_finish;
   // RETURNS: the entity tag for the stream.
   extern (C) char* /*new*/ function (FileOutputStream* stream) get_etag;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct FileOutputStreamPrivate {
}


// When doing file operations that may take a while, such as moving
// a file or copying a file, a progress callback is used to pass how
// far along that operation is to the application.
// <current_num_bytes>: the current number of bytes in the operation.
// <total_num_bytes>: the total number of bytes in the operation.
// <user_data>: user data passed to the callback.
extern (C) alias void function (long current_num_bytes, long total_num_bytes, void* user_data) FileProgressCallback;

// Flags used when querying a #GFileInfo.
enum FileQueryInfoFlags {
   NONE = 0,
   NOFOLLOW_SYMLINKS = 1
}

// When loading the partial contents of a file with g_file_load_partial_contents_async(),
// it may become necessary to determine if any more data from the file should be loaded.
// A #GFileReadMoreCallback function facilitates this by returning %TRUE if more data
// should be read, or %FALSE otherwise.
// RETURNS: %TRUE if more data should be read back. %FALSE otherwise.
// <file_contents>: the data as currently read.
// <file_size>: the size of the data currently read.
// <callback_data>: data passed to the callback.
extern (C) alias int function (char* file_contents, long file_size, void* callback_data) FileReadMoreCallback;

// Indicates the file's on-disk type.
enum FileType {
   UNKNOWN = 0,
   REGULAR = 1,
   DIRECTORY = 2,
   SYMBOLIC_LINK = 3,
   SPECIAL = 4,
   SHORTCUT = 5,
   MOUNTABLE = 6
}

// Completes partial file and directory names given a partial string by
// looking in the file system for clues. Can return a list of possible
// completion strings for widget implementations.
struct FilenameCompleter /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new filename completer.
   // RETURNS: a #GFilenameCompleter.
   static FilenameCompleter* /*new*/ new_() {
      return g_filename_completer_new();
   }

   // Obtains a completion for @initial_text from @completer.
   // 
   // This string is not owned by GIO, so remember to g_free() it
   // when finished.
   // RETURNS: a completed string, or %NULL if no completion exists.
   // <initial_text>: text to be completed.
   char* /*new*/ get_completion_suffix(char* initial_text) {
      return g_filename_completer_get_completion_suffix(&this, initial_text);
   }

   // Gets an array of completion strings for a given initial text.
   // 
   // This array must be freed by g_strfreev() when finished.
   // RETURNS: array of strings with possible completions for @initial_text.
   // <initial_text>: text to be completed.
   char** /*new*/ get_completions(char* initial_text) {
      return g_filename_completer_get_completions(&this, initial_text);
   }

   // If @dirs_only is %TRUE, @completer will only
   // complete directory names, and not file names.
   // <dirs_only>: a #gboolean.
   void set_dirs_only(int dirs_only) {
      g_filename_completer_set_dirs_only(&this, dirs_only);
   }
   // Emitted when the file name completion information comes available.
   extern (C) alias static void function (FilenameCompleter* this_, void* user_data=null) signal_got_completion_data;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"got-completion-data", CB:signal_got_completion_data)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"got-completion-data",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct FilenameCompleterClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (FilenameCompleter* filename_completer) got_completion_data;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
}


// Indicates a hint from the file system whether files should be
// previewed in a file manager. Returned as the value of the key
// #G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW.
enum FilesystemPreviewType {
   IF_ALWAYS = 0,
   IF_LOCAL = 1,
   NEVER = 2
}

// Base class for input stream implementations that perform some
// kind of filtering operation on a base stream. Typical examples
// of filtering operations are character set conversion, compression
// and byte order flipping.
struct FilterInputStream /* : InputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance inputstream;
   InputStream parent_instance;
   InputStream* base_stream;


   // Gets the base stream for the filter stream.
   // RETURNS: a #GInputStream.
   InputStream* get_base_stream() {
      return g_filter_input_stream_get_base_stream(&this);
   }

   // Returns whether the base stream will be closed when @stream is
   // closed.
   // RETURNS: %TRUE if the base stream will be closed.
   int get_close_base_stream() {
      return g_filter_input_stream_get_close_base_stream(&this);
   }

   // Sets whether the base stream will be closed when @stream is closed.
   // <close_base>: %TRUE to close the base stream.
   void set_close_base_stream(int close_base) {
      g_filter_input_stream_set_close_base_stream(&this, close_base);
   }
}

struct FilterInputStreamClass {
   InputStreamClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
}


// Base class for output stream implementations that perform some
// kind of filtering operation on a base stream. Typical examples
// of filtering operations are character set conversion, compression
// and byte order flipping.
struct FilterOutputStream /* : OutputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance outputstream;
   OutputStream parent_instance;
   OutputStream* base_stream;


   // Gets the base stream for the filter stream.
   // RETURNS: a #GOutputStream.
   OutputStream* get_base_stream() {
      return g_filter_output_stream_get_base_stream(&this);
   }

   // Returns whether the base stream will be closed when @stream is
   // closed.
   // RETURNS: %TRUE if the base stream will be closed.
   int get_close_base_stream() {
      return g_filter_output_stream_get_close_base_stream(&this);
   }

   // Sets whether the base stream will be closed when @stream is closed.
   // <close_base>: %TRUE to close the base stream.
   void set_close_base_stream(int close_base) {
      g_filter_output_stream_set_close_base_stream(&this, close_base);
   }
}

struct FilterOutputStreamClass {
   OutputStreamClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
}

// Error codes returned by GIO functions.
enum IOErrorEnum {
   FAILED = 0,
   NOT_FOUND = 1,
   EXISTS = 2,
   IS_DIRECTORY = 3,
   NOT_DIRECTORY = 4,
   NOT_EMPTY = 5,
   NOT_REGULAR_FILE = 6,
   NOT_SYMBOLIC_LINK = 7,
   NOT_MOUNTABLE_FILE = 8,
   FILENAME_TOO_LONG = 9,
   INVALID_FILENAME = 10,
   TOO_MANY_LINKS = 11,
   NO_SPACE = 12,
   INVALID_ARGUMENT = 13,
   PERMISSION_DENIED = 14,
   NOT_SUPPORTED = 15,
   NOT_MOUNTED = 16,
   ALREADY_MOUNTED = 17,
   CLOSED = 18,
   CANCELLED = 19,
   PENDING = 20,
   READ_ONLY = 21,
   CANT_CREATE_BACKUP = 22,
   WRONG_ETAG = 23,
   TIMED_OUT = 24,
   WOULD_RECURSE = 25,
   BUSY = 26,
   WOULD_BLOCK = 27,
   HOST_NOT_FOUND = 28,
   WOULD_MERGE = 29,
   FAILED_HANDLED = 30,
   TOO_MANY_OPEN_FILES = 31,
   NOT_INITIALIZED = 32,
   ADDRESS_IN_USE = 33,
   PARTIAL_INPUT = 34,
   INVALID_DATA = 35,
   DBUS_ERROR = 36,
   HOST_UNREACHABLE = 37,
   NETWORK_UNREACHABLE = 38,
   CONNECTION_REFUSED = 39,
   PROXY_FAILED = 40,
   PROXY_AUTH_FAILED = 41,
   PROXY_NEED_AUTH = 42,
   PROXY_NOT_ALLOWED = 43
}
struct IOExtension {

   // Gets the name under which @extension was registered.
   // 
   // Note that the same type may be registered as extension
   // for multiple extension points, under different names.
   // RETURNS: the name of @extension.
   char* get_name() {
      return g_io_extension_get_name(&this);
   }

   // Gets the priority with which @extension was registered.
   // RETURNS: the priority of @extension
   int get_priority() {
      return g_io_extension_get_priority(&this);
   }

   // Unintrospectable method: ref_class() / g_io_extension_ref_class()
   // Gets a reference to the class for the type that is
   // associated with @extension.
   // RETURNS: the #GTypeClass for the type of @extension
   GObject2.TypeClass* /*new*/ ref_class() {
      return g_io_extension_ref_class(&this);
   }
}

struct IOExtensionPoint {

   // Finds a #GIOExtension for an extension point by name.
   // 
   // given name, or %NULL if there is no extension with that name
   // RETURNS: the #GIOExtension for @extension_point that has the
   // <name>: the name of the extension to get
   IOExtension* get_extension_by_name(char* name) {
      return g_io_extension_point_get_extension_by_name(&this, name);
   }

   // Gets a list of all extensions that implement this extension point.
   // The list is sorted by priority, beginning with the highest priority.
   // 
   // #GIOExtension<!-- -->s. The list is owned by GIO and should not be
   // modified.
   // RETURNS: a #GList of
   GLib2.List* get_extensions() {
      return g_io_extension_point_get_extensions(&this);
   }

   // Gets the required type for @extension_point.
   // 
   // or #G_TYPE_INVALID if the extension point has no required type
   // RETURNS: the #GType that all implementations must have,
   Type get_required_type() {
      return g_io_extension_point_get_required_type(&this);
   }

   // Sets the required type for @extension_point to @type.
   // All implementations must henceforth have this type.
   // <type>: the #GType to require
   void set_required_type(Type type) {
      g_io_extension_point_set_required_type(&this, type);
   }

   // Registers @type as extension for the extension point with name
   // @extension_point_name.
   // 
   // If @type has already been registered as an extension for this
   // extension point, the existing #GIOExtension object is returned.
   // RETURNS: a #GIOExtension object for #GType
   // <extension_point_name>: the name of the extension point
   // <type>: the #GType to register as extension
   // <extension_name>: the name for the extension
   // <priority>: the priority for the extension
   static IOExtension* implement(char* extension_point_name, Type type, char* extension_name, int priority) {
      return g_io_extension_point_implement(extension_point_name, type, extension_name, priority);
   }

   // Looks up an existing extension point.
   // 
   // is no registered extension point with the given name.
   // RETURNS: the #GIOExtensionPoint, or %NULL if there
   // <name>: the name of the extension point
   static IOExtensionPoint* lookup(char* name) {
      return g_io_extension_point_lookup(name);
   }

   // Registers an extension point.
   // 
   // owned by GIO and should not be freed.
   // RETURNS: the new #GIOExtensionPoint. This object is
   // <name>: The name of the extension point
   static IOExtensionPoint* register(char* name) {
      return g_io_extension_point_register(name);
   }
}


// Provides an interface and default functions for loading and unloading
// modules. This is used internally to make GIO extensible, but can also
// be used by others to implement module loading.
struct IOModule /* : GObject.TypeModule */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent typemodule;
   GObject2.TypeModule method_parent;


   // Creates a new GIOModule that will load the specific
   // shared library when in use.
   // 
   // or %NULL on error.
   // RETURNS: a #GIOModule from given @filename,
   // <filename>: filename of the shared library module.
   static IOModule* /*new*/ new_(char* filename) {
      return g_io_module_new(filename);
   }

   // Optional API for GIO modules to implement.
   // 
   // Should return a list of all the extension points that may be
   // implemented in this module.
   // 
   // This method will not be called in normal use, however it may be
   // called when probing existing modules and recording which extension
   // points that this model is used for. This means we won't have to
   // load and initialze this module unless its needed.
   // 
   // If this function is not implemented by the module the module will
   // always be loaded, initialized and then unloaded on application startup
   // so that it can register its extension points during init.
   // 
   // Note that a module need not actually implement all the extension points
   // that g_io_module_query returns, since the exact list of extension may
   // depend on runtime issues. However all extension points actually implemented
   // must be returned by g_io_module_query() (if defined).
   // 
   // When installing a module that implements g_io_module_query you must
   // run gio-querymodules in order to build the cache files required for
   // lazy loading.
   // 
   // extension points of the module. The array must be suitable for
   // freeing with g_strfreev().
   // RETURNS: A %NULL-terminated array of strings, listing the supported
   static char** /*new*/ query() {
      return g_io_module_query();
   }

   // Required API for GIO modules to implement.
   // This function is ran after the module has been loaded into GIO,
   // to initialize the module.
   void load() {
      g_io_module_load(&this);
   }

   // Required API for GIO modules to implement.
   // This function is ran when the module is being unloaded from GIO,
   // to finalize the module.
   void unload() {
      g_io_module_unload(&this);
   }
}

struct IOModuleClass {
}


// Represents a scope for loading IO modules. A scope can be used for blocking
// duplicate modules, or blocking a module you don't want to load.
// 
// The scope can be used with g_io_modules_load_all_in_directory_with_scope()
// or g_io_modules_scan_all_in_directory_with_scope().
struct IOModuleScope /* Version 2.30 */ {

   // Block modules with the given @basename from being loaded when
   // this scope is used with g_io_modules_scan_all_in_directory_with_scope()
   // or g_io_modules_load_all_in_directory_with_scope().
   // <basename>: the basename to block
   void block(char* basename) {
      g_io_module_scope_block(&this, basename);
   }
   // Free a module scope.
   void free() {
      g_io_module_scope_free(&this);
   }

   // Unintrospectable function: new() / g_io_module_scope_new()
   // Create a new scope for loading of IO modules. A scope can be used for
   // blocking duplicate modules, or blocking a module you don't want to load.
   // 
   // Specify the %G_IO_MODULES_SCOPE_BLOCK_DUPLICATES flag to block modules
   // which have the same base name as a module that has already been seen
   // in this scope.
   // RETURNS: the new module scope
   // <flags>: flags for the new scope
   static IOModuleScope* /*new*/ new_(IOModuleScopeFlags flags) {
      return g_io_module_scope_new(flags);
   }
}

// Flags for use with g_io_module_scope_new().
enum IOModuleScopeFlags /* Version 2.30 */ {
   NONE = 0,
   BLOCK_DUPLICATES = 1
}
// Opaque class for defining and scheduling IO jobs.
struct IOSchedulerJob {

   // Used from an I/O job to send a callback to be run in the thread
   // that the job was started from, waiting for the result (and thus
   // blocking the I/O job).
   // RETURNS: The return value of @func
   // <func>: a #GSourceFunc callback that will be called in the original thread
   // <user_data>: data to pass to @func
   // <notify>: a #GDestroyNotify for @user_data, or %NULL
   int send_to_mainloop(GLib2.SourceFunc func, void* user_data, GLib2.DestroyNotify notify) {
      return g_io_scheduler_job_send_to_mainloop(&this, func, user_data, notify);
   }

   // Used from an I/O job to send a callback to be run asynchronously in
   // the thread that the job was started from. The callback will be run
   // when the main loop is available, but at that time the I/O job might
   // have finished. The return value from the callback is ignored.
   // 
   // Note that if you are passing the @user_data from g_io_scheduler_push_job()
   // on to this function you have to ensure that it is not freed before
   // @func is called, either by passing %NULL as @notify to
   // g_io_scheduler_push_job() or by using refcounting for @user_data.
   // <func>: a #GSourceFunc callback that will be called in the original thread
   // <user_data>: data to pass to @func
   // <notify>: a #GDestroyNotify for @user_data, or %NULL
   void send_to_mainloop_async(GLib2.SourceFunc func, void* user_data, GLib2.DestroyNotify notify) {
      g_io_scheduler_job_send_to_mainloop_async(&this, func, user_data, notify);
   }
}


// I/O Job function.
// 
// Note that depending on whether threads are available, the
// #GIOScheduler may run jobs in separate threads or in an idle
// in the mainloop.
// 
// Long-running jobs should periodically check the @cancellable
// to see if they have been cancelled.
// 
// complete the job, %FALSE if the job is complete (or cancelled)
// RETURNS: %TRUE if this function should be called again to
// <job>: a #GIOSchedulerJob.
// <cancellable>: optional #GCancellable object, %NULL to ignore.
// <user_data>: the data to pass to callback function
extern (C) alias int function (IOSchedulerJob* job, Cancellable* cancellable, void* user_data) IOSchedulerJobFunc;


// GIOStream represents an object that has both read and write streams.
// Generally the two streams acts as separate input and output streams,
// but they share some common resources and state. For instance, for
// seekable streams they may use the same position in both streams.
// 
// Examples of #GIOStream objects are #GSocketConnection which represents
// a two-way network connection, and #GFileIOStream which represent a
// file handle opened in read-write mode.
// 
// To do the actual reading and writing you need to get the substreams
// with g_io_stream_get_input_stream() and g_io_stream_get_output_stream().
// 
// The #GIOStream object owns the input and the output streams, not the other
// way around, so keeping the substreams alive will not keep the #GIOStream
// object alive. If the #GIOStream object is freed it will be closed, thus
// closing the substream, so even if the substreams stay alive they will
// always just return a %G_IO_ERROR_CLOSED for all operations.
// 
// To close a stream use g_io_stream_close() which will close the common
// stream object and also the individual substreams. You can also close
// the substreams themselves. In most cases this only marks the
// substream as closed, so further I/O on it fails. However, some streams
// may support "half-closed" states where one direction of the stream
// is actually shut down.
struct IOStream /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private IOStreamPrivate* priv;


   // Finishes an asynchronous io stream splice operation.
   // RETURNS: %TRUE on success, %FALSE otherwise.
   // <result>: a #GAsyncResult.
   static int splice_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_io_stream_splice_finish(result, error);
   }
   // Clears the pending flag on @stream.
   void clear_pending() {
      g_io_stream_clear_pending(&this);
   }

   // Closes the stream, releasing resources related to it. This will also
   // closes the individual input and output streams, if they are not already
   // closed.
   // 
   // Once the stream is closed, all other operations will return
   // %G_IO_ERROR_CLOSED. Closing a stream multiple times will not
   // return an error.
   // 
   // Closing a stream will automatically flush any outstanding buffers
   // in the stream.
   // 
   // Streams will be automatically closed when the last reference
   // is dropped, but you might want to call this function to make sure
   // resources are released as early as possible.
   // 
   // Some streams might keep the backing store of the stream (e.g. a file
   // descriptor) open after the stream is closed. See the documentation for
   // the individual stream for details.
   // 
   // On failure the first error that happened will be reported, but the
   // close operation will finish as much as possible. A stream that failed
   // to close will still return %G_IO_ERROR_CLOSED for all operations.
   // Still, it is important to check and report the error to the user,
   // otherwise there might be a loss of data as all data might not be written.
   // 
   // If @cancellable is not NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // Cancelling a close will still leave the stream closed, but some streams
   // can use a faster close that doesn't block to e.g. check errors.
   // 
   // The default implementation of this method just calls close on the
   // individual input/output streams.
   // RETURNS: %TRUE on success, %FALSE on failure
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   int close(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_io_stream_close(&this, cancellable, error);
   }

   // Requests an asynchronous close of the stream, releasing resources
   // related to it. When the operation is finished @callback will be
   // called. You can then call g_io_stream_close_finish() to get
   // the result of the operation.
   // 
   // For behaviour details see g_io_stream_close().
   // 
   // The asynchronous methods have a default fallback that uses threads
   // to implement asynchronicity, so they are optional for inheriting
   // classes. However, if you override one you must override all.
   // <io_priority>: the io priority of the request
   // <cancellable>: optional cancellable object
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void close_async(int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_io_stream_close_async(&this, io_priority, cancellable, callback, user_data);
   }

   // Closes a stream.
   // RETURNS: %TRUE if stream was successfully closed, %FALSE otherwise.
   // <result>: a #GAsyncResult
   int close_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_io_stream_close_finish(&this, result, error);
   }

   // Gets the input stream for this object. This is used
   // for reading.
   // 
   // Do not free.
   // RETURNS: a #GInputStream, owned by the #GIOStream.
   InputStream* get_input_stream() {
      return g_io_stream_get_input_stream(&this);
   }

   // Gets the output stream for this object. This is used for
   // writing.
   // 
   // Do not free.
   // RETURNS: a #GOutputStream, owned by the #GIOStream.
   OutputStream* get_output_stream() {
      return g_io_stream_get_output_stream(&this);
   }

   // Checks if a stream has pending actions.
   // RETURNS: %TRUE if @stream has pending actions.
   int has_pending() {
      return g_io_stream_has_pending(&this);
   }

   // Checks if a stream is closed.
   // RETURNS: %TRUE if the stream is closed.
   int is_closed() {
      return g_io_stream_is_closed(&this);
   }

   // Sets @stream to have actions pending. If the pending flag is
   // already set or @stream is closed, it will return %FALSE and set
   // @error.
   // RETURNS: %TRUE if pending was previously unset and is now set.
   int set_pending(GLib2.Error** error=null) {
      return g_io_stream_set_pending(&this, error);
   }

   // Asyncronously splice the output stream of @stream1 to the input stream of
   // @stream2, and splice the output stream of @stream2 to the input stream of
   // @stream1.
   // 
   // When the operation is finished @callback will be called.
   // You can then call g_io_stream_splice_finish() to get the
   // result of the operation.
   // <stream2>: a #GIOStream.
   // <flags>: a set of #GIOStreamSpliceFlags.
   // <io_priority>: the io priority of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback.
   // <user_data>: user data passed to @callback.
   void splice_async(IOStream* stream2, IOStreamSpliceFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_io_stream_splice_async(&this, stream2, flags, io_priority, cancellable, callback, user_data);
   }
}

struct IOStreamAdapter {
}

struct IOStreamClass {
   GObject2.ObjectClass parent_class;
   // RETURNS: a #GInputStream, owned by the #GIOStream.
   extern (C) InputStream* function (IOStream* stream) get_input_stream;
   // RETURNS: a #GOutputStream, owned by the #GIOStream.
   extern (C) OutputStream* function (IOStream* stream) get_output_stream;
   extern (C) int function (IOStream* stream, Cancellable* cancellable, GLib2.Error** error=null) close_fn;

   // <io_priority>: the io priority of the request
   // <cancellable>: optional cancellable object
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (IOStream* stream, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) close_async;

   // RETURNS: %TRUE if stream was successfully closed, %FALSE otherwise.
   // <result>: a #GAsyncResult
   extern (C) int function (IOStream* stream, AsyncResult* result, GLib2.Error** error=null) close_finish;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
   extern (C) void function () _g_reserved6;
   extern (C) void function () _g_reserved7;
   extern (C) void function () _g_reserved8;
   extern (C) void function () _g_reserved9;
   extern (C) void function () _g_reserved10;
}

struct IOStreamPrivate {
}

// GIOStreamSpliceFlags determine how streams should be spliced.
enum IOStreamSpliceFlags /* Version 2.28 */ {
   NONE = 0,
   CLOSE_STREAM1 = 1,
   CLOSE_STREAM2 = 2,
   WAIT_FOR_BOTH = 4
}

// #GIcon is a very minimal interface for icons. It provides functions
// for checking the equality of two icons, hashing of icons and
// serializing an icon to and from strings.
// 
// #GIcon does not provide the actual pixmap for the icon as this is out
// of GIO's scope, however implementations of #GIcon may contain the name
// of an icon (see #GThemedIcon), or the path to an icon (see #GLoadableIcon).
// 
// To obtain a hash of a #GIcon, see g_icon_hash().
// 
// To check if two #GIcons are equal, see g_icon_equal().
// 
// For serializing a #GIcon, use g_icon_to_string() and
// g_icon_new_for_string().
// 
// If your application or library provides one or more #GIcon
// implementations you need to ensure that each #GType is registered
// with the type system prior to calling g_icon_new_for_string().
struct Icon {

   // Gets a hash for an icon.
   // 
   // use in a #GHashTable or similar data structure.
   // RETURNS: a #guint containing a hash for the @icon, suitable for
   // <icon>: #gconstpointer to an icon object.
   static uint hash(const(void)* icon) {
      return g_icon_hash(icon);
   }

   // Generate a #GIcon instance from @str. This function can fail if
   // @str is not valid - see g_icon_to_string() for discussion.
   // 
   // If your application or library provides one or more #GIcon
   // implementations you need to ensure that each #GType is registered
   // with the type system prior to calling g_icon_new_for_string().
   // 
   // interface or %NULL if @error is set.
   // RETURNS: An object implementing the #GIcon
   // <str>: A string obtained via g_icon_to_string().
   static Icon* /*new*/ new_for_string(char* str, GLib2.Error** error=null) {
      return g_icon_new_for_string(str, error);
   }

   // Checks if two icons are equal.
   // RETURNS: %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
   // <icon2>: pointer to the second #GIcon.
   int equal(Icon* icon2) {
      return g_icon_equal(&this, icon2);
   }

   // Generates a textual representation of @icon that can be used for
   // serialization such as when passing @icon to a different process or
   // saving it to persistent storage. Use g_icon_new_for_string() to
   // get @icon back from the returned string.
   // 
   // The encoding of the returned string is proprietary to #GIcon except
   // in the following two cases
   // 
   // <itemizedlist>
   // <listitem><para>
   // If @icon is a #GFileIcon, the returned string is a native path
   // (such as <literal>/path/to/my icon.png</literal>) without escaping
   // if the #GFile for @icon is a native file.  If the file is not
   // native, the returned string is the result of g_file_get_uri()
   // (such as <literal>sftp://path/to/my&percnt;20icon.png</literal>).
   // </para></listitem>
   // <listitem><para>
   // If @icon is a #GThemedIcon with exactly one name, the encoding is
   // simply the name (such as <literal>network-server</literal>).
   // </para></listitem>
   // </itemizedlist>
   // 
   // be serialized. Use g_free() to free.
   // RETURNS: An allocated NUL-terminated UTF8 string or %NULL if @icon can't
   char* /*new*/ to_string() {
      return g_icon_to_string(&this);
   }
}


// GIconIface is used to implement GIcon types for various
// different systems. See #GThemedIcon and #GLoadableIcon for
// examples of how to implement this interface.
struct IconIface {
   GObject2.TypeInterface g_iface;
   // RETURNS: a #guint containing a hash for the @icon, suitable for
   extern (C) uint function (Icon* icon) hash;

   // RETURNS: %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
   // <icon2>: pointer to the second #GIcon.
   extern (C) int function (Icon* icon1, Icon* icon2) equal;
   // RETURNS: An allocated NUL-terminated UTF8 string or %NULL if @icon can't
   extern (C) int function (Icon* icon, PtrArray* tokens, int* out_version) to_tokens;
   // Unintrospectable functionp: from_tokens() / ()
   extern (C) Icon* function (char** tokens, int num_tokens, int version_, GLib2.Error** error=null) from_tokens;
}


// #GInetAddress represents an IPv4 or IPv6 internet address. Use
// g_resolver_lookup_by_name() or g_resolver_lookup_by_name_async() to
// look up the #GInetAddress for a hostname. Use
// g_resolver_lookup_by_address() or
// g_resolver_lookup_by_address_async() to look up the hostname for a
// #GInetAddress.
// 
// To actually connect to a remote host, you will need a
// #GInetSocketAddress (which includes a #GInetAddress as well as a
// port number).
struct InetAddress /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private InetAddressPrivate* priv;


   // Creates a #GInetAddress for the "any" address (unassigned/"don't
   // care") for @family.
   // 
   // for @family.
   // RETURNS: a new #GInetAddress corresponding to the "any" address
   // <family>: the address family
   static InetAddress* /*new*/ new_any(SocketFamily family) {
      return g_inet_address_new_any(family);
   }

   // Creates a new #GInetAddress from the given @family and @bytes.
   // @bytes should be 4 bytes for %G_INET_ADDRESS_IPV4 and 16 bytes for
   // %G_INET_ADDRESS_IPV6.
   // RETURNS: a new #GInetAddress corresponding to @family and @bytes.
   // <bytes>: raw address data
   // <family>: the address family of @bytes
   static InetAddress* /*new*/ new_from_bytes(ubyte* bytes, SocketFamily family) {
      return g_inet_address_new_from_bytes(bytes, family);
   }

   // Parses @string as an IP address and creates a new #GInetAddress.
   // 
   // @string could not be parsed.
   // RETURNS: a new #GInetAddress corresponding to @string, or %NULL if
   // <string>: a string representation of an IP address
   static InetAddress* /*new*/ new_from_string(char* string_) {
      return g_inet_address_new_from_string(string_);
   }

   // Creates a #GInetAddress for the loopback address for @family.
   // 
   // for @family.
   // RETURNS: a new #GInetAddress corresponding to the loopback address
   // <family>: the address family
   static InetAddress* /*new*/ new_loopback(SocketFamily family) {
      return g_inet_address_new_loopback(family);
   }

   // Checks if two #GInetAddress instances are equal, e.g. the same address.
   // RETURNS: %TRUE if @address and @other_address are equal, %FALSE otherwise.
   // <other_address>: Another #GInetAddress.
   int equal(InetAddress* other_address) {
      return g_inet_address_equal(&this, other_address);
   }

   // Gets @address's family
   // RETURNS: @address's family
   SocketFamily get_family() {
      return g_inet_address_get_family(&this);
   }

   // Tests whether @address is the "any" address for its family.
   // RETURNS: %TRUE if @address is the "any" address for its family.
   int get_is_any() {
      return g_inet_address_get_is_any(&this);
   }

   // Tests whether @address is a link-local address (that is, if it
   // identifies a host on a local network that is not connected to the
   // Internet).
   // RETURNS: %TRUE if @address is a link-local address.
   int get_is_link_local() {
      return g_inet_address_get_is_link_local(&this);
   }

   // Tests whether @address is the loopback address for its family.
   // RETURNS: %TRUE if @address is the loopback address for its family.
   int get_is_loopback() {
      return g_inet_address_get_is_loopback(&this);
   }

   // Tests whether @address is a global multicast address.
   // RETURNS: %TRUE if @address is a global multicast address.
   int get_is_mc_global() {
      return g_inet_address_get_is_mc_global(&this);
   }

   // Tests whether @address is a link-local multicast address.
   // RETURNS: %TRUE if @address is a link-local multicast address.
   int get_is_mc_link_local() {
      return g_inet_address_get_is_mc_link_local(&this);
   }

   // Tests whether @address is a node-local multicast address.
   // RETURNS: %TRUE if @address is a node-local multicast address.
   int get_is_mc_node_local() {
      return g_inet_address_get_is_mc_node_local(&this);
   }

   // Tests whether @address is an organization-local multicast address.
   // RETURNS: %TRUE if @address is an organization-local multicast address.
   int get_is_mc_org_local() {
      return g_inet_address_get_is_mc_org_local(&this);
   }

   // Tests whether @address is a site-local multicast address.
   // RETURNS: %TRUE if @address is a site-local multicast address.
   int get_is_mc_site_local() {
      return g_inet_address_get_is_mc_site_local(&this);
   }

   // Tests whether @address is a multicast address.
   // RETURNS: %TRUE if @address is a multicast address.
   int get_is_multicast() {
      return g_inet_address_get_is_multicast(&this);
   }

   // Tests whether @address is a site-local address such as 10.0.0.1
   // (that is, the address identifies a host on a local network that can
   // not be reached directly from the Internet, but which may have
   // outgoing Internet connectivity via a NAT or firewall).
   // RETURNS: %TRUE if @address is a site-local address.
   int get_is_site_local() {
      return g_inet_address_get_is_site_local(&this);
   }

   // Gets the size of the native raw binary address for @address. This
   // is the size of the data that you get from g_inet_address_to_bytes().
   // RETURNS: the number of bytes used for the native version of @address.
   size_t get_native_size() {
      return g_inet_address_get_native_size(&this);
   }

   // Unintrospectable method: to_bytes() / g_inet_address_to_bytes()
   // Gets the raw binary address data from @address.
   // 
   // which should not be modified, stored, or freed. The size of this
   // array can be gotten with g_inet_address_get_native_size().
   // RETURNS: a pointer to an internal array of the bytes in @address,
   ubyte* to_bytes() {
      return g_inet_address_to_bytes(&this);
   }

   // Converts @address to string form.
   // 
   // freed after use.
   // RETURNS: a representation of @address as a string, which should be
   char* /*new*/ to_string() {
      return g_inet_address_to_string(&this);
   }
}

struct InetAddressClass {
   GObject2.ObjectClass parent_class;
   // RETURNS: a representation of @address as a string, which should be
   extern (C) char* /*new*/ function (InetAddress* address) to_string;
   // RETURNS: a pointer to an internal array of the bytes in @address,
   extern (C) ubyte* function (InetAddress* address) to_bytes;
}

struct InetAddressPrivate {
}


// An IPv4 or IPv6 socket address; that is, the combination of a
// #GInetAddress and a port number.
struct InetSocketAddress /* : SocketAddress */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance socketaddress;
   SocketAddress parent_instance;
   private InetSocketAddressPrivate* priv;


   // Creates a new #GInetSocketAddress for @address and @port.
   // RETURNS: a new #GInetSocketAddress
   // <address>: a #GInetAddress
   // <port>: a port number
   static InetSocketAddress* /*new*/ new_(InetAddress* address, ushort port) {
      return g_inet_socket_address_new(address, port);
   }

   // Gets @address's #GInetAddress.
   // 
   // g_object_ref()'d if it will be stored
   // RETURNS: the #GInetAddress for @address, which must be
   InetAddress* get_address() {
      return g_inet_socket_address_get_address(&this);
   }

   // Gets @address's port.
   // RETURNS: the port for @address
   ushort get_port() {
      return g_inet_socket_address_get_port(&this);
   }
}

struct InetSocketAddressClass {
   SocketAddressClass parent_class;
}

struct InetSocketAddressPrivate {
}


// #GInitable is implemented by objects that can fail during
// initialization. If an object implements this interface the
// g_initable_init() function must be called as the first thing
// after construction. If g_initable_init() is not called, or if
// it returns an error, all further operations on the object
// should fail, generally with a %G_IO_ERROR_NOT_INITIALIZED error.
// 
// Users of objects implementing this are not intended to use
// the interface method directly, instead it will be used automatically
// in various ways. For C applications you generally just call
// g_initable_new() directly, or indirectly via a foo_thing_new() wrapper.
// This will call g_initable_init() under the cover, returning %NULL and
// setting a #GError on failure (at which point the instance is
// unreferenced).
// 
// For bindings in languages where the native constructor supports
// exceptions the binding could check for objects implemention %GInitable
// during normal construction and automatically initialize them, throwing
// an exception on failure.
struct Initable /* Version 2.22 */ {

   // Unintrospectable function: new() / g_initable_new()
   // Helper function for constructing #GInitiable object. This is
   // similar to g_object_new() but also initializes the object
   // and returns %NULL, setting an error on failure.
   // RETURNS: a newly allocated #GObject, or %NULL on error
   // <object_type>: a #GType supporting #GInitable.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <error>: a #GError location to store the error occurring, or %NULL to ignore.
   // <first_property_name>: the name of the first property, or %NULL if no properties
   alias g_initable_new new_; // Variadic

   // Unintrospectable function: new_valist() / g_initable_new_valist()
   // Helper function for constructing #GInitiable object. This is
   // similar to g_object_new_valist() but also initializes the object
   // and returns %NULL, setting an error on failure.
   // RETURNS: a newly allocated #GObject, or %NULL on error
   // <object_type>: a #GType supporting #GInitable.
   // <first_property_name>: the name of the first property, followed by the value, and other property value pairs, and ended by %NULL.
   // <var_args>: The var args list generated from @first_property_name.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   static GObject2.Object* /*new*/ new_valist(Type object_type, char* first_property_name, va_list var_args, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_initable_new_valist(object_type, first_property_name, var_args, cancellable, error);
   }

   // Helper function for constructing #GInitiable object. This is
   // similar to g_object_newv() but also initializes the object
   // and returns %NULL, setting an error on failure.
   // RETURNS: a newly allocated #GObject, or %NULL on error
   // <object_type>: a #GType supporting #GInitable.
   // <n_parameters>: the number of parameters in @parameters
   // <parameters>: the parameters to use to construct the object
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   static void* /*new*/ newv(Type object_type, uint n_parameters, GObject2.Parameter* parameters, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_initable_newv(object_type, n_parameters, parameters, cancellable, error);
   }

   // Initializes the object implementing the interface. This must be
   // done before any real use of the object after initial construction.
   // 
   // Implementations may also support cancellation. If @cancellable is not %NULL,
   // then initialization can be cancelled by triggering the cancellable object
   // from another thread. If the operation was cancelled, the error
   // %G_IO_ERROR_CANCELLED will be returned. If @cancellable is not %NULL and
   // the object doesn't support cancellable initialization the error
   // %G_IO_ERROR_NOT_SUPPORTED will be returned.
   // 
   // If this function is not called, or returns with an error then all
   // operations on the object should fail, generally returning the
   // error %G_IO_ERROR_NOT_INITIALIZED.
   // 
   // Implementations of this method must be idempotent, i.e. multiple calls
   // to this function with the same argument should return the same results.
   // Only the first call initializes the object, further calls return the result
   // of the first call. This is so that its safe to implement the singleton
   // pattern in the GObject constructor function.
   // 
   // return %FALSE and set @error appropriately if present.
   // RETURNS: %TRUE if successful. If an error has occurred, this function will
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int init(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_initable_init(&this, cancellable, error);
   }
}


// Provides an interface for initializing object such that initialization
// may fail.
struct InitableIface /* Version 2.22 */ {
   GObject2.TypeInterface g_iface;

   // RETURNS: %TRUE if successful. If an error has occurred, this function will
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) int function (Initable* initable, Cancellable* cancellable, GLib2.Error** error=null) init;
}


// GInputStream has functions to read from a stream (g_input_stream_read()),
// to close a stream (g_input_stream_close()) and to skip some content
// (g_input_stream_skip()).
// 
// To copy the content of an input stream to an output stream without
// manually handling the reads and writes, use g_output_stream_splice().
// 
// All of these functions have async variants too.
struct InputStream /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private InputStreamPrivate* priv;

   // Clears the pending flag on @stream.
   void clear_pending() {
      g_input_stream_clear_pending(&this);
   }

   // Closes the stream, releasing resources related to it.
   // 
   // Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
   // Closing a stream multiple times will not return an error.
   // 
   // Streams will be automatically closed when the last reference
   // is dropped, but you might want to call this function to make sure
   // resources are released as early as possible.
   // 
   // Some streams might keep the backing store of the stream (e.g. a file descriptor)
   // open after the stream is closed. See the documentation for the individual
   // stream for details.
   // 
   // On failure the first error that happened will be reported, but the close
   // operation will finish as much as possible. A stream that failed to
   // close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
   // is important to check and report the error to the user.
   // 
   // If @cancellable is not NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // Cancelling a close will still leave the stream closed, but some streams
   // can use a faster close that doesn't block to e.g. check errors.
   // RETURNS: %TRUE on success, %FALSE on failure
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int close(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_input_stream_close(&this, cancellable, error);
   }

   // Requests an asynchronous closes of the stream, releasing resources related to it.
   // When the operation is finished @callback will be called.
   // You can then call g_input_stream_close_finish() to get the result of the
   // operation.
   // 
   // For behaviour details see g_input_stream_close().
   // 
   // The asyncronous methods have a default fallback that uses threads to implement
   // asynchronicity, so they are optional for inheriting classes. However, if you
   // override one you must override all.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional cancellable object
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void close_async(int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_input_stream_close_async(&this, io_priority, cancellable, callback, user_data);
   }

   // Finishes closing a stream asynchronously, started from g_input_stream_close_async().
   // RETURNS: %TRUE if the stream was closed successfully.
   // <result>: a #GAsyncResult.
   int close_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_input_stream_close_finish(&this, result, error);
   }

   // Checks if an input stream has pending actions.
   // RETURNS: %TRUE if @stream has pending actions.
   int has_pending() {
      return g_input_stream_has_pending(&this);
   }

   // Checks if an input stream is closed.
   // RETURNS: %TRUE if the stream is closed.
   int is_closed() {
      return g_input_stream_is_closed(&this);
   }

   // Tries to read @count bytes from the stream into the buffer starting at
   // @buffer. Will block during this read.
   // 
   // If count is zero returns zero and does nothing. A value of @count
   // larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
   // 
   // On success, the number of bytes read into the buffer is returned.
   // It is not an error if this is not the same as the requested size, as it
   // can happen e.g. near the end of a file. Zero is returned on end of file
   // (or if @count is zero),  but never otherwise.
   // 
   // If @cancellable is not NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an
   // operation was partially finished when the operation was cancelled the
   // partial result will be returned, without an error.
   // 
   // On error -1 is returned and @error is set accordingly.
   // RETURNS: Number of bytes read, or -1 on error
   // <buffer>: a buffer to read data into (which should be at least count bytes long).
   // <count>: the number of bytes that will be read from the stream
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   ssize_t read(void* buffer, size_t count, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_input_stream_read(&this, buffer, count, cancellable, error);
   }

   // Tries to read @count bytes from the stream into the buffer starting at
   // @buffer. Will block during this read.
   // 
   // This function is similar to g_input_stream_read(), except it tries to
   // read as many bytes as requested, only stopping on an error or end of stream.
   // 
   // On a successful read of @count bytes, or if we reached the end of the
   // stream,  %TRUE is returned, and @bytes_read is set to the number of bytes
   // read into @buffer.
   // 
   // If there is an error during the operation %FALSE is returned and @error
   // is set to indicate the error status, @bytes_read is updated to contain
   // the number of bytes read into @buffer before the error occurred.
   // RETURNS: %TRUE on success, %FALSE if there was an error
   // <buffer>: a buffer to read data into (which should be at least count bytes long).
   // <count>: the number of bytes that will be read from the stream
   // <bytes_read>: location to store the number of bytes that was read from the stream
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int read_all(void* buffer, size_t count, /*out*/ size_t* bytes_read, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_input_stream_read_all(&this, buffer, count, bytes_read, cancellable, error);
   }

   // Request an asynchronous read of @count bytes from the stream into the buffer
   // starting at @buffer. When the operation is finished @callback will be called.
   // You can then call g_input_stream_read_finish() to get the result of the
   // operation.
   // 
   // During an async request no other sync and async calls are allowed on @stream, and will
   // result in %G_IO_ERROR_PENDING errors.
   // 
   // A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
   // 
   // On success, the number of bytes read into the buffer will be passed to the
   // callback. It is not an error if this is not the same as the requested size, as it
   // can happen e.g. near the end of a file, but generally we try to read
   // as many bytes as requested. Zero is returned on end of file
   // (or if @count is zero),  but never otherwise.
   // 
   // Any outstanding i/o request with higher priority (lower numerical value) will
   // be executed before an outstanding request with lower priority. Default
   // priority is %G_PRIORITY_DEFAULT.
   // 
   // The asyncronous methods have a default fallback that uses threads to implement
   // asynchronicity, so they are optional for inheriting classes. However, if you
   // override one you must override all.
   // <buffer>: a buffer to read data into (which should be at least count bytes long).
   // <count>: the number of bytes that will be read from the stream
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void read_async(void* buffer, size_t count, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_input_stream_read_async(&this, buffer, count, io_priority, cancellable, callback, user_data);
   }

   // Finishes an asynchronous stream read operation.
   // RETURNS: number of bytes read in, or -1 on error.
   // <result>: a #GAsyncResult.
   ssize_t read_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_input_stream_read_finish(&this, result, error);
   }

   // Sets @stream to have actions pending. If the pending flag is
   // already set or @stream is closed, it will return %FALSE and set
   // @error.
   // RETURNS: %TRUE if pending was previously unset and is now set.
   int set_pending(GLib2.Error** error=null) {
      return g_input_stream_set_pending(&this, error);
   }

   // Tries to skip @count bytes from the stream. Will block during the operation.
   // 
   // This is identical to g_input_stream_read(), from a behaviour standpoint,
   // but the bytes that are skipped are not returned to the user. Some
   // streams have an implementation that is more efficient than reading the data.
   // 
   // This function is optional for inherited classes, as the default implementation
   // emulates it using read.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
   // operation was partially finished when the operation was cancelled the
   // partial result will be returned, without an error.
   // RETURNS: Number of bytes skipped, or -1 on error
   // <count>: the number of bytes that will be skipped from the stream
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   ssize_t skip(size_t count, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_input_stream_skip(&this, count, cancellable, error);
   }

   // Request an asynchronous skip of @count bytes from the stream.
   // When the operation is finished @callback will be called.
   // You can then call g_input_stream_skip_finish() to get the result
   // of the operation.
   // 
   // During an async request no other sync and async calls are allowed,
   // and will result in %G_IO_ERROR_PENDING errors.
   // 
   // A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
   // 
   // On success, the number of bytes skipped will be passed to the callback.
   // It is not an error if this is not the same as the requested size, as it
   // can happen e.g. near the end of a file, but generally we try to skip
   // as many bytes as requested. Zero is returned on end of file
   // (or if @count is zero), but never otherwise.
   // 
   // Any outstanding i/o request with higher priority (lower numerical value)
   // will be executed before an outstanding request with lower priority.
   // Default priority is %G_PRIORITY_DEFAULT.
   // 
   // The asynchronous methods have a default fallback that uses threads to
   // implement asynchronicity, so they are optional for inheriting classes.
   // However, if you override one, you must override all.
   // <count>: the number of bytes that will be skipped from the stream
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void skip_async(size_t count, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_input_stream_skip_async(&this, count, io_priority, cancellable, callback, user_data);
   }

   // Finishes a stream skip operation.
   // RETURNS: the size of the bytes skipped, or %-1 on error.
   // <result>: a #GAsyncResult.
   ssize_t skip_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_input_stream_skip_finish(&this, result, error);
   }
}

struct InputStreamClass {
   GObject2.ObjectClass parent_class;
   extern (C) ssize_t function (InputStream* stream, void* buffer, size_t count, Cancellable* cancellable, GLib2.Error** error=null) read_fn;

   // RETURNS: Number of bytes skipped, or -1 on error
   // <count>: the number of bytes that will be skipped from the stream
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) ssize_t function (InputStream* stream, size_t count, Cancellable* cancellable, GLib2.Error** error=null) skip;
   extern (C) int function (InputStream* stream, Cancellable* cancellable, GLib2.Error** error=null) close_fn;

   // <buffer>: a buffer to read data into (which should be at least count bytes long).
   // <count>: the number of bytes that will be read from the stream
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (InputStream* stream, void* buffer, size_t count, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) read_async;

   // RETURNS: number of bytes read in, or -1 on error.
   // <result>: a #GAsyncResult.
   extern (C) ssize_t function (InputStream* stream, AsyncResult* result, GLib2.Error** error=null) read_finish;

   // <count>: the number of bytes that will be skipped from the stream
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (InputStream* stream, size_t count, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) skip_async;

   // RETURNS: the size of the bytes skipped, or %-1 on error.
   // <result>: a #GAsyncResult.
   extern (C) ssize_t function (InputStream* stream, AsyncResult* result, GLib2.Error** error=null) skip_finish;

   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: optional cancellable object
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (InputStream* stream, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) close_async;

   // RETURNS: %TRUE if the stream was closed successfully.
   // <result>: a #GAsyncResult.
   extern (C) int function (InputStream* stream, AsyncResult* result, GLib2.Error** error=null) close_finish;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct InputStreamPrivate {
}


// Structure used for scatter/gather data input.
// You generally pass in an array of #GInputVector<!-- -->s
// and the operation will store the read data starting in the
// first buffer, switching to the next as needed.
struct InputVector /* Version 2.22 */ {
   void* buffer;
   size_t size;
}


// Extends the #GIcon interface and adds the ability to
// load icons from streams.
struct LoadableIcon {

   // Loads a loadable icon. For the asynchronous version of this function,
   // see g_loadable_icon_load_async().
   // RETURNS: a #GInputStream to read the icon from.
   // <size>: an integer.
   // <type>: a location to store the type of the loaded icon, %NULL to ignore.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   InputStream* /*new*/ load(int size, /*out*/ char** type, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_loadable_icon_load(&this, size, type, cancellable, error);
   }

   // Loads an icon asynchronously. To finish this function, see
   // g_loadable_icon_load_finish(). For the synchronous, blocking
   // version of this function, see g_loadable_icon_load().
   // <size>: an integer.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void load_async(int size, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_loadable_icon_load_async(&this, size, cancellable, callback, user_data);
   }

   // Finishes an asynchronous icon load started in g_loadable_icon_load_async().
   // RETURNS: a #GInputStream to read the icon from.
   // <res>: a #GAsyncResult.
   // <type>: a location to store the type of the loaded icon, %NULL to ignore.
   InputStream* /*new*/ load_finish(AsyncResult* res, char** type, GLib2.Error** error=null) {
      return g_loadable_icon_load_finish(&this, res, type, error);
   }
}

// Interface for icons that can be loaded as a stream.
struct LoadableIconIface {
   GObject2.TypeInterface g_iface;

   // RETURNS: a #GInputStream to read the icon from.
   // <size>: an integer.
   // <type>: a location to store the type of the loaded icon, %NULL to ignore.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) InputStream* /*new*/ function (LoadableIcon* icon, int size, /*out*/ char** type, Cancellable* cancellable, GLib2.Error** error=null) load;

   // <size>: an integer.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (LoadableIcon* icon, int size, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) load_async;

   // RETURNS: a #GInputStream to read the icon from.
   // <res>: a #GAsyncResult.
   // <type>: a location to store the type of the loaded icon, %NULL to ignore.
   extern (C) InputStream* /*new*/ function (LoadableIcon* icon, AsyncResult* res, char** type, GLib2.Error** error=null) load_finish;
}


// #GMemoryInputStream is a class for using arbitrary
// memory chunks as input for GIO streaming input operations.
struct MemoryInputStream /* : InputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance inputstream;
   InputStream parent_instance;
   private MemoryInputStreamPrivate* priv;


   // Creates a new empty #GMemoryInputStream.
   // RETURNS: a new #GInputStream
   static MemoryInputStream* /*new*/ new_() {
      return g_memory_input_stream_new();
   }

   // Creates a new #GMemoryInputStream with data in memory of a given size.
   // RETURNS: new #GInputStream read from @data of @len bytes.
   // <data>: input data
   // <len>: length of the data, may be -1 if @data is a nul-terminated string
   // <destroy>: function that is called to free @data, or %NULL
   static MemoryInputStream* /*new*/ new_from_data(ubyte* data, ssize_t len, GLib2.DestroyNotify destroy=null) {
      return g_memory_input_stream_new_from_data(data, len, destroy);
   }

   // Appends @data to data that can be read from the input stream
   // <data>: input data
   // <len>: length of the data, may be -1 if @data is a nul-terminated string
   // <destroy>: function that is called to free @data, or %NULL
   void add_data(ubyte* data, ssize_t len, GLib2.DestroyNotify destroy=null) {
      g_memory_input_stream_add_data(&this, data, len, destroy);
   }
}

struct MemoryInputStreamClass {
   InputStreamClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct MemoryInputStreamPrivate {
}


// #GMemoryOutputStream is a class for using arbitrary
// memory chunks as output for GIO streaming output operations.
struct MemoryOutputStream /* : OutputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance outputstream;
   OutputStream parent_instance;
   private MemoryOutputStreamPrivate* priv;


   // Unintrospectable constructor: new() / g_memory_output_stream_new()
   // Creates a new #GMemoryOutputStream.
   // 
   // If @data is non-%NULL, the stream  will use that for its internal storage.
   // If @realloc_fn is non-%NULL, it will be used for resizing the internal
   // storage when necessary. To construct a fixed-size output stream,
   // pass %NULL as @realloc_fn.
   // 
   // |[
   // /&ast; a stream that can grow &ast;/
   // stream = g_memory_output_stream_new (NULL, 0, realloc, free);
   // 
   // /&ast; another stream that can grow &ast;/
   // stream2 = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
   // 
   // /&ast; a fixed-size stream &ast;/
   // data = malloc (200);
   // stream3 = g_memory_output_stream_new (data, 200, NULL, free);
   // ]|
   // RETURNS: A newly created #GMemoryOutputStream object.
   // <data>: pointer to a chunk of memory to use, or %NULL
   // <size>: the size of @data
   // <realloc_function>: a function with realloc() semantics (like g_realloc()) to be called when @data needs to be grown, or %NULL
   // <destroy_function>: a function to be called on @data when the stream is finalized, or %NULL
   static MemoryOutputStream* /*new*/ new_(void* data, size_t size, ReallocFunc realloc_function, GLib2.DestroyNotify destroy_function) {
      return g_memory_output_stream_new(data, size, realloc_function, destroy_function);
   }

   // Gets any loaded data from the @ostream.
   // 
   // Note that the returned pointer may become invalid on the next
   // write or truncate operation on the stream.
   // RETURNS: pointer to the stream's data
   void* get_data() {
      return g_memory_output_stream_get_data(&this);
   }

   // Returns the number of bytes from the start up
   // to including the last byte written in the stream
   // that has not been truncated away.
   // RETURNS: the number of bytes written to the stream
   size_t get_data_size() {
      return g_memory_output_stream_get_data_size(&this);
   }

   // Gets the size of the currently allocated data area (available from
   // g_memory_output_stream_get_data()). If the stream isn't
   // growable (no realloc was passed to g_memory_output_stream_new()) then
   // this is the maximum size of the stream and further writes
   // will return %G_IO_ERROR_NO_SPACE.
   // 
   // Note that for growable streams the returned size may become invalid on
   // the next write or truncate operation on the stream.
   // 
   // If you want the number of bytes currently written to the stream, use
   // g_memory_output_stream_get_data_size().
   // RETURNS: the number of bytes allocated for the data buffer
   size_t get_size() {
      return g_memory_output_stream_get_size(&this);
   }

   // Gets any loaded data from the @ostream. Ownership of the data
   // is transferred to the caller; when no longer needed it must be
   // freed using the free function set in @ostream's
   // #GMemoryOutputStream:destroy-function property.
   // 
   // @ostream must be closed before calling this function.
   // RETURNS: the stream's data
   void* /*new*/ steal_data() {
      return g_memory_output_stream_steal_data(&this);
   }
}

struct MemoryOutputStreamClass {
   OutputStreamClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct MemoryOutputStreamPrivate {
}


// The #GMount interface represents user-visible mounts. Note, when
// porting from GnomeVFS, #GMount is the moral equivalent of #GnomeVFSVolume.
// 
// #GMount is a "mounted" filesystem that you can access. Mounted is in
// quotes because it's not the same as a unix mount, it might be a gvfs
// mount, but you can still access the files on it if you use GIO. Might or
// might not be related to a volume object.
// 
// Unmounting a #GMount instance is an asynchronous operation. For
// more information about asynchronous operations, see #GAsyncReady
// and #GSimpleAsyncReady. To unmount a #GMount instance, first call
// g_mount_unmount_with_operation() with (at least) the #GMount instance and a
// #GAsyncReadyCallback.  The callback will be fired when the
// operation has resolved (either with success or failure), and a
// #GAsyncReady structure will be passed to the callback.  That
// callback should then call g_mount_unmount_with_operation_finish() with the #GMount
// and the #GAsyncReady data to see if the operation was completed
// successfully.  If an @error is present when g_mount_unmount_with_operation_finish()
// is called, then it will be filled with any error information.
struct Mount {

   // Checks if @mount can be eject.
   // RETURNS: %TRUE if the @mount can be ejected.
   int can_eject() {
      return g_mount_can_eject(&this);
   }

   // Checks if @mount can be mounted.
   // RETURNS: %TRUE if the @mount can be unmounted.
   int can_unmount() {
      return g_mount_can_unmount(&this);
   }

   // Ejects a mount. This is an asynchronous operation, and is
   // finished by calling g_mount_eject_finish() with the @mount
   // and #GAsyncResult data returned in the @callback.
   // <flags>: flags affecting the unmount if required for eject
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   void eject(MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_mount_eject(&this, flags, cancellable, callback, user_data);
   }

   // Finishes ejecting a mount. If any errors occurred during the operation,
   // @error will be set to contain the errors and %FALSE will be returned.
   // RETURNS: %TRUE if the mount was successfully ejected. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   int eject_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_mount_eject_finish(&this, result, error);
   }

   // Ejects a mount. This is an asynchronous operation, and is
   // finished by calling g_mount_eject_with_operation_finish() with the @mount
   // and #GAsyncResult data returned in the @callback.
   // <flags>: flags affecting the unmount if required for eject
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   void eject_with_operation(MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_mount_eject_with_operation(&this, flags, mount_operation, cancellable, callback, user_data);
   }

   // Finishes ejecting a mount. If any errors occurred during the operation,
   // @error will be set to contain the errors and %FALSE will be returned.
   // RETURNS: %TRUE if the mount was successfully ejected. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   int eject_with_operation_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_mount_eject_with_operation_finish(&this, result, error);
   }

   // Gets the default location of @mount. The default location of the given
   // @mount is a path that reflects the main entry point for the user (e.g.
   // the home directory, or the root of the volume).
   // 
   // The returned object should be unreffed with
   // g_object_unref() when no longer needed.
   // RETURNS: a #GFile.
   File* /*new*/ get_default_location() {
      return g_mount_get_default_location(&this);
   }

   // Gets the drive for the @mount.
   // 
   // This is a convenience method for getting the #GVolume and then
   // using that object to get the #GDrive.
   // 
   // The returned object should be unreffed with
   // g_object_unref() when no longer needed.
   // RETURNS: a #GDrive or %NULL if @mount is not associated with a volume or a drive.
   Drive* /*new*/ get_drive() {
      return g_mount_get_drive(&this);
   }

   // Gets the icon for @mount.
   // 
   // The returned object should be unreffed with
   // g_object_unref() when no longer needed.
   // RETURNS: a #GIcon.
   Icon* /*new*/ get_icon() {
      return g_mount_get_icon(&this);
   }

   // Gets the name of @mount.
   // 
   // The returned string should be freed with g_free()
   // when no longer needed.
   // RETURNS: the name for the given @mount.
   char* /*new*/ get_name() {
      return g_mount_get_name(&this);
   }

   // Gets the root directory on @mount.
   // 
   // The returned object should be unreffed with
   // g_object_unref() when no longer needed.
   // RETURNS: a #GFile.
   File* /*new*/ get_root() {
      return g_mount_get_root(&this);
   }

   // Gets the UUID for the @mount. The reference is typically based on
   // the file system UUID for the mount in question and should be
   // considered an opaque string. Returns %NULL if there is no UUID
   // available.
   // 
   // The returned string should be freed with g_free()
   // when no longer needed.
   // RETURNS: the UUID for @mount or %NULL if no UUID can be computed.
   char* /*new*/ get_uuid() {
      return g_mount_get_uuid(&this);
   }

   // Gets the volume for the @mount.
   // 
   // The returned object should be unreffed with
   // g_object_unref() when no longer needed.
   // RETURNS: a #GVolume or %NULL if @mount is not associated with a volume.
   Volume* /*new*/ get_volume() {
      return g_mount_get_volume(&this);
   }

   // Tries to guess the type of content stored on @mount. Returns one or
   // more textual identifiers of well-known content types (typically
   // prefixed with "x-content/"), e.g. x-content/image-dcf for camera
   // memory cards. See the <ulink url="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</ulink>
   // specification for more on x-content types.
   // 
   // This is an asynchronous operation (see
   // g_mount_guess_content_type_sync() for the synchronous version), and
   // is finished by calling g_mount_guess_content_type_finish() with the
   // @mount and #GAsyncResult data returned in the @callback.
   // <force_rescan>: Whether to force a rescan of the content. Otherwise a cached result will be used if available
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   // <callback>: a #GAsyncReadyCallback
   // <user_data>: user data passed to @callback
   void guess_content_type(int force_rescan, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_mount_guess_content_type(&this, force_rescan, cancellable, callback, user_data);
   }

   // Finishes guessing content types of @mount. If any errors occurred
   // during the operation, @error will be set to contain the errors and
   // %FALSE will be returned. In particular, you may get an
   // %G_IO_ERROR_NOT_SUPPORTED if the mount does not support content
   // guessing.
   // 
   // Caller should free this array with g_strfreev() when done with it.
   // RETURNS: a %NULL-terminated array of content types or %NULL on error.
   // <result>: a #GAsyncResult
   char** /*new*/ guess_content_type_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_mount_guess_content_type_finish(&this, result, error);
   }

   // Tries to guess the type of content stored on @mount. Returns one or
   // more textual identifiers of well-known content types (typically
   // prefixed with "x-content/"), e.g. x-content/image-dcf for camera
   // memory cards. See the <ulink url="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</ulink>
   // specification for more on x-content types.
   // 
   // This is an synchronous operation and as such may block doing IO;
   // see g_mount_guess_content_type() for the asynchronous version.
   // 
   // Caller should free this array with g_strfreev() when done with it.
   // RETURNS: a %NULL-terminated array of content types or %NULL on error.
   // <force_rescan>: Whether to force a rescan of the content. Otherwise a cached result will be used if available
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   char** /*new*/ guess_content_type_sync(int force_rescan, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_mount_guess_content_type_sync(&this, force_rescan, cancellable, error);
   }

   // Determines if @mount is shadowed. Applications or libraries should
   // avoid displaying @mount in the user interface if it is shadowed.
   // 
   // A mount is said to be shadowed if there exists one or more user
   // visible objects (currently #GMount objects) with a root that is
   // inside the root of @mount.
   // 
   // One application of shadow mounts is when exposing a single file
   // system that is used to address several logical volumes. In this
   // situation, a #GVolumeMonitor implementation would create two
   // #GVolume objects (for example, one for the camera functionality of
   // the device and one for a SD card reader on the device) with
   // activation URIs <literal>gphoto2://[usb:001,002]/store1/</literal>
   // and <literal>gphoto2://[usb:001,002]/store2/</literal>. When the
   // underlying mount (with root
   // <literal>gphoto2://[usb:001,002]/</literal>) is mounted, said
   // #GVolumeMonitor implementation would create two #GMount objects
   // (each with their root matching the corresponding volume activation
   // root) that would shadow the original mount.
   // 
   // The proxy monitor in GVfs 2.26 and later, automatically creates and
   // manage shadow mounts (and shadows the underlying mount) if the
   // activation root on a #GVolume is set.
   // RETURNS: %TRUE if @mount is shadowed.
   int is_shadowed() {
      return g_mount_is_shadowed(&this);
   }

   // Remounts a mount. This is an asynchronous operation, and is
   // finished by calling g_mount_remount_finish() with the @mount
   // and #GAsyncResults data returned in the @callback.
   // 
   // Remounting is useful when some setting affecting the operation
   // of the volume has been changed, as these may need a remount to
   // take affect. While this is semantically equivalent with unmounting
   // and then remounting not all backends might need to actually be
   // unmounted.
   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   void remount(MountMountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_mount_remount(&this, flags, mount_operation, cancellable, callback, user_data);
   }

   // Finishes remounting a mount. If any errors occurred during the operation,
   // @error will be set to contain the errors and %FALSE will be returned.
   // RETURNS: %TRUE if the mount was successfully remounted. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   int remount_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_mount_remount_finish(&this, result, error);
   }

   // Increments the shadow count on @mount. Usually used by
   // #GVolumeMonitor implementations when creating a shadow mount for
   // @mount, see g_mount_is_shadowed() for more information. The caller
   // will need to emit the #GMount::changed signal on @mount manually.
   void shadow() {
      g_mount_shadow(&this);
   }

   // Unmounts a mount. This is an asynchronous operation, and is
   // finished by calling g_mount_unmount_finish() with the @mount
   // and #GAsyncResult data returned in the @callback.
   // <flags>: flags affecting the operation
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   void unmount(MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_mount_unmount(&this, flags, cancellable, callback, user_data);
   }

   // Finishes unmounting a mount. If any errors occurred during the operation,
   // @error will be set to contain the errors and %FALSE will be returned.
   // RETURNS: %TRUE if the mount was successfully unmounted. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   int unmount_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_mount_unmount_finish(&this, result, error);
   }

   // Unmounts a mount. This is an asynchronous operation, and is
   // finished by calling g_mount_unmount_with_operation_finish() with the @mount
   // and #GAsyncResult data returned in the @callback.
   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   void unmount_with_operation(MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_mount_unmount_with_operation(&this, flags, mount_operation, cancellable, callback, user_data);
   }

   // Finishes unmounting a mount. If any errors occurred during the operation,
   // @error will be set to contain the errors and %FALSE will be returned.
   // RETURNS: %TRUE if the mount was successfully unmounted. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   int unmount_with_operation_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_mount_unmount_with_operation_finish(&this, result, error);
   }

   // Decrements the shadow count on @mount. Usually used by
   // #GVolumeMonitor implementations when destroying a shadow mount for
   // @mount, see g_mount_is_shadowed() for more information. The caller
   // will need to emit the #GMount::changed signal on @mount manually.
   void unshadow() {
      g_mount_unshadow(&this);
   }
   // Emitted when the mount has been changed.
   extern (C) alias static void function (Mount* this_, void* user_data=null) signal_changed;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"changed", CB:signal_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when the #GMount is about to be
   // unmounted.
   extern (C) alias static void function (Mount* this_, void* user_data=null) signal_pre_unmount;
   ulong signal_connect(string name:"pre-unmount", CB:signal_pre_unmount)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"pre-unmount",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when the #GMount have been
   // unmounted. If the recipient is holding references to the
   // object they should release them so the object can be
   // finalized.
   extern (C) alias static void function (Mount* this_, void* user_data=null) signal_unmounted;
   ulong signal_connect(string name:"unmounted", CB:signal_unmounted)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"unmounted",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

// Interface for implementing operations for mounts.
struct MountIface {
   GObject2.TypeInterface g_iface;
   extern (C) void function (Mount* mount) changed;
   extern (C) void function (Mount* mount) unmounted;
   // RETURNS: a #GFile.
   extern (C) File* /*new*/ function (Mount* mount) get_root;
   // RETURNS: the name for the given @mount.
   extern (C) char* /*new*/ function (Mount* mount) get_name;
   // RETURNS: a #GIcon.
   extern (C) Icon* /*new*/ function (Mount* mount) get_icon;
   // RETURNS: the UUID for @mount or %NULL if no UUID can be computed.
   extern (C) char* /*new*/ function (Mount* mount) get_uuid;
   // RETURNS: a #GVolume or %NULL if @mount is not associated with a volume.
   extern (C) Volume* /*new*/ function (Mount* mount) get_volume;
   // RETURNS: a #GDrive or %NULL if @mount is not associated with a volume or a drive.
   extern (C) Drive* /*new*/ function (Mount* mount) get_drive;
   // RETURNS: %TRUE if the @mount can be unmounted.
   extern (C) int function (Mount* mount) can_unmount;
   // RETURNS: %TRUE if the @mount can be ejected.
   extern (C) int function (Mount* mount) can_eject;

   // <flags>: flags affecting the operation
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   extern (C) void function (Mount* mount, MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) unmount;

   // RETURNS: %TRUE if the mount was successfully unmounted. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   extern (C) int function (Mount* mount, AsyncResult* result, GLib2.Error** error=null) unmount_finish;

   // <flags>: flags affecting the unmount if required for eject
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   extern (C) void function (Mount* mount, MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) eject;

   // RETURNS: %TRUE if the mount was successfully ejected. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   extern (C) int function (Mount* mount, AsyncResult* result, GLib2.Error** error=null) eject_finish;

   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   extern (C) void function (Mount* mount, MountMountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) remount;

   // RETURNS: %TRUE if the mount was successfully remounted. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   extern (C) int function (Mount* mount, AsyncResult* result, GLib2.Error** error=null) remount_finish;

   // <force_rescan>: Whether to force a rescan of the content. Otherwise a cached result will be used if available
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   // <callback>: a #GAsyncReadyCallback
   // <user_data>: user data passed to @callback
   extern (C) void function (Mount* mount, int force_rescan, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) guess_content_type;

   // RETURNS: a %NULL-terminated array of content types or %NULL on error.
   // <result>: a #GAsyncResult
   extern (C) char** /*new*/ function (Mount* mount, AsyncResult* result, GLib2.Error** error=null) guess_content_type_finish;

   // RETURNS: a %NULL-terminated array of content types or %NULL on error.
   // <force_rescan>: Whether to force a rescan of the content. Otherwise a cached result will be used if available
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   extern (C) char** /*new*/ function (Mount* mount, int force_rescan, Cancellable* cancellable, GLib2.Error** error=null) guess_content_type_sync;
   extern (C) void function (Mount* mount) pre_unmount;

   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   extern (C) void function (Mount* mount, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) unmount_with_operation;

   // RETURNS: %TRUE if the mount was successfully unmounted. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   extern (C) int function (Mount* mount, AsyncResult* result, GLib2.Error** error=null) unmount_with_operation_finish;

   // <flags>: flags affecting the unmount if required for eject
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   extern (C) void function (Mount* mount, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) eject_with_operation;

   // RETURNS: %TRUE if the mount was successfully ejected. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   extern (C) int function (Mount* mount, AsyncResult* result, GLib2.Error** error=null) eject_with_operation_finish;
   // RETURNS: a #GFile.
   extern (C) File* /*new*/ function (Mount* mount) get_default_location;
}

// Flags used when mounting a mount.
enum MountMountFlags {
   NONE = 0
}

// #GMountOperation provides a mechanism for interacting with the user.
// It can be used for authenticating mountable operations, such as loop
// mounting files, hard drive partitions or server locations. It can
// also be used to ask the user questions or show a list of applications
// preventing unmount or eject operations from completing.
// 
// Note that #GMountOperation is used for more than just #GMount
// objects – for example it is also used in g_drive_start() and
// g_drive_stop().
// 
// Users should instantiate a subclass of this that implements all the
// various callbacks to show the required dialogs, such as
// #GtkMountOperation. If no user interaction is desired (for example
// when automounting filesystems at login time), usually %NULL can be
// passed, see each method taking a #GMountOperation for details.
struct MountOperation /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   MountOperationPrivate* priv;


   // Creates a new mount operation.
   // RETURNS: a #GMountOperation.
   static MountOperation* /*new*/ new_() {
      return g_mount_operation_new();
   }

   // Check to see whether the mount operation is being used
   // for an anonymous user.
   // RETURNS: %TRUE if mount operation is anonymous.
   int get_anonymous() {
      return g_mount_operation_get_anonymous(&this);
   }

   // Gets a choice from the mount operation.
   // 
   // the choice's list, or %0.
   // RETURNS: an integer containing an index of the user's choice from
   int get_choice() {
      return g_mount_operation_get_choice(&this);
   }

   // Gets the domain of the mount operation.
   // RETURNS: a string set to the domain.
   char* get_domain() {
      return g_mount_operation_get_domain(&this);
   }

   // Gets a password from the mount operation.
   // RETURNS: a string containing the password within @op.
   char* get_password() {
      return g_mount_operation_get_password(&this);
   }

   // Gets the state of saving passwords for the mount operation.
   // RETURNS: a #GPasswordSave flag.
   PasswordSave get_password_save() {
      return g_mount_operation_get_password_save(&this);
   }

   // Get the user name from the mount operation.
   // RETURNS: a string containing the user name.
   char* get_username() {
      return g_mount_operation_get_username(&this);
   }

   // Emits the #GMountOperation::reply signal.
   // <result>: a #GMountOperationResult
   void reply(MountOperationResult result) {
      g_mount_operation_reply(&this, result);
   }

   // Sets the mount operation to use an anonymous user if @anonymous is %TRUE.
   // <anonymous>: boolean value.
   void set_anonymous(int anonymous) {
      g_mount_operation_set_anonymous(&this, anonymous);
   }

   // Sets a default choice for the mount operation.
   // <choice>: an integer.
   void set_choice(int choice) {
      g_mount_operation_set_choice(&this, choice);
   }

   // Sets the mount operation's domain.
   // <domain>: the domain to set.
   void set_domain(char* domain) {
      g_mount_operation_set_domain(&this, domain);
   }

   // Sets the mount operation's password to @password.
   // <password>: password to set.
   void set_password(char* password) {
      g_mount_operation_set_password(&this, password);
   }

   // Sets the state of saving passwords for the mount operation.
   // <save>: a set of #GPasswordSave flags.
   void set_password_save(PasswordSave save) {
      g_mount_operation_set_password_save(&this, save);
   }

   // Sets the user name within @op to @username.
   // <username>: input username.
   void set_username(char* username) {
      g_mount_operation_set_username(&this, username);
   }

   // Emitted by the backend when e.g. a device becomes unavailable
   // while a mount operation is in progress.
   // 
   // Implementations of GMountOperation should handle this signal
   // by dismissing open password dialogs.
   extern (C) alias static void function (MountOperation* this_, void* user_data=null) signal_aborted;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"aborted", CB:signal_aborted)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"aborted",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when a mount operation asks the user for a password.
   // 
   // If the message contains a line break, the first line should be
   // presented as a heading. For example, it may be used as the
   // primary text in a #GtkMessageDialog.
   // <message>: string containing a message to display to the user.
   // <default_user>: string containing the default user name.
   // <default_domain>: string containing the default domain.
   // <flags>: a set of #GAskPasswordFlags.
   extern (C) alias static void function (MountOperation* this_, char* message, char* default_user, char* default_domain, AskPasswordFlags* flags, void* user_data=null) signal_ask_password;
   ulong signal_connect(string name:"ask-password", CB:signal_ask_password)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"ask-password",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when asking the user a question and gives a list of
   // choices for the user to choose from.
   // 
   // If the message contains a line break, the first line should be
   // presented as a heading. For example, it may be used as the
   // primary text in a #GtkMessageDialog.
   // <message>: string containing a message to display to the user.
   // <choices>: an array of strings for each possible choice.
   extern (C) alias static void function (MountOperation* this_, char* message, char* choices, void* user_data=null) signal_ask_question;
   ulong signal_connect(string name:"ask-question", CB:signal_ask_question)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"ask-question",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when the user has replied to the mount operation.
   // <result>: a #GMountOperationResult indicating how the request was handled
   extern (C) alias static void function (MountOperation* this_, MountOperationResult* result, void* user_data=null) signal_reply;
   ulong signal_connect(string name:"reply", CB:signal_reply)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"reply",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when one or more processes are blocking an operation
   // e.g. unmounting/ejecting a #GMount or stopping a #GDrive.
   // 
   // Note that this signal may be emitted several times to update the
   // list of blocking processes as processes close files. The
   // application should only respond with g_mount_operation_reply() to
   // the latest signal (setting #GMountOperation:choice to the choice
   // the user made).
   // 
   // If the message contains a line break, the first line should be
   // presented as a heading. For example, it may be used as the
   // primary text in a #GtkMessageDialog.
   // <message>: string containing a message to display to the user.
   // <processes>: an array of #GPid for processes blocking the operation.
   // <choices>: an array of strings for each possible choice.
   extern (C) alias static void function (MountOperation* this_, char* message, void* processes, char* choices, void* user_data=null) signal_show_processes;
   ulong signal_connect(string name:"show-processes", CB:signal_show_processes)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"show-processes",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct MountOperationClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (MountOperation* op, char* message, char* default_user, char* default_domain, AskPasswordFlags flags) ask_password;
   extern (C) void function (MountOperation* op, char* message, char* choices) ask_question;
   // <result>: a #GMountOperationResult
   extern (C) void function (MountOperation* op, MountOperationResult result) reply;
   extern (C) void function (MountOperation* op) aborted;
   extern (C) void function (MountOperation* op, char* message, Array* processes, char* choices) show_processes;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
   extern (C) void function () _g_reserved6;
   extern (C) void function () _g_reserved7;
   extern (C) void function () _g_reserved8;
   extern (C) void function () _g_reserved9;
   extern (C) void function () _g_reserved10;
}

struct MountOperationPrivate {
}


// #GMountOperationResult is returned as a result when a request for
// information is send by the mounting operation.
enum MountOperationResult {
   HANDLED = 0,
   ABORTED = 1,
   UNHANDLED = 2
}
// Flags used when an unmounting a mount.
enum MountUnmountFlags {
   NONE = 0,
   FORCE = 1
}
enum NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME = "gio-native-volume-monitor";
struct NativeVolumeMonitor /* : VolumeMonitor */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance volumemonitor;
   VolumeMonitor parent_instance;
}

struct NativeVolumeMonitorClass {
   VolumeMonitorClass parent_class;
   // Unintrospectable functionp: get_mount_for_mount_path() / ()
   extern (C) Mount* function (char* mount_path, Cancellable* cancellable) get_mount_for_mount_path;
}


// #GNetworkAddress provides an easy way to resolve a hostname and
// then attempt to connect to that host, handling the possibility of
// multiple IP addresses and multiple address families.
// 
// See #GSocketConnectable for and example of using the connectable
// interface.
struct NetworkAddress /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private NetworkAddressPrivate* priv;


   // Creates a new #GSocketConnectable for connecting to the given
   // @hostname and @port.
   // RETURNS: the new #GNetworkAddress
   // <hostname>: the hostname
   // <port>: the port
   static SocketConnectable* /*new*/ new_(char* hostname, ushort port) {
      return g_network_address_new(hostname, port);
   }

   // Creates a new #GSocketConnectable for connecting to the given
   // @hostname and @port. May fail and return %NULL in case
   // parsing @host_and_port fails.
   // 
   // @host_and_port may be in any of a number of recognised formats; an IPv6
   // address, an IPv4 address, or a domain name (in which case a DNS
   // lookup is performed). Quoting with [] is supported for all address
   // types. A port override may be specified in the usual way with a
   // colon. Ports may be given as decimal numbers or symbolic names (in
   // which case an /etc/services lookup is performed).
   // 
   // If no port is specified in @host_and_port then @default_port will be
   // used as the port number to connect to.
   // 
   // In general, @host_and_port is expected to be provided by the user
   // (allowing them to give the hostname, and a port overide if necessary)
   // and @default_port is expected to be provided by the application.
   // RETURNS: the new #GNetworkAddress, or %NULL on error
   // <host_and_port>: the hostname and optionally a port
   // <default_port>: the default port if not in @host_and_port
   static SocketConnectable* /*new*/ parse(char* host_and_port, ushort default_port, GLib2.Error** error=null) {
      return g_network_address_parse(host_and_port, default_port, error);
   }

   // Creates a new #GSocketConnectable for connecting to the given
   // @uri. May fail and return %NULL in case parsing @uri fails.
   // 
   // Using this rather than g_network_address_new() or
   // g_network_address_parse_host() allows #GSocketClient to determine
   // when to use application-specific proxy protocols.
   // RETURNS: the new #GNetworkAddress, or %NULL on error
   // <uri>: the hostname and optionally a port
   // <default_port>: The default port if none is found in the URI
   static SocketConnectable* /*new*/ parse_uri(char* uri, ushort default_port, GLib2.Error** error=null) {
      return g_network_address_parse_uri(uri, default_port, error);
   }

   // Gets @addr's hostname. This might be either UTF-8 or ASCII-encoded,
   // depending on what @addr was created with.
   // RETURNS: @addr's hostname
   char* get_hostname() {
      return g_network_address_get_hostname(&this);
   }

   // Gets @addr's port number
   // RETURNS: @addr's port (which may be 0)
   ushort get_port() {
      return g_network_address_get_port(&this);
   }

   // Gets @addr's scheme
   // RETURNS: @addr's scheme (%NULL if not built from URI)
   char* get_scheme() {
      return g_network_address_get_scheme(&this);
   }
}

struct NetworkAddressClass {
   GObject2.ObjectClass parent_class;
}

struct NetworkAddressPrivate {
}


// Like #GNetworkAddress does with hostnames, #GNetworkService
// provides an easy way to resolve a SRV record, and then attempt to
// connect to one of the hosts that implements that service, handling
// service priority/weighting, multiple IP addresses, and multiple
// address families.
// 
// See #GSrvTarget for more information about SRV records, and see
// #GSocketConnectable for and example of using the connectable
// interface.
struct NetworkService /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private NetworkServicePrivate* priv;


   // Creates a new #GNetworkService representing the given @service,
   // @protocol, and @domain. This will initially be unresolved; use the
   // #GSocketConnectable interface to resolve it.
   // RETURNS: a new #GNetworkService
   // <service>: the service type to look up (eg, "ldap")
   // <protocol>: the networking protocol to use for @service (eg, "tcp")
   // <domain>: the DNS domain to look up the service in
   static SocketConnectable* /*new*/ new_(char* service, char* protocol, char* domain) {
      return g_network_service_new(service, protocol, domain);
   }

   // Gets the domain that @srv serves. This might be either UTF-8 or
   // ASCII-encoded, depending on what @srv was created with.
   // RETURNS: @srv's domain name
   char* get_domain() {
      return g_network_service_get_domain(&this);
   }

   // Gets @srv's protocol name (eg, "tcp").
   // RETURNS: @srv's protocol name
   char* get_protocol() {
      return g_network_service_get_protocol(&this);
   }

   // Get's the URI scheme used to resolve proxies. By default, the service name
   // is used as scheme.
   // RETURNS: @srv's scheme name
   char* get_scheme() {
      return g_network_service_get_scheme(&this);
   }

   // Gets @srv's service name (eg, "ldap").
   // RETURNS: @srv's service name
   char* get_service() {
      return g_network_service_get_service(&this);
   }

   // Set's the URI scheme used to resolve proxies. By default, the service name
   // is used as scheme.
   // <scheme>: a URI scheme
   void set_scheme(char* scheme) {
      g_network_service_set_scheme(&this, scheme);
   }
}

struct NetworkServiceClass {
   GObject2.ObjectClass parent_class;
}

struct NetworkServicePrivate {
}


// GOutputStream has functions to write to a stream (g_output_stream_write()),
// to close a stream (g_output_stream_close()) and to flush pending writes
// (g_output_stream_flush()).
// 
// To copy the content of an input stream to an output stream without
// manually handling the reads and writes, use g_output_stream_splice().
// 
// All of these functions have async variants too.
struct OutputStream /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private OutputStreamPrivate* priv;

   // Clears the pending flag on @stream.
   void clear_pending() {
      g_output_stream_clear_pending(&this);
   }

   // Closes the stream, releasing resources related to it.
   // 
   // Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
   // Closing a stream multiple times will not return an error.
   // 
   // Closing a stream will automatically flush any outstanding buffers in the
   // stream.
   // 
   // Streams will be automatically closed when the last reference
   // is dropped, but you might want to call this function to make sure
   // resources are released as early as possible.
   // 
   // Some streams might keep the backing store of the stream (e.g. a file descriptor)
   // open after the stream is closed. See the documentation for the individual
   // stream for details.
   // 
   // On failure the first error that happened will be reported, but the close
   // operation will finish as much as possible. A stream that failed to
   // close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
   // is important to check and report the error to the user, otherwise
   // there might be a loss of data as all data might not be written.
   // 
   // If @cancellable is not NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // Cancelling a close will still leave the stream closed, but there some streams
   // can use a faster close that doesn't block to e.g. check errors. On
   // cancellation (as with any error) there is no guarantee that all written
   // data will reach the target.
   // RETURNS: %TRUE on success, %FALSE on failure
   // <cancellable>: optional cancellable object
   int close(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_output_stream_close(&this, cancellable, error);
   }

   // Requests an asynchronous close of the stream, releasing resources
   // related to it. When the operation is finished @callback will be
   // called. You can then call g_output_stream_close_finish() to get
   // the result of the operation.
   // 
   // For behaviour details see g_output_stream_close().
   // 
   // The asyncronous methods have a default fallback that uses threads
   // to implement asynchronicity, so they are optional for inheriting
   // classes. However, if you override one you must override all.
   // <io_priority>: the io priority of the request.
   // <cancellable>: optional cancellable object
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void close_async(int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_output_stream_close_async(&this, io_priority, cancellable, callback, user_data);
   }

   // Closes an output stream.
   // RETURNS: %TRUE if stream was successfully closed, %FALSE otherwise.
   // <result>: a #GAsyncResult.
   int close_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_output_stream_close_finish(&this, result, error);
   }

   // Flushed any outstanding buffers in the stream. Will block during
   // the operation. Closing the stream will implicitly cause a flush.
   // 
   // This function is optional for inherited classes.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // RETURNS: %TRUE on success, %FALSE on error
   // <cancellable>: optional cancellable object
   int flush(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_output_stream_flush(&this, cancellable, error);
   }

   // Flushes a stream asynchronously.
   // For behaviour details see g_output_stream_flush().
   // 
   // When the operation is finished @callback will be
   // called. You can then call g_output_stream_flush_finish() to get the
   // result of the operation.
   // <io_priority>: the io priority of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void flush_async(int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_output_stream_flush_async(&this, io_priority, cancellable, callback, user_data);
   }

   // Finishes flushing an output stream.
   // RETURNS: %TRUE if flush operation succeeded, %FALSE otherwise.
   // <result>: a GAsyncResult.
   int flush_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_output_stream_flush_finish(&this, result, error);
   }

   // Checks if an ouput stream has pending actions.
   // RETURNS: %TRUE if @stream has pending actions.
   int has_pending() {
      return g_output_stream_has_pending(&this);
   }

   // Checks if an output stream has already been closed.
   // RETURNS: %TRUE if @stream is closed. %FALSE otherwise.
   int is_closed() {
      return g_output_stream_is_closed(&this);
   }

   // Checks if an output stream is being closed. This can be
   // used inside e.g. a flush implementation to see if the
   // flush (or other i/o operation) is called from within
   // the closing operation.
   // RETURNS: %TRUE if @stream is being closed. %FALSE otherwise.
   int is_closing() {
      return g_output_stream_is_closing(&this);
   }

   // Sets @stream to have actions pending. If the pending flag is
   // already set or @stream is closed, it will return %FALSE and set
   // @error.
   // RETURNS: %TRUE if pending was previously unset and is now set.
   int set_pending(GLib2.Error** error=null) {
      return g_output_stream_set_pending(&this, error);
   }

   // Splices an input stream into an output stream.
   // 
   // -1 if an error occurred. Note that if the number of bytes
   // spliced is greater than %G_MAXSSIZE, then that will be
   // returned, and there is no way to determine the actual number
   // of bytes spliced.
   // RETURNS: a #gssize containing the size of the data spliced, or
   // <source>: a #GInputStream.
   // <flags>: a set of #GOutputStreamSpliceFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   ssize_t splice(InputStream* source, OutputStreamSpliceFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_output_stream_splice(&this, source, flags, cancellable, error);
   }

   // Splices a stream asynchronously.
   // When the operation is finished @callback will be called.
   // You can then call g_output_stream_splice_finish() to get the
   // result of the operation.
   // 
   // For the synchronous, blocking version of this function, see
   // g_output_stream_splice().
   // <source>: a #GInputStream.
   // <flags>: a set of #GOutputStreamSpliceFlags.
   // <io_priority>: the io priority of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback.
   // <user_data>: user data passed to @callback.
   void splice_async(InputStream* source, OutputStreamSpliceFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_output_stream_splice_async(&this, source, flags, io_priority, cancellable, callback, user_data);
   }

   // Finishes an asynchronous stream splice operation.
   // 
   // number of bytes spliced is greater than %G_MAXSSIZE, then that
   // will be returned, and there is no way to determine the actual
   // number of bytes spliced.
   // RETURNS: a #gssize of the number of bytes spliced. Note that if the
   // <result>: a #GAsyncResult.
   ssize_t splice_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_output_stream_splice_finish(&this, result, error);
   }

   // Tries to write @count bytes from @buffer into the stream. Will block
   // during the operation.
   // 
   // If count is 0, returns 0 and does nothing. A value of @count
   // larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
   // 
   // On success, the number of bytes written to the stream is returned.
   // It is not an error if this is not the same as the requested size, as it
   // can happen e.g. on a partial I/O error, or if there is not enough
   // storage in the stream. All writes block until at least one byte
   // is written or an error occurs; 0 is never returned (unless
   // @count is 0).
   // 
   // If @cancellable is not NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
   // operation was partially finished when the operation was cancelled the
   // partial result will be returned, without an error.
   // 
   // On error -1 is returned and @error is set accordingly.
   // RETURNS: Number of bytes written, or -1 on error
   // <buffer>: the buffer containing the data to write.
   // <count>: the number of bytes to write
   // <cancellable>: optional cancellable object
   ssize_t write(ubyte* buffer, size_t count, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_output_stream_write(&this, buffer, count, cancellable, error);
   }

   // Tries to write @count bytes from @buffer into the stream. Will block
   // during the operation.
   // 
   // This function is similar to g_output_stream_write(), except it tries to
   // write as many bytes as requested, only stopping on an error.
   // 
   // On a successful write of @count bytes, %TRUE is returned, and @bytes_written
   // is set to @count.
   // 
   // If there is an error during the operation FALSE is returned and @error
   // is set to indicate the error status, @bytes_written is updated to contain
   // the number of bytes written into the stream before the error occurred.
   // RETURNS: %TRUE on success, %FALSE if there was an error
   // <buffer>: the buffer containing the data to write.
   // <count>: the number of bytes to write
   // <bytes_written>: location to store the number of bytes that was written to the stream
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int write_all(ubyte* buffer, size_t count, /*out*/ size_t* bytes_written, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_output_stream_write_all(&this, buffer, count, bytes_written, cancellable, error);
   }

   // Request an asynchronous write of @count bytes from @buffer into
   // the stream. When the operation is finished @callback will be called.
   // You can then call g_output_stream_write_finish() to get the result of the
   // operation.
   // 
   // During an async request no other sync and async calls are allowed,
   // and will result in %G_IO_ERROR_PENDING errors.
   // 
   // A value of @count larger than %G_MAXSSIZE will cause a
   // %G_IO_ERROR_INVALID_ARGUMENT error.
   // 
   // On success, the number of bytes written will be passed to the
   // @callback. It is not an error if this is not the same as the
   // requested size, as it can happen e.g. on a partial I/O error,
   // but generally we try to write as many bytes as requested.
   // 
   // You are guaranteed that this method will never fail with
   // %G_IO_ERROR_WOULD_BLOCK - if @stream can't accept more data, the
   // method will just wait until this changes.
   // 
   // Any outstanding I/O request with higher priority (lower numerical
   // value) will be executed before an outstanding request with lower
   // priority. Default priority is %G_PRIORITY_DEFAULT.
   // 
   // The asyncronous methods have a default fallback that uses threads
   // to implement asynchronicity, so they are optional for inheriting
   // classes. However, if you override one you must override all.
   // 
   // For the synchronous, blocking version of this function, see
   // g_output_stream_write().
   // <buffer>: the buffer containing the data to write.
   // <count>: the number of bytes to write
   // <io_priority>: the io priority of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void write_async(ubyte* buffer, size_t count, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_output_stream_write_async(&this, buffer, count, io_priority, cancellable, callback, user_data);
   }

   // Finishes a stream write operation.
   // RETURNS: a #gssize containing the number of bytes written to the stream.
   // <result>: a #GAsyncResult.
   ssize_t write_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_output_stream_write_finish(&this, result, error);
   }
}

struct OutputStreamClass {
   GObject2.ObjectClass parent_class;
   extern (C) ssize_t function (OutputStream* stream, void* buffer, size_t count, Cancellable* cancellable, GLib2.Error** error=null) write_fn;

   // RETURNS: a #gssize containing the size of the data spliced, or
   // <source>: a #GInputStream.
   // <flags>: a set of #GOutputStreamSpliceFlags.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) ssize_t function (OutputStream* stream, InputStream* source, OutputStreamSpliceFlags flags, Cancellable* cancellable, GLib2.Error** error=null) splice;

   // RETURNS: %TRUE on success, %FALSE on error
   // <cancellable>: optional cancellable object
   extern (C) int function (OutputStream* stream, Cancellable* cancellable, GLib2.Error** error=null) flush;
   extern (C) int function (OutputStream* stream, Cancellable* cancellable, GLib2.Error** error=null) close_fn;

   // <buffer>: the buffer containing the data to write.
   // <count>: the number of bytes to write
   // <io_priority>: the io priority of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (OutputStream* stream, ubyte* buffer, size_t count, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) write_async;

   // RETURNS: a #gssize containing the number of bytes written to the stream.
   // <result>: a #GAsyncResult.
   extern (C) ssize_t function (OutputStream* stream, AsyncResult* result, GLib2.Error** error=null) write_finish;

   // <source>: a #GInputStream.
   // <flags>: a set of #GOutputStreamSpliceFlags.
   // <io_priority>: the io priority of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback.
   // <user_data>: user data passed to @callback.
   extern (C) void function (OutputStream* stream, InputStream* source, OutputStreamSpliceFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) splice_async;

   // RETURNS: a #gssize of the number of bytes spliced. Note that if the
   // <result>: a #GAsyncResult.
   extern (C) ssize_t function (OutputStream* stream, AsyncResult* result, GLib2.Error** error=null) splice_finish;

   // <io_priority>: the io priority of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (OutputStream* stream, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) flush_async;

   // RETURNS: %TRUE if flush operation succeeded, %FALSE otherwise.
   // <result>: a GAsyncResult.
   extern (C) int function (OutputStream* stream, AsyncResult* result, GLib2.Error** error=null) flush_finish;

   // <io_priority>: the io priority of the request.
   // <cancellable>: optional cancellable object
   // <callback>: callback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (OutputStream* stream, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) close_async;

   // RETURNS: %TRUE if stream was successfully closed, %FALSE otherwise.
   // <result>: a #GAsyncResult.
   extern (C) int function (OutputStream* stream, AsyncResult* result, GLib2.Error** error=null) close_finish;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
   extern (C) void function () _g_reserved6;
   extern (C) void function () _g_reserved7;
   extern (C) void function () _g_reserved8;
}

struct OutputStreamPrivate {
}

// GOutputStreamSpliceFlags determine how streams should be spliced.
enum OutputStreamSpliceFlags {
   NONE = 0,
   CLOSE_SOURCE = 1,
   CLOSE_TARGET = 2
}

// Structure used for scatter/gather data output.
// You generally pass in an array of #GOutputVector<!-- -->s
// and the operation will use all the buffers as if they were
// one buffer.
struct OutputVector /* Version 2.22 */ {
   const(void)* buffer;
   size_t size;
}

enum PROXY_EXTENSION_POINT_NAME = "gio-proxy";
enum PROXY_RESOLVER_EXTENSION_POINT_NAME = "gio-proxy-resolver";

// #GPasswordSave is used to indicate the lifespan of a saved password.
// 
// #Gvfs stores passwords in the Gnome keyring when this flag allows it
// to, and later retrieves it again from there.
enum PasswordSave {
   NEVER = 0,
   FOR_SESSION = 1,
   PERMANENTLY = 2
}

// A #GPermission represents the status of the caller's permission to
// perform a certain action.
// 
// You can query if the action is currently allowed and if it is
// possible to acquire the permission so that the action will be allowed
// in the future.
// 
// There is also an API to actually acquire the permission and one to
// release it.
// 
// As an example, a #GPermission might represent the ability for the
// user to write to a #GSettings object.  This #GPermission object could
// then be used to decide if it is appropriate to show a "Click here to
// unlock" button in a dialog and to provide the mechanism to invoke
// when that button is clicked.
struct Permission /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private PermissionPrivate* priv;


   // Attempts to acquire the permission represented by @permission.
   // 
   // The precise method by which this happens depends on the permission
   // and the underlying authentication mechanism.  A simple example is
   // that a dialog may appear asking the user to enter their password.
   // 
   // You should check with g_permission_get_can_acquire() before calling
   // this function.
   // 
   // If the permission is acquired then %TRUE is returned.  Otherwise,
   // %FALSE is returned and @error is set appropriately.
   // 
   // This call is blocking, likely for a very long time (in the case that
   // user interaction is required).  See g_permission_acquire_async() for
   // the non-blocking version.
   // RETURNS: %TRUE if the permission was successfully acquired
   // <cancellable>: a #GCancellable, or %NULL
   int acquire(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_permission_acquire(&this, cancellable, error);
   }

   // Attempts to acquire the permission represented by @permission.
   // 
   // This is the first half of the asynchronous version of
   // g_permission_acquire().
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: the #GAsyncReadyCallback to call when done
   // <user_data>: the user data to pass to @callback
   void acquire_async(Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_permission_acquire_async(&this, cancellable, callback, user_data);
   }

   // Collects the result of attempting to acquire the permission
   // represented by @permission.
   // 
   // This is the second half of the asynchronous version of
   // g_permission_acquire().
   // RETURNS: %TRUE if the permission was successfully acquired
   // <result>: the #GAsyncResult given to the #GAsyncReadyCallback
   int acquire_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_permission_acquire_finish(&this, result, error);
   }

   // Gets the value of the 'allowed' property.  This property is %TRUE if
   // the caller currently has permission to perform the action that
   // @permission represents the permission to perform.
   // RETURNS: the value of the 'allowed' property
   int get_allowed() {
      return g_permission_get_allowed(&this);
   }

   // Gets the value of the 'can-acquire' property.  This property is %TRUE
   // if it is generally possible to acquire the permission by calling
   // g_permission_acquire().
   // RETURNS: the value of the 'can-acquire' property
   int get_can_acquire() {
      return g_permission_get_can_acquire(&this);
   }

   // Gets the value of the 'can-release' property.  This property is %TRUE
   // if it is generally possible to release the permission by calling
   // g_permission_release().
   // RETURNS: the value of the 'can-release' property
   int get_can_release() {
      return g_permission_get_can_release(&this);
   }

   // This function is called by the #GPermission implementation to update
   // the properties of the permission.  You should never call this
   // function except from a #GPermission implementation.
   // 
   // GObject notify signals are generated, as appropriate.
   // <allowed>: the new value for the 'allowed' property
   // <can_acquire>: the new value for the 'can-acquire' property
   // <can_release>: the new value for the 'can-release' property
   void impl_update(int allowed, int can_acquire, int can_release) {
      g_permission_impl_update(&this, allowed, can_acquire, can_release);
   }

   // Attempts to release the permission represented by @permission.
   // 
   // The precise method by which this happens depends on the permission
   // and the underlying authentication mechanism.  In most cases the
   // permission will be dropped immediately without further action.
   // 
   // You should check with g_permission_get_can_release() before calling
   // this function.
   // 
   // If the permission is released then %TRUE is returned.  Otherwise,
   // %FALSE is returned and @error is set appropriately.
   // 
   // This call is blocking, likely for a very long time (in the case that
   // user interaction is required).  See g_permission_release_async() for
   // the non-blocking version.
   // RETURNS: %TRUE if the permission was successfully released
   // <cancellable>: a #GCancellable, or %NULL
   int release(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_permission_release(&this, cancellable, error);
   }

   // Attempts to release the permission represented by @permission.
   // 
   // This is the first half of the asynchronous version of
   // g_permission_release().
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: the #GAsyncReadyCallback to call when done
   // <user_data>: the user data to pass to @callback
   void release_async(Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_permission_release_async(&this, cancellable, callback, user_data);
   }

   // Collects the result of attempting to release the permission
   // represented by @permission.
   // 
   // This is the second half of the asynchronous version of
   // g_permission_release().
   // RETURNS: %TRUE if the permission was successfully released
   // <result>: the #GAsyncResult given to the #GAsyncReadyCallback
   int release_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_permission_release_finish(&this, result, error);
   }
}

struct PermissionClass {
   GObject2.ObjectClass parent_class;

   // RETURNS: %TRUE if the permission was successfully acquired
   // <cancellable>: a #GCancellable, or %NULL
   extern (C) int function (Permission* permission, Cancellable* cancellable, GLib2.Error** error=null) acquire;

   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: the #GAsyncReadyCallback to call when done
   // <user_data>: the user data to pass to @callback
   extern (C) void function (Permission* permission, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) acquire_async;

   // RETURNS: %TRUE if the permission was successfully acquired
   // <result>: the #GAsyncResult given to the #GAsyncReadyCallback
   extern (C) int function (Permission* permission, AsyncResult* result, GLib2.Error** error=null) acquire_finish;

   // RETURNS: %TRUE if the permission was successfully released
   // <cancellable>: a #GCancellable, or %NULL
   extern (C) int function (Permission* permission, Cancellable* cancellable, GLib2.Error** error=null) release;

   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: the #GAsyncReadyCallback to call when done
   // <user_data>: the user data to pass to @callback
   extern (C) void function (Permission* permission, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) release_async;

   // RETURNS: %TRUE if the permission was successfully released
   // <result>: the #GAsyncResult given to the #GAsyncReadyCallback
   extern (C) int function (Permission* permission, AsyncResult* result, GLib2.Error** error=null) release_finish;
   void*[16] reserved;
}

struct PermissionPrivate {
}


// #GPollableInputStream is implemented by #GInputStream<!-- -->s that
// can be polled for readiness to read. This can be used when
// interfacing with a non-GIO API that expects
// UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
struct PollableInputStream /* Version 2.28 */ {

   // Checks if @stream is actually pollable. Some classes may implement
   // #GPollableInputStream but have only certain instances of that class
   // be pollable. If this method returns %FALSE, then the behavior of
   // other #GPollableInputStream methods is undefined.
   // 
   // For any given stream, the value returned by this method is constant;
   // a stream cannot switch from pollable to non-pollable or vice versa.
   // RETURNS: %TRUE if @stream is pollable, %FALSE if not.
   int can_poll() {
      return g_pollable_input_stream_can_poll(&this);
   }

   // Unintrospectable method: create_source() / g_pollable_input_stream_create_source()
   // Creates a #GSource that triggers when @stream can be read, or
   // @cancellable is triggered or an error occurs. The callback on the
   // source is of the #GPollableSourceFunc type.
   // 
   // As with g_pollable_input_stream_is_readable(), it is possible that
   // the stream may not actually be readable even after the source
   // triggers, so you should use g_pollable_input_stream_read_nonblocking()
   // rather than g_input_stream_read() from the callback.
   // RETURNS: a new #GSource
   // <cancellable>: a #GCancellable, or %NULL
   GLib2.Source* /*new*/ create_source(Cancellable* cancellable=null) {
      return g_pollable_input_stream_create_source(&this, cancellable);
   }

   // Checks if @stream can be read.
   // 
   // Note that some stream types may not be able to implement this 100%
   // reliably, and it is possible that a call to g_input_stream_read()
   // after this returns %TRUE would still block. To guarantee
   // non-blocking behavior, you should always use
   // g_pollable_input_stream_read_nonblocking(), which will return a
   // %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
   // 
   // has occurred on @stream, this will result in
   // g_pollable_input_stream_is_readable() returning %TRUE, and the
   // next attempt to read will return the error.
   // RETURNS: %TRUE if @stream is readable, %FALSE if not. If an error
   int is_readable() {
      return g_pollable_input_stream_is_readable(&this);
   }

   // Attempts to read up to @size bytes from @stream into @buffer, as
   // with g_input_stream_read(). If @stream is not currently readable,
   // this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
   // use g_pollable_input_stream_create_source() to create a #GSource
   // that will be triggered when @stream is readable.
   // 
   // Note that since this method never blocks, you cannot actually
   // use @cancellable to cancel it. However, it will return an error
   // if @cancellable has already been cancelled when you call, which
   // may happen if you call this method after a source triggers due
   // to having been cancelled.
   // 
   // %G_IO_ERROR_WOULD_BLOCK).
   // RETURNS: the number of bytes read, or -1 on error (including
   // <buffer>: a buffer to read data into (which should be at least @size bytes long).
   // <size>: the number of bytes you want to read
   // <cancellable>: a #GCancellable, or %NULL
   ssize_t read_nonblocking(void* buffer, size_t size, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_pollable_input_stream_read_nonblocking(&this, buffer, size, cancellable, error);
   }
}


// The interface for pollable input streams.
// 
// The default implementation of @can_poll always returns %TRUE.
// 
// The default implementation of @read_nonblocking calls
// g_pollable_input_stream_is_readable(), and then calls
// g_input_stream_read() if it returns %TRUE. This means you only need
// to override it if it is possible that your @is_readable
// implementation may return %TRUE when the stream is not actually
// readable.
struct PollableInputStreamInterface /* Version 2.28 */ {
   GObject2.TypeInterface g_iface;
   // RETURNS: %TRUE if @stream is pollable, %FALSE if not.
   extern (C) int function (PollableInputStream* stream) can_poll;
   // RETURNS: %TRUE if @stream is readable, %FALSE if not. If an error
   extern (C) int function (PollableInputStream* stream) is_readable;

   // RETURNS: a new #GSource
   // <cancellable>: a #GCancellable, or %NULL
   extern (C) GLib2.Source* /*new*/ function (PollableInputStream* stream, Cancellable* cancellable=null) create_source;

   // RETURNS: the number of bytes read, or -1 on error (including
   // <buffer>: a buffer to read data into (which should be at least @size bytes long).
   // <size>: the number of bytes you want to read
   extern (C) ssize_t function (PollableInputStream* stream, void* buffer, size_t size, GLib2.Error** error=null) read_nonblocking;
}


// #GPollableOutputStream is implemented by #GOutputStream<!-- -->s that
// can be polled for readiness to write. This can be used when
// interfacing with a non-GIO API that expects
// UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
struct PollableOutputStream /* Version 2.28 */ {

   // Checks if @stream is actually pollable. Some classes may implement
   // #GPollableOutputStream but have only certain instances of that
   // class be pollable. If this method returns %FALSE, then the behavior
   // of other #GPollableOutputStream methods is undefined.
   // 
   // For any given stream, the value returned by this method is constant;
   // a stream cannot switch from pollable to non-pollable or vice versa.
   // RETURNS: %TRUE if @stream is pollable, %FALSE if not.
   int can_poll() {
      return g_pollable_output_stream_can_poll(&this);
   }

   // Unintrospectable method: create_source() / g_pollable_output_stream_create_source()
   // Creates a #GSource that triggers when @stream can be written, or
   // @cancellable is triggered or an error occurs. The callback on the
   // source is of the #GPollableSourceFunc type.
   // 
   // As with g_pollable_output_stream_is_writable(), it is possible that
   // the stream may not actually be writable even after the source
   // triggers, so you should use g_pollable_output_stream_write_nonblocking()
   // rather than g_output_stream_write() from the callback.
   // RETURNS: a new #GSource
   // <cancellable>: a #GCancellable, or %NULL
   GLib2.Source* /*new*/ create_source(Cancellable* cancellable=null) {
      return g_pollable_output_stream_create_source(&this, cancellable);
   }

   // Checks if @stream can be written.
   // 
   // Note that some stream types may not be able to implement this 100%
   // reliably, and it is possible that a call to g_output_stream_write()
   // after this returns %TRUE would still block. To guarantee
   // non-blocking behavior, you should always use
   // g_pollable_output_stream_write_nonblocking(), which will return a
   // %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
   // 
   // has occurred on @stream, this will result in
   // g_pollable_output_stream_is_writable() returning %TRUE, and the
   // next attempt to write will return the error.
   // RETURNS: %TRUE if @stream is writable, %FALSE if not. If an error
   int is_writable() {
      return g_pollable_output_stream_is_writable(&this);
   }

   // Attempts to write up to @size bytes from @buffer to @stream, as
   // with g_output_stream_write(). If @stream is not currently writable,
   // this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
   // use g_pollable_output_stream_create_source() to create a #GSource
   // that will be triggered when @stream is writable.
   // 
   // Note that since this method never blocks, you cannot actually
   // use @cancellable to cancel it. However, it will return an error
   // if @cancellable has already been cancelled when you call, which
   // may happen if you call this method after a source triggers due
   // to having been cancelled.
   // 
   // %G_IO_ERROR_WOULD_BLOCK).
   // RETURNS: the number of bytes written, or -1 on error (including
   // <buffer>: a buffer to write data from
   // <size>: the number of bytes you want to write
   // <cancellable>: a #GCancellable, or %NULL
   ssize_t write_nonblocking(ubyte* buffer, size_t size, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_pollable_output_stream_write_nonblocking(&this, buffer, size, cancellable, error);
   }
}


// The interface for pollable output streams.
// 
// The default implementation of @can_poll always returns %TRUE.
// 
// The default implementation of @write_nonblocking calls
// g_pollable_output_stream_is_writable(), and then calls
// g_output_stream_write() if it returns %TRUE. This means you only
// need to override it if it is possible that your @is_writable
// implementation may return %TRUE when the stream is not actually
// writable.
struct PollableOutputStreamInterface /* Version 2.28 */ {
   GObject2.TypeInterface g_iface;
   // RETURNS: %TRUE if @stream is pollable, %FALSE if not.
   extern (C) int function (PollableOutputStream* stream) can_poll;
   // RETURNS: %TRUE if @stream is writable, %FALSE if not. If an error
   extern (C) int function (PollableOutputStream* stream) is_writable;

   // RETURNS: a new #GSource
   // <cancellable>: a #GCancellable, or %NULL
   extern (C) GLib2.Source* /*new*/ function (PollableOutputStream* stream, Cancellable* cancellable=null) create_source;

   // RETURNS: the number of bytes written, or -1 on error (including
   // <buffer>: a buffer to write data from
   // <size>: the number of bytes you want to write
   extern (C) ssize_t function (PollableOutputStream* stream, ubyte* buffer, size_t size, GLib2.Error** error=null) write_nonblocking;
}


// This is the function type of the callback used for the #GSource
// returned by g_pollable_input_stream_create_source() and
// g_pollable_output_stream_create_source().
// RETURNS: it should return %FALSE if the source should be removed.
// <pollable_stream>: the #GPollableInputStream or #GPollableOutputStream
// <user_data>: data passed in by the user.
extern (C) alias int function (GObject2.Object* pollable_stream, void* user_data) PollableSourceFunc;


// A #GProxy handles connecting to a remote host via a given type of
// proxy server. It is implemented by the 'gio-proxy' extension point.
// The extensions are named after their proxy protocol name. As an
// example, a SOCKS5 proxy implementation can be retrieved with the
// name 'socks5' using the function
// g_io_extension_point_get_extension_by_name().
struct Proxy /* Version 2.26 */ {

   // Lookup "gio-proxy" extension point for a proxy implementation that supports
   // specified protocol.
   // 
   // is not supported.
   // RETURNS: return a #GProxy or NULL if protocol
   // <protocol>: the proxy protocol name (e.g. http, socks, etc)
   static Proxy* /*new*/ get_default_for_protocol(char* protocol) {
      return g_proxy_get_default_for_protocol(protocol);
   }

   // Given @connection to communicate with a proxy (eg, a
   // #GSocketConnection that is connected to the proxy server), this
   // does the necessary handshake to connect to @proxy_address, and if
   // required, wraps the #GIOStream to handle proxy payload.
   // 
   // be the same as @connection, in which case a reference
   // will be added.
   // RETURNS: a #GIOStream that will replace @connection. This might
   // <connection>: a #GIOStream
   // <proxy_address>: a #GProxyAddress
   // <cancellable>: a #GCancellable
   IOStream* /*new*/ connect(IOStream* connection, ProxyAddress* proxy_address, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_proxy_connect(&this, connection, proxy_address, cancellable, error);
   }

   // Asynchronous version of g_proxy_connect().
   // <connection>: a #GIOStream
   // <proxy_address>: a #GProxyAddress
   // <cancellable>: a #GCancellable
   // <callback>: a #GAsyncReadyCallback
   // <user_data>: callback data
   void connect_async(IOStream* connection, ProxyAddress* proxy_address, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_proxy_connect_async(&this, connection, proxy_address, cancellable, callback, user_data);
   }

   // See g_proxy_connect().
   // RETURNS: a #GIOStream.
   // <result>: a #GAsyncResult
   IOStream* /*new*/ connect_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_proxy_connect_finish(&this, result, error);
   }

   // Some proxy protocols expect to be passed a hostname, which they
   // will resolve to an IP address themselves. Others, like SOCKS4, do
   // not allow this. This function will return %FALSE if @proxy is
   // implementing such a protocol. When %FALSE is returned, the caller
   // should resolve the destination hostname first, and then pass a
   // #GProxyAddress containing the stringified IP address to
   // g_proxy_connect() or g_proxy_connect_async().
   // RETURNS: %TRUE if hostname resolution is supported.
   int supports_hostname() {
      return g_proxy_supports_hostname(&this);
   }
}

// Support for proxied #GInetSocketAddress.
struct ProxyAddress /* : InetSocketAddress */ /* Version 2.26 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance inetsocketaddress;
   InetSocketAddress parent_instance;
   private ProxyAddressPrivate* priv;


   // Creates a new #GProxyAddress for @inetaddr with @protocol that should
   // tunnel through @dest_hostname and @dest_port.
   // RETURNS: a new #GProxyAddress
   // <inetaddr>: The proxy server #GInetAddress.
   // <port>: The proxy server port.
   // <protocol>: The proxy protocol to support, in lower case (e.g. socks, http).
   // <dest_hostname>: The destination hostname the the proxy should tunnel to.
   // <dest_port>: The destination port to tunnel to.
   // <username>: The username to authenticate to the proxy server (or %NULL).
   // <password>: The password to authenticate to the proxy server (or %NULL).
   static ProxyAddress* /*new*/ new_(InetAddress* inetaddr, ushort port, char* protocol, char* dest_hostname, ushort dest_port, char* username=null, char* password=null) {
      return g_proxy_address_new(inetaddr, port, protocol, dest_hostname, dest_port, username, password);
   }

   // Gets @proxy's destination hostname.
   // RETURNS: the @proxy's destination hostname
   char* get_destination_hostname() {
      return g_proxy_address_get_destination_hostname(&this);
   }

   // Gets @proxy's destination port.
   // RETURNS: the @proxy's destination port
   ushort get_destination_port() {
      return g_proxy_address_get_destination_port(&this);
   }

   // Gets @proxy's password.
   // RETURNS: the @proxy's password
   char* get_password() {
      return g_proxy_address_get_password(&this);
   }

   // Gets @proxy's protocol.
   // RETURNS: the @proxy's protocol
   char* get_protocol() {
      return g_proxy_address_get_protocol(&this);
   }

   // Gets @proxy's username.
   // RETURNS: the @proxy's username
   char* get_username() {
      return g_proxy_address_get_username(&this);
   }
}

struct ProxyAddressClass {
   InetSocketAddressClass parent_class;
}


// A subclass of #GSocketAddressEnumerator that takes another address
// enumerator and wraps its results in #GProxyAddress<!-- -->es as
// directed by the default #GProxyResolver.
struct ProxyAddressEnumerator /* : SocketAddressEnumerator */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance socketaddressenumerator;
   SocketAddressEnumerator parent_instance;
   ProxyAddressEnumeratorPrivate* priv;
}

struct ProxyAddressEnumeratorClass {
   SocketAddressEnumeratorClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
   extern (C) void function () _g_reserved6;
   extern (C) void function () _g_reserved7;
}

struct ProxyAddressEnumeratorPrivate {
}

struct ProxyAddressPrivate {
}

// Provides an interface for handling proxy connection and payload.
struct ProxyInterface /* Version 2.26 */ {
   GObject2.TypeInterface g_iface;

   // RETURNS: a #GIOStream that will replace @connection. This might
   // <connection>: a #GIOStream
   // <proxy_address>: a #GProxyAddress
   // <cancellable>: a #GCancellable
   extern (C) IOStream* /*new*/ function (Proxy* proxy, IOStream* connection, ProxyAddress* proxy_address, Cancellable* cancellable, GLib2.Error** error=null) connect;

   // <connection>: a #GIOStream
   // <proxy_address>: a #GProxyAddress
   // <cancellable>: a #GCancellable
   // <callback>: a #GAsyncReadyCallback
   // <user_data>: callback data
   extern (C) void function (Proxy* proxy, IOStream* connection, ProxyAddress* proxy_address, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) connect_async;

   // RETURNS: a #GIOStream.
   // <result>: a #GAsyncResult
   extern (C) IOStream* /*new*/ function (Proxy* proxy, AsyncResult* result, GLib2.Error** error=null) connect_finish;
   // RETURNS: %TRUE if hostname resolution is supported.
   extern (C) int function (Proxy* proxy) supports_hostname;
}


// #GProxyResolver provides synchronous and asynchronous network proxy
// resolution. #GProxyResolver is used within #GSocketClient through
// the method g_socket_connectable_proxy_enumerate().
struct ProxyResolver {

   // Gets the default #GProxyResolver for the system.
   // RETURNS: the default #GProxyResolver.
   static ProxyResolver* get_default() {
      return g_proxy_resolver_get_default();
   }

   // Checks if @resolver can be used on this system. (This is used
   // internally; g_proxy_resolver_get_default() will only return a proxy
   // resolver that returns %TRUE for this method.)
   // RETURNS: %TRUE if @resolver is supported.
   int is_supported() {
      return g_proxy_resolver_is_supported(&this);
   }

   // Looks into the system proxy configuration to determine what proxy,
   // if any, to use to connect to @uri. The returned proxy URIs are of the
   // form <literal>&lt;protocol&gt;://[user[:password]@]host:port</literal>
   // or <literal>direct://</literal>, where &lt;protocol&gt; could be
   // http, rtsp, socks or other proxying protocol.
   // 
   // If you don't know what network protocol is being used on the
   // socket, you should use <literal>none</literal> as the URI protocol.
   // In this case, the resolver might still return a generic proxy type
   // (such as SOCKS), but would not return protocol-specific proxy types
   // (such as http).
   // 
   // <literal>direct://</literal> is used when no proxy is needed.
   // Direct connection should not be attempted unless it is part of the
   // returned array of proxies.
   // 
   // NULL-terminated array of proxy URIs. Must be freed
   // with g_strfreev().
   // RETURNS: A
   // <uri>: a URI representing the destination to connect to
   // <cancellable>: a #GCancellable, or %NULL
   char** /*new*/ lookup(char* uri, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_proxy_resolver_lookup(&this, uri, cancellable, error);
   }

   // Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more
   // details.
   // <uri>: a URI representing the destination to connect to
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call after resolution completes
   // <user_data>: data for @callback
   void lookup_async(char* uri, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_proxy_resolver_lookup_async(&this, uri, cancellable, callback, user_data);
   }

   // Call this function to obtain the array of proxy URIs when
   // g_proxy_resolver_lookup_async() is complete. See
   // g_proxy_resolver_lookup() for more details.
   // 
   // NULL-terminated array of proxy URIs. Must be freed
   // with g_strfreev().
   // RETURNS: A
   // <result>: the result passed to your #GAsyncReadyCallback
   char** /*new*/ lookup_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_proxy_resolver_lookup_finish(&this, result, error);
   }
}

struct ProxyResolverInterface {
   GObject2.TypeInterface g_iface;
   // RETURNS: %TRUE if @resolver is supported.
   extern (C) int function (ProxyResolver* resolver) is_supported;

   // RETURNS: A
   // <uri>: a URI representing the destination to connect to
   // <cancellable>: a #GCancellable, or %NULL
   extern (C) char** /*new*/ function (ProxyResolver* resolver, char* uri, Cancellable* cancellable, GLib2.Error** error=null) lookup;

   // <uri>: a URI representing the destination to connect to
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call after resolution completes
   // <user_data>: data for @callback
   extern (C) void function (ProxyResolver* resolver, char* uri, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) lookup_async;

   // RETURNS: A
   // <result>: the result passed to your #GAsyncReadyCallback
   extern (C) char** /*new*/ function (ProxyResolver* resolver, AsyncResult* result, GLib2.Error** error=null) lookup_finish;
}


// Unintrospectable callback: ReallocFunc() / ()
// Changes the size of the memory block pointed to by @data to
// @size bytes.
// 
// The function should have the same semantics as realloc().
// RETURNS: a pointer to the reallocated memory
// <data>: memory block to reallocate
// <size>: size to reallocate @data to
extern (C) alias void* function (void* data, size_t size) ReallocFunc;


// #GResolver provides cancellable synchronous and asynchronous DNS
// resolution, for hostnames (g_resolver_lookup_by_address(),
// g_resolver_lookup_by_name() and their async variants) and SRV
// (service) records (g_resolver_lookup_service()).
// 
// #GNetworkAddress and #GNetworkService provide wrappers around
// #GResolver functionality that also implement #GSocketConnectable,
// making it easy to connect to a remote host/service.
struct Resolver /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   ResolverPrivate* priv;


   // Unintrospectable function: free_addresses() / g_resolver_free_addresses()
   // Frees @addresses (which should be the return value from
   // g_resolver_lookup_by_name() or g_resolver_lookup_by_name_finish()).
   // (This is a convenience method; you can also simply free the results
   // by hand.)
   // <addresses>: a #GList of #GInetAddress
   static void free_addresses(GLib2.List* addresses) {
      g_resolver_free_addresses(addresses);
   }

   // Unintrospectable function: free_targets() / g_resolver_free_targets()
   // Frees @targets (which should be the return value from
   // g_resolver_lookup_service() or g_resolver_lookup_service_finish()).
   // (This is a convenience method; you can also simply free the
   // results by hand.)
   // <targets>: a #GList of #GSrvTarget
   static void free_targets(GLib2.List* targets) {
      g_resolver_free_targets(targets);
   }

   // Gets the default #GResolver. You should unref it when you are done
   // with it. #GResolver may use its reference count as a hint about how
   // many threads/processes, etc it should allocate for concurrent DNS
   // resolutions.
   // RETURNS: the default #GResolver.
   static Resolver* /*new*/ get_default() {
      return g_resolver_get_default();
   }

   // Synchronously reverse-resolves @address to determine its
   // associated hostname.
   // 
   // If the DNS resolution fails, @error (if non-%NULL) will be set to
   // a value from #GResolverError.
   // 
   // If @cancellable is non-%NULL, it can be used to cancel the
   // operation, in which case @error (if non-%NULL) will be set to
   // %G_IO_ERROR_CANCELLED.
   // 
   // form), or %NULL on error.
   // RETURNS: a hostname (either ASCII-only, or in ASCII-encoded
   // <address>: the address to reverse-resolve
   // <cancellable>: a #GCancellable, or %NULL
   char* /*new*/ lookup_by_address(InetAddress* address, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_resolver_lookup_by_address(&this, address, cancellable, error);
   }

   // Begins asynchronously reverse-resolving @address to determine its
   // associated hostname, and eventually calls @callback, which must
   // call g_resolver_lookup_by_address_finish() to get the final result.
   // <address>: the address to reverse-resolve
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call after resolution completes
   // <user_data>: data for @callback
   void lookup_by_address_async(InetAddress* address, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_resolver_lookup_by_address_async(&this, address, cancellable, callback, user_data);
   }

   // Retrieves the result of a previous call to
   // g_resolver_lookup_by_address_async().
   // 
   // If the DNS resolution failed, @error (if non-%NULL) will be set to
   // a value from #GResolverError. If the operation was cancelled,
   // @error will be set to %G_IO_ERROR_CANCELLED.
   // 
   // form), or %NULL on error.
   // RETURNS: a hostname (either ASCII-only, or in ASCII-encoded
   // <result>: the result passed to your #GAsyncReadyCallback
   char* /*new*/ lookup_by_address_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_resolver_lookup_by_address_finish(&this, result, error);
   }

   // Synchronously resolves @hostname to determine its associated IP
   // address(es). @hostname may be an ASCII-only or UTF-8 hostname, or
   // the textual form of an IP address (in which case this just becomes
   // a wrapper around g_inet_address_new_from_string()).
   // 
   // On success, g_resolver_lookup_by_name() will return a #GList of
   // #GInetAddress, sorted in order of preference and guaranteed to not
   // contain duplicates. That is, if using the result to connect to
   // @hostname, you should attempt to connect to the first address
   // first, then the second if the first fails, etc. If you are using
   // the result to listen on a socket, it is appropriate to add each
   // result using e.g. g_socket_listener_add_address().
   // 
   // If the DNS resolution fails, @error (if non-%NULL) will be set to a
   // value from #GResolverError.
   // 
   // If @cancellable is non-%NULL, it can be used to cancel the
   // operation, in which case @error (if non-%NULL) will be set to
   // %G_IO_ERROR_CANCELLED.
   // 
   // If you are planning to connect to a socket on the resolved IP
   // address, it may be easier to create a #GNetworkAddress and use its
   // #GSocketConnectable interface.
   // 
   // of #GInetAddress, or %NULL on error. You
   // must unref each of the addresses and free the list when you are
   // done with it. (You can use g_resolver_free_addresses() to do this.)
   // RETURNS: a #GList
   // <hostname>: the hostname to look up
   // <cancellable>: a #GCancellable, or %NULL
   GLib2.List* /*new*/ lookup_by_name(char* hostname, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_resolver_lookup_by_name(&this, hostname, cancellable, error);
   }

   // Begins asynchronously resolving @hostname to determine its
   // associated IP address(es), and eventually calls @callback, which
   // must call g_resolver_lookup_by_name_finish() to get the result.
   // See g_resolver_lookup_by_name() for more details.
   // <hostname>: the hostname to look up the address of
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call after resolution completes
   // <user_data>: data for @callback
   void lookup_by_name_async(char* hostname, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_resolver_lookup_by_name_async(&this, hostname, cancellable, callback, user_data);
   }

   // Retrieves the result of a call to
   // g_resolver_lookup_by_name_async().
   // 
   // If the DNS resolution failed, @error (if non-%NULL) will be set to
   // a value from #GResolverError. If the operation was cancelled,
   // @error will be set to %G_IO_ERROR_CANCELLED.
   // 
   // of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name()
   // for more details.
   // RETURNS: a #GList
   // <result>: the result passed to your #GAsyncReadyCallback
   GLib2.List* /*new*/ lookup_by_name_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_resolver_lookup_by_name_finish(&this, result, error);
   }

   // Synchronously performs a DNS SRV lookup for the given @service and
   // @protocol in the given @domain and returns an array of #GSrvTarget.
   // @domain may be an ASCII-only or UTF-8 hostname. Note also that the
   // @service and @protocol arguments <emphasis>do not</emphasis>
   // include the leading underscore that appears in the actual DNS
   // entry.
   // 
   // On success, g_resolver_lookup_service() will return a #GList of
   // #GSrvTarget, sorted in order of preference. (That is, you should
   // attempt to connect to the first target first, then the second if
   // the first fails, etc.)
   // 
   // If the DNS resolution fails, @error (if non-%NULL) will be set to
   // a value from #GResolverError.
   // 
   // If @cancellable is non-%NULL, it can be used to cancel the
   // operation, in which case @error (if non-%NULL) will be set to
   // %G_IO_ERROR_CANCELLED.
   // 
   // If you are planning to connect to the service, it is usually easier
   // to create a #GNetworkService and use its #GSocketConnectable
   // interface.
   // 
   // or %NULL on error. You must free each of the targets and the list when you are
   // done with it. (You can use g_resolver_free_targets() to do this.)
   // RETURNS: a #GList of #GSrvTarget,
   // <service>: the service type to look up (eg, "ldap")
   // <protocol>: the networking protocol to use for @service (eg, "tcp")
   // <domain>: the DNS domain to look up the service in
   // <cancellable>: a #GCancellable, or %NULL
   GLib2.List* /*new*/ lookup_service(char* service, char* protocol, char* domain, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_resolver_lookup_service(&this, service, protocol, domain, cancellable, error);
   }

   // Begins asynchronously performing a DNS SRV lookup for the given
   // @service and @protocol in the given @domain, and eventually calls
   // @callback, which must call g_resolver_lookup_service_finish() to
   // get the final result. See g_resolver_lookup_service() for more
   // details.
   // <service>: the service type to look up (eg, "ldap")
   // <protocol>: the networking protocol to use for @service (eg, "tcp")
   // <domain>: the DNS domain to look up the service in
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call after resolution completes
   // <user_data>: data for @callback
   void lookup_service_async(char* service, char* protocol, char* domain, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_resolver_lookup_service_async(&this, service, protocol, domain, cancellable, callback, user_data);
   }

   // Retrieves the result of a previous call to
   // g_resolver_lookup_service_async().
   // 
   // If the DNS resolution failed, @error (if non-%NULL) will be set to
   // a value from #GResolverError. If the operation was cancelled,
   // @error will be set to %G_IO_ERROR_CANCELLED.
   // 
   // or %NULL on error. See g_resolver_lookup_service() for more details.
   // RETURNS: a #GList of #GSrvTarget,
   // <result>: the result passed to your #GAsyncReadyCallback
   GLib2.List* /*new*/ lookup_service_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_resolver_lookup_service_finish(&this, result, error);
   }

   // Sets @resolver to be the application's default resolver (reffing
   // @resolver, and unreffing the previous default resolver, if any).
   // Future calls to g_resolver_get_default() will return this resolver.
   // 
   // This can be used if an application wants to perform any sort of DNS
   // caching or "pinning"; it can implement its own #GResolver that
   // calls the original default resolver for DNS operations, and
   // implements its own cache policies on top of that, and then set
   // itself as the default resolver for all later code to use.
   void set_default() {
      g_resolver_set_default(&this);
   }

   // Emitted when the resolver notices that the system resolver
   // configuration has changed.
   extern (C) alias static void function (Resolver* this_, void* user_data=null) signal_reload;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"reload", CB:signal_reload)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"reload",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ResolverClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (Resolver* resolver) reload;

   // RETURNS: a #GList
   // <hostname>: the hostname to look up
   // <cancellable>: a #GCancellable, or %NULL
   extern (C) GLib2.List* /*new*/ function (Resolver* resolver, char* hostname, Cancellable* cancellable, GLib2.Error** error=null) lookup_by_name;

   // <hostname>: the hostname to look up the address of
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call after resolution completes
   // <user_data>: data for @callback
   extern (C) void function (Resolver* resolver, char* hostname, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) lookup_by_name_async;

   // RETURNS: a #GList
   // <result>: the result passed to your #GAsyncReadyCallback
   extern (C) GLib2.List* /*new*/ function (Resolver* resolver, AsyncResult* result, GLib2.Error** error=null) lookup_by_name_finish;

   // RETURNS: a hostname (either ASCII-only, or in ASCII-encoded
   // <address>: the address to reverse-resolve
   // <cancellable>: a #GCancellable, or %NULL
   extern (C) char* /*new*/ function (Resolver* resolver, InetAddress* address, Cancellable* cancellable, GLib2.Error** error=null) lookup_by_address;

   // <address>: the address to reverse-resolve
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call after resolution completes
   // <user_data>: data for @callback
   extern (C) void function (Resolver* resolver, InetAddress* address, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) lookup_by_address_async;

   // RETURNS: a hostname (either ASCII-only, or in ASCII-encoded
   // <result>: the result passed to your #GAsyncReadyCallback
   extern (C) char* /*new*/ function (Resolver* resolver, AsyncResult* result, GLib2.Error** error=null) lookup_by_address_finish;
   // Unintrospectable functionp: lookup_service() / ()
   extern (C) GLib2.List* function (Resolver* resolver, char* rrname, Cancellable* cancellable, GLib2.Error** error=null) lookup_service;
   extern (C) void function (Resolver* resolver, char* rrname, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) lookup_service_async;

   // RETURNS: a #GList of #GSrvTarget,
   // <result>: the result passed to your #GAsyncReadyCallback
   extern (C) GLib2.List* /*new*/ function (Resolver* resolver, AsyncResult* result, GLib2.Error** error=null) lookup_service_finish;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
   extern (C) void function () _g_reserved6;
}


// An error code used with %G_RESOLVER_ERROR in a #GError returned
// from a #GResolver routine.
enum ResolverError /* Version 2.22 */ {
   NOT_FOUND = 0,
   TEMPORARY_FAILURE = 1,
   INTERNAL = 2
}
struct ResolverPrivate {
}


// #GSeekable is implemented by streams (implementations of
// #GInputStream or #GOutputStream) that support seeking.
struct Seekable {

   // Tests if the stream supports the #GSeekableIface.
   // RETURNS: %TRUE if @seekable can be seeked. %FALSE otherwise.
   int can_seek() {
      return g_seekable_can_seek(&this);
   }

   // Tests if the stream can be truncated.
   // RETURNS: %TRUE if the stream can be truncated, %FALSE otherwise.
   int can_truncate() {
      return g_seekable_can_truncate(&this);
   }

   // Seeks in the stream by the given @offset, modified by @type.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // 
   // has occurred, this function will return %FALSE and set @error
   // appropriately if present.
   // RETURNS: %TRUE if successful. If an error
   // <offset>: a #goffset.
   // <type>: a #GSeekType.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int seek(long offset, GLib2.SeekType type, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_seekable_seek(&this, offset, type, cancellable, error);
   }

   // Tells the current position within the stream.
   // RETURNS: the offset from the beginning of the buffer.
   long tell() {
      return g_seekable_tell(&this);
   }

   // Truncates a stream with a given #offset.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
   // operation was partially finished when the operation was cancelled the
   // partial result will be returned, without an error.
   // 
   // has occurred, this function will return %FALSE and set @error
   // appropriately if present.
   // RETURNS: %TRUE if successful. If an error
   // <offset>: a #goffset.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int truncate(long offset, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_seekable_truncate(&this, offset, cancellable, error);
   }
}

// Provides an interface for implementing seekable functionality on I/O Streams.
struct SeekableIface {
   GObject2.TypeInterface g_iface;
   // RETURNS: the offset from the beginning of the buffer.
   extern (C) long function (Seekable* seekable) tell;
   // RETURNS: %TRUE if @seekable can be seeked. %FALSE otherwise.
   extern (C) int function (Seekable* seekable) can_seek;

   // RETURNS: %TRUE if successful. If an error
   // <offset>: a #goffset.
   // <type>: a #GSeekType.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) int function (Seekable* seekable, long offset, GLib2.SeekType type, Cancellable* cancellable, GLib2.Error** error=null) seek;
   // RETURNS: %TRUE if the stream can be truncated, %FALSE otherwise.
   extern (C) int function (Seekable* seekable) can_truncate;

   // RETURNS: %TRUE if successful. If an error
   // <offset>: a #goffset.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) int function (Seekable* seekable, long offset, Cancellable* cancellable, GLib2.Error** error=null) truncate_fn;
}


// The #GSettings class provides a convenient API for storing and retrieving
// application settings.
// 
// Reads and writes can be considered to be non-blocking.  Reading
// settings with #GSettings is typically extremely fast: on
// approximately the same order of magnitude (but slower than) a
// #GHashTable lookup.  Writing settings is also extremely fast in terms
// of time to return to your application, but can be extremely expensive
// for other threads and other processes.  Many settings backends
// (including dconf) have lazy initialisation which means in the common
// case of the user using their computer without modifying any settings
// a lot of work can be avoided.  For dconf, the D-Bus service doesn't
// even need to be started in this case.  For this reason, you should
// only ever modify #GSettings keys in response to explicit user action.
// Particular care should be paid to ensure that modifications are not
// made during startup -- for example, when setting the initial value
// of preferences widgets.  The built-in g_settings_bind() functionality
// is careful not to write settings in response to notify signals as a
// result of modifications that it makes to widgets.
// 
// When creating a GSettings instance, you have to specify a schema
// that describes the keys in your settings and their types and default
// values, as well as some other information.
// 
// Normally, a schema has as fixed path that determines where the settings
// are stored in the conceptual global tree of settings. However, schemas
// can also be 'relocatable', i.e. not equipped with a fixed path. This is
// useful e.g. when the schema describes an 'account', and you want to be
// able to store a arbitrary number of accounts.
// 
// Unlike other configuration systems (like GConf), GSettings does not
// restrict keys to basic types like strings and numbers. GSettings stores
// values as #GVariant, and allows any #GVariantType for keys. Key names
// are restricted to lowercase characters, numbers and '-'. Furthermore,
// the names must begin with a lowercase character, must not end
// with a '-', and must not contain consecutive dashes.
// 
// Similar to GConf, the default values in GSettings schemas can be
// localized, but the localized values are stored in gettext catalogs
// and looked up with the domain that is specified in the
// <tag class="attribute">gettext-domain</tag> attribute of the
// <tag class="starttag">schemalist</tag> or <tag class="starttag">schema</tag>
// elements and the category that is specified in the l10n attribute of the
// <tag class="starttag">key</tag> element.
// 
// GSettings uses schemas in a compact binary form that is created
// by the <link linkend="glib-compile-schemas">glib-compile-schemas</link>
// utility. The input is a schema description in an XML format that can be
// described by the following DTD:
// |[<xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/gschema.dtd"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include>]|
// 
// glib-compile-schemas expects schema files to have the extension <filename>.gschema.xml</filename>
// 
// At runtime, schemas are identified by their id (as specified
// in the <tag class="attribute">id</tag> attribute of the
// <tag class="starttag">schema</tag> element). The
// convention for schema ids is to use a dotted name, similar in
// style to a D-Bus bus name, e.g. "org.gnome.SessionManager". In particular,
// if the settings are for a specific service that owns a D-Bus bus name,
// the D-Bus bus name and schema id should match. For schemas which deal
// with settings not associated with one named application, the id should
// not use StudlyCaps, e.g. "org.gnome.font-rendering".
// 
// In addition to #GVariant types, keys can have types that have enumerated
// types. These can be described by a <tag class="starttag">choice</tag>,
// <tag class="starttag">enum</tag> or <tag class="starttag">flags</tag> element, see
// <xref linkend="schema-enumerated"/>. The underlying type of
// such a key is string, but you can use g_settings_get_enum(),
// g_settings_set_enum(), g_settings_get_flags(), g_settings_set_flags()
// access the numeric values corresponding to the string value of enum
// and flags keys.
// 
// <example id="schema-default-values"><title>Default values</title>
// <programlisting><![CDATA[
// <schemalist>
// <schema id="org.gtk.Test" path="/tests/" gettext-domain="test">
// 
// <key name="greeting" type="s">
// <default l10n="messages">"Hello, earthlings"</default>
// <summary>A greeting</summary>
// <description>
// Greeting of the invading martians
// </description>
// </key>
// 
// <key name="box" type="(ii)">
// <default>(20,30)</default>
// </key>
// 
// </schema>
// </schemalist>
// ]]></programlisting></example>
// 
// <example id="schema-enumerated"><title>Ranges, choices and enumerated types</title>
// <programlisting><![CDATA[
// <schemalist>
// 
// <enum id="org.gtk.Test.myenum">
// <value nick="first" value="1"/>
// <value nick="second" value="2"/>
// </enum>
// 
// <flags id="org.gtk.Test.myflags">
// <value nick="flag1" value="1"/>
// <value nick="flag2" value="2"/>
// <value nick="flag3" value="4"/>
// </flags>
// 
// <schema id="org.gtk.Test">
// 
// <key name="key-with-range" type="i">
// <range min="1" max="100"/>
// <default>10</default>
// </key>
// 
// <key name="key-with-choices" type="s">
// <choices>
// <choice value='Elisabeth'/>
// <choice value='Annabeth'/>
// <choice value='Joe'/>
// </choices>
// <aliases>
// <alias value='Anna' target='Annabeth'/>
// <alias value='Beth' target='Elisabeth'/>
// </aliases>
// <default>'Joe'</default>
// </key>
// 
// <key name='enumerated-key' enum='org.gtk.Test.myenum'>
// <default>'first'</default>
// </key>
// 
// <key name='flags-key' flags='org.gtk.Test.myflags'>
// <default>["flag1",flag2"]</default>
// </key>
// </schema>
// </schemalist>
// ]]></programlisting></example>
// 
// <refsect2>
// <title>Vendor overrides</title>
// <para>
// Default values are defined in the schemas that get installed by
// an application. Sometimes, it is necessary for a vendor or distributor
// to adjust these defaults. Since patching the XML source for the schema
// is inconvenient and error-prone,
// <link linkend="glib-compile-schemas">glib-compile-schemas</link> reads
// so-called 'vendor override' files. These are keyfiles in the same
// directory as the XML schema sources which can override default values.
// The schema id serves as the group name in the key file, and the values
// are expected in serialized GVariant form, as in the following example:
// <informalexample><programlisting>
// [org.gtk.Example]
// key1='string'
// key2=1.5
// </programlisting></informalexample>
// </para>
// <para>
// glib-compile-schemas expects schema files to have the extension
// <filename>.gschema.override</filename>
// </para>
// </refsect2>
// 
// <refsect2>
// <title>Binding</title>
// <para>
// A very convenient feature of GSettings lets you bind #GObject properties
// directly to settings, using g_settings_bind(). Once a GObject property
// has been bound to a setting, changes on either side are automatically
// propagated to the other side. GSettings handles details like
// mapping between GObject and GVariant types, and preventing infinite
// cycles.
// </para>
// <para>
// This makes it very easy to hook up a preferences dialog to the
// underlying settings. To make this even more convenient, GSettings
// looks for a boolean property with the name "sensitivity" and
// automatically binds it to the writability of the bound setting.
// If this 'magic' gets in the way, it can be suppressed with the
// #G_SETTINGS_BIND_NO_SENSITIVITY flag.
// </para>
// </refsect2>
struct Settings /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   SettingsPrivate* priv;


   // Creates a new #GSettings object with a given schema.
   // 
   // Signals on the newly created #GSettings object will be dispatched
   // via the thread-default #GMainContext in effect at the time of the
   // call to g_settings_new().  The new #GSettings will hold a reference
   // on the context.  See g_main_context_push_thread_default().
   // RETURNS: a new #GSettings object
   // <schema>: the name of the schema
   static Settings* /*new*/ new_(char* schema) {
      return g_settings_new(schema);
   }

   // Creates a new #GSettings object with a given schema and backend.
   // 
   // Creating a #GSettings object with a different backend allows accessing
   // settings from a database other than the usual one. For example, it may make
   // sense to pass a backend corresponding to the "defaults" settings database on
   // the system to get a settings object that modifies the system default
   // settings instead of the settings for this user.
   // RETURNS: a new #GSettings object
   // <schema>: the name of the schema
   // <backend>: the #GSettingsBackend to use
   static Settings* /*new*/ new_with_backend(char* schema, SettingsBackend* backend) {
      return g_settings_new_with_backend(schema, backend);
   }

   // Creates a new #GSettings object with a given schema, backend and
   // path.
   // 
   // This is a mix of g_settings_new_with_backend() and
   // g_settings_new_with_path().
   // RETURNS: a new #GSettings object
   // <schema>: the name of the schema
   // <backend>: the #GSettingsBackend to use
   // <path>: the path to use
   static Settings* /*new*/ new_with_backend_and_path(char* schema, SettingsBackend* backend, char* path) {
      return g_settings_new_with_backend_and_path(schema, backend, path);
   }

   // Creates a new #GSettings object with a given schema and path.
   // 
   // You only need to do this if you want to directly create a settings
   // object with a schema that doesn't have a specified path of its own.
   // That's quite rare.
   // 
   // It is a programmer error to call this function for a schema that
   // has an explicitly specified path.
   // RETURNS: a new #GSettings object
   // <schema>: the name of the schema
   // <path>: the path to use
   static Settings* /*new*/ new_with_path(char* schema, char* path) {
      return g_settings_new_with_path(schema, path);
   }

   // Gets a list of the relocatable #GSettings schemas installed on the
   // system.  These are schemas that do not provide their own path.  It is
   // usual to instantiate these schemas directly, but if you want to you
   // can use g_settings_new_with_path() to specify the path.
   // 
   // The output of this function, tTaken together with the output of
   // g_settings_list_schemas() represents the complete list of all
   // installed schemas.
   // 
   // #GSettings schemas that are available.  The list must not be
   // modified or freed.
   // RETURNS: a list of relocatable
   static char** list_relocatable_schemas() {
      return g_settings_list_relocatable_schemas();
   }

   // Gets a list of the #GSettings schemas installed on the system.  The
   // returned list is exactly the list of schemas for which you may call
   // g_settings_new() without adverse effects.
   // 
   // This function does not list the schemas that do not provide their own
   // paths (ie: schemas for which you must use
   // g_settings_new_with_path()).  See
   // g_settings_list_relocatable_schemas() for that.
   // 
   // schemas that are available.  The list must not be modified or
   // freed.
   // RETURNS: a list of #GSettings
   static char** list_schemas() {
      return g_settings_list_schemas();
   }

   // Ensures that all pending operations for the given are complete for
   // the default backend.
   // 
   // Writes made to a #GSettings are handled asynchronously.  For this
   // reason, it is very unlikely that the changes have it to disk by the
   // time g_settings_set() returns.
   // 
   // This call will block until all of the writes have made it to the
   // backend.  Since the mainloop is not running, no change notifications
   // will be dispatched during this call (but some may be queued by the
   // time the call is done).
   static void sync() {
      g_settings_sync();
   }

   // Removes an existing binding for @property on @object.
   // 
   // Note that bindings are automatically removed when the
   // object is finalized, so it is rarely necessary to call this
   // function.
   // <object>: the object
   // <property>: the property whose binding is removed
   static void unbind(void* object, char* property) {
      g_settings_unbind(object, property);
   }

   // Applies any changes that have been made to the settings.  This
   // function does nothing unless @settings is in 'delay-apply' mode;
   // see g_settings_delay().  In the normal case settings are always
   // applied immediately.
   void apply() {
      g_settings_apply(&this);
   }

   // Create a binding between the @key in the @settings object
   // and the property @property of @object.
   // 
   // The binding uses the default GIO mapping functions to map
   // between the settings and property values. These functions
   // handle booleans, numeric types and string types in a
   // straightforward way. Use g_settings_bind_with_mapping() if
   // you need a custom mapping, or map between types that are not
   // supported by the default mapping functions.
   // 
   // Unless the @flags include %G_SETTINGS_BIND_NO_SENSITIVITY, this
   // function also establishes a binding between the writability of
   // @key and the "sensitive" property of @object (if @object has
   // a boolean property by that name). See g_settings_bind_writable()
   // for more details about writable bindings.
   // 
   // Note that the lifecycle of the binding is tied to the object,
   // and that you can have only one binding per object property.
   // If you bind the same property twice on the same object, the second
   // binding overrides the first one.
   // <key>: the key to bind
   // <object>: a #GObject
   // <property>: the name of the property to bind
   // <flags>: flags for the binding
   void bind(char* key, GObject2.Object* object, char* property, SettingsBindFlags flags) {
      g_settings_bind(&this, key, object, property, flags);
   }

   // Unintrospectable method: bind_with_mapping() / g_settings_bind_with_mapping()
   // Create a binding between the @key in the @settings object
   // and the property @property of @object.
   // 
   // The binding uses the provided mapping functions to map between
   // settings and property values.
   // 
   // Note that the lifecycle of the binding is tied to the object,
   // and that you can have only one binding per object property.
   // If you bind the same property twice on the same object, the second
   // binding overrides the first one.
   // <key>: the key to bind
   // <object>: a #GObject
   // <property>: the name of the property to bind
   // <flags>: flags for the binding
   // <get_mapping>: a function that gets called to convert values from @settings to @object, or %NULL to use the default GIO mapping
   // <set_mapping>: a function that gets called to convert values from @object to @settings, or %NULL to use the default GIO mapping
   // <user_data>: data that gets passed to @get_mapping and @set_mapping
   // <destroy>: #GDestroyNotify function for @user_data
   void bind_with_mapping(char* key, GObject2.Object* object, char* property, SettingsBindFlags flags, SettingsBindGetMapping get_mapping, SettingsBindSetMapping set_mapping, void* user_data, GLib2.DestroyNotify destroy) {
      g_settings_bind_with_mapping(&this, key, object, property, flags, get_mapping, set_mapping, user_data, destroy);
   }

   // Create a binding between the writability of @key in the
   // @settings object and the property @property of @object.
   // The property must be boolean; "sensitive" or "visible"
   // properties of widgets are the most likely candidates.
   // 
   // Writable bindings are always uni-directional; changes of the
   // writability of the setting will be propagated to the object
   // property, not the other way.
   // 
   // When the @inverted argument is %TRUE, the binding inverts the
   // value as it passes from the setting to the object, i.e. @property
   // will be set to %TRUE if the key is <emphasis>not</emphasis>
   // writable.
   // 
   // Note that the lifecycle of the binding is tied to the object,
   // and that you can have only one binding per object property.
   // If you bind the same property twice on the same object, the second
   // binding overrides the first one.
   // <key>: the key to bind
   // <object>: a #GObject
   // <property>: the name of a boolean property to bind
   // <inverted>: whether to 'invert' the value
   void bind_writable(char* key, GObject2.Object* object, char* property, int inverted) {
      g_settings_bind_writable(&this, key, object, property, inverted);
   }

   // Changes the #GSettings object into 'delay-apply' mode. In this
   // mode, changes to @settings are not immediately propagated to the
   // backend, but kept locally until g_settings_apply() is called.
   void delay() {
      g_settings_delay(&this);
   }

   // Unintrospectable method: get() / g_settings_get()
   // Gets the value that is stored at @key in @settings.
   // 
   // A convenience function that combines g_settings_get_value() with
   // g_variant_get().
   // 
   // It is a programmer error to give a @key that isn't contained in the
   // schema for @settings or for the #GVariantType of @format to mismatch
   // the type given in the schema.
   // <key>: the key to get the value for
   // <format>: a #GVariant format string
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_settings_get get; // Variadic
   +/

   // Gets the value that is stored at @key in @settings.
   // 
   // A convenience variant of g_settings_get() for booleans.
   // 
   // It is a programmer error to give a @key that isn't specified as
   // having a boolean type in the schema for @settings.
   // RETURNS: a boolean
   // <key>: the key to get the value for
   int get_boolean(char* key) {
      return g_settings_get_boolean(&this, key);
   }

   // Creates a 'child' settings object which has a base path of
   // <replaceable>base-path</replaceable>/@name, where
   // <replaceable>base-path</replaceable> is the base path of @settings.
   // 
   // The schema for the child settings object must have been declared
   // in the schema of @settings using a <tag class="starttag">child</tag> element.
   // RETURNS: a 'child' settings object
   // <name>: the name of the 'child' schema
   Settings* /*new*/ get_child(char* name) {
      return g_settings_get_child(&this, name);
   }

   // Gets the value that is stored at @key in @settings.
   // 
   // A convenience variant of g_settings_get() for doubles.
   // 
   // It is a programmer error to give a @key that isn't specified as
   // having a 'double' type in the schema for @settings.
   // RETURNS: a double
   // <key>: the key to get the value for
   double get_double(char* key) {
      return g_settings_get_double(&this, key);
   }

   // Gets the value that is stored in @settings for @key and converts it
   // to the enum value that it represents.
   // 
   // In order to use this function the type of the value must be a string
   // and it must be marked in the schema file as an enumerated type.
   // 
   // It is a programmer error to give a @key that isn't contained in the
   // schema for @settings or is not marked as an enumerated type.
   // 
   // If the value stored in the configuration database is not a valid
   // value for the enumerated type then this function will return the
   // default value.
   // RETURNS: the enum value
   // <key>: the key to get the value for
   int get_enum(char* key) {
      return g_settings_get_enum(&this, key);
   }

   // Gets the value that is stored in @settings for @key and converts it
   // to the flags value that it represents.
   // 
   // In order to use this function the type of the value must be an array
   // of strings and it must be marked in the schema file as an flags type.
   // 
   // It is a programmer error to give a @key that isn't contained in the
   // schema for @settings or is not marked as a flags type.
   // 
   // If the value stored in the configuration database is not a valid
   // value for the flags type then this function will return the default
   // value.
   // RETURNS: the flags value
   // <key>: the key to get the value for
   uint get_flags(char* key) {
      return g_settings_get_flags(&this, key);
   }

   // Returns whether the #GSettings object has any unapplied
   // changes.  This can only be the case if it is in 'delayed-apply' mode.
   // RETURNS: %TRUE if @settings has unapplied changes
   int get_has_unapplied() {
      return g_settings_get_has_unapplied(&this);
   }

   // Gets the value that is stored at @key in @settings.
   // 
   // A convenience variant of g_settings_get() for 32-bit integers.
   // 
   // It is a programmer error to give a @key that isn't specified as
   // having a int32 type in the schema for @settings.
   // RETURNS: an integer
   // <key>: the key to get the value for
   int get_int(char* key) {
      return g_settings_get_int(&this, key);
   }

   // Gets the value that is stored at @key in @settings, subject to
   // application-level validation/mapping.
   // 
   // You should use this function when the application needs to perform
   // some processing on the value of the key (for example, parsing).  The
   // @mapping function performs that processing.  If the function
   // indicates that the processing was unsuccessful (due to a parse error,
   // for example) then the mapping is tried again with another value.
   // This allows a robust 'fall back to defaults' behaviour to be
   // implemented somewhat automatically.
   // 
   // The first value that is tried is the user's setting for the key.  If
   // the mapping function fails to map this value, other values may be
   // tried in an unspecified order (system or site defaults, translated
   // schema default values, untranslated schema default values, etc).
   // 
   // If the mapping function fails for all possible values, one additional
   // attempt is made: the mapping function is called with a %NULL value.
   // If the mapping function still indicates failure at this point then
   // the application will be aborted.
   // 
   // The result parameter for the @mapping function is pointed to a
   // #gpointer which is initially set to %NULL.  The same pointer is given
   // to each invocation of @mapping.  The final value of that #gpointer is
   // what is returned by this function.  %NULL is valid; it is returned
   // just as any other value would be.
   // RETURNS: the result, which may be %NULL
   // <key>: the key to get the value for
   // <mapping>: the function to map the value in the settings database to the value used by the application
   // <user_data>: user data for @mapping
   void* /*new*/ get_mapped(char* key, SettingsGetMapping mapping, void* user_data) {
      return g_settings_get_mapped(&this, key, mapping, user_data);
   }

   // Queries the range of a key.
   // 
   // This function will return a #GVariant that fully describes the range
   // of values that are valid for @key.
   // 
   // The type of #GVariant returned is <literal>(sv)</literal>.  The
   // string describes the type of range restriction in effect.  The type
   // and meaning of the value contained in the variant depends on the
   // string.
   // 
   // If the string is <literal>'type'</literal> then the variant contains
   // an empty array.  The element type of that empty array is the expected
   // type of value and all values of that type are valid.
   // 
   // If the string is <literal>'enum'</literal> then the variant contains
   // an array enumerating the possible values.  Each item in the array is
   // a possible valid value and no other values are valid.
   // 
   // If the string is <literal>'flags'</literal> then the variant contains
   // an array.  Each item in the array is a value that may appear zero or
   // one times in an array to be used as the value for this key.  For
   // example, if the variant contained the array <literal>['x',
   // 'y']</literal> then the valid values for the key would be
   // <literal>[]</literal>, <literal>['x']</literal>,
   // <literal>['y']</literal>, <literal>['x', 'y']</literal> and
   // <literal>['y', 'x']</literal>.
   // 
   // Finally, if the string is <literal>'range'</literal> then the variant
   // contains a pair of like-typed values -- the minimum and maximum
   // permissible values for this key.
   // 
   // This information should not be used by normal programs.  It is
   // considered to be a hint for introspection purposes.  Normal programs
   // should already know what is permitted by their own schema.  The
   // format may change in any way in the future -- but particularly, new
   // forms may be added to the possibilities described above.
   // 
   // It is a programmer error to give a @key that isn't contained in the
   // schema for @settings.
   // 
   // You should free the returned value with g_variant_unref() when it is
   // no longer needed.
   // RETURNS: a #GVariant describing the range
   // <key>: the key to query the range of
   GLib2.Variant* /*new*/ get_range(char* key) {
      return g_settings_get_range(&this, key);
   }

   // Gets the value that is stored at @key in @settings.
   // 
   // A convenience variant of g_settings_get() for strings.
   // 
   // It is a programmer error to give a @key that isn't specified as
   // having a string type in the schema for @settings.
   // RETURNS: a newly-allocated string
   // <key>: the key to get the value for
   char* /*new*/ get_string(char* key) {
      return g_settings_get_string(&this, key);
   }

   // A convenience variant of g_settings_get() for string arrays.
   // 
   // It is a programmer error to give a @key that isn't specified as
   // having an array of strings type in the schema for @settings.
   // RETURNS: a newly-allocated, %NULL-terminated array of strings, the value that is stored at @key in @settings.
   // <key>: the key to get the value for
   char** /*new*/ get_strv(char* key) {
      return g_settings_get_strv(&this, key);
   }

   // Gets the value that is stored at @key in @settings.
   // 
   // A convenience variant of g_settings_get() for 32-bit unsigned
   // integers.
   // 
   // It is a programmer error to give a @key that isn't specified as
   // having a uint32 type in the schema for @settings.
   // RETURNS: an unsigned integer
   // <key>: the key to get the value for
   uint get_uint(char* key) {
      return g_settings_get_uint(&this, key);
   }

   // Gets the value that is stored in @settings for @key.
   // 
   // It is a programmer error to give a @key that isn't contained in the
   // schema for @settings.
   // RETURNS: a new #GVariant
   // <key>: the key to get the value for
   GLib2.Variant* /*new*/ get_value(char* key) {
      return g_settings_get_value(&this, key);
   }

   // Finds out if a key can be written or not
   // RETURNS: %TRUE if the key @name is writable
   // <name>: the name of a key
   int is_writable(char* name) {
      return g_settings_is_writable(&this, name);
   }

   // Gets the list of children on @settings.
   // 
   // The list is exactly the list of strings for which it is not an error
   // to call g_settings_get_child().
   // 
   // For GSettings objects that are lists, this value can change at any
   // time and you should connect to the "children-changed" signal to watch
   // for those changes.  Note that there is a race condition here: you may
   // request a child after listing it only for it to have been destroyed
   // in the meantime.  For this reason, g_settings_get_child() may return
   // %NULL even for a child that was listed by this function.
   // 
   // For GSettings objects that are not lists, you should probably not be
   // calling this function from "normal" code (since you should already
   // know what children are in your schema).  This function may still be
   // useful there for introspection reasons, however.
   // 
   // You should free the return value with g_strfreev() when you are done
   // with it.
   // RETURNS: a list of the children on @settings
   char** /*new*/ list_children() {
      return g_settings_list_children(&this);
   }

   // Introspects the list of keys on @settings.
   // 
   // You should probably not be calling this function from "normal" code
   // (since you should already know what keys are in your schema).  This
   // function is intended for introspection reasons.
   // 
   // You should free the return value with g_strfreev() when you are done
   // with it.
   // RETURNS: a list of the keys on @settings
   char** /*new*/ list_keys() {
      return g_settings_list_keys(&this);
   }

   // Checks if the given @value is of the correct type and within the
   // permitted range for @key.
   // 
   // This API is not intended to be used by normal programs -- they should
   // already know what is permitted by their own schemas.  This API is
   // meant to be used by programs such as editors or commandline tools.
   // 
   // It is a programmer error to give a @key that isn't contained in the
   // schema for @settings.
   // RETURNS: %TRUE if @value is valid for @key
   // <key>: the key to check
   // <value>: the value to check
   int range_check(char* key, GLib2.Variant* value) {
      return g_settings_range_check(&this, key, value);
   }

   // Resets @key to its default value.
   // 
   // This call resets the key, as much as possible, to its default value.
   // That might the value specified in the schema or the one set by the
   // administrator.
   // <key>: the name of a key
   void reset(char* key) {
      g_settings_reset(&this, key);
   }

   // Reverts all non-applied changes to the settings.  This function
   // does nothing unless @settings is in 'delay-apply' mode; see
   // g_settings_delay().  In the normal case settings are always applied
   // immediately.
   // 
   // Change notifications will be emitted for affected keys.
   void revert() {
      g_settings_revert(&this);
   }

   // Unintrospectable method: set() / g_settings_set()
   // Sets @key in @settings to @value.
   // 
   // A convenience function that combines g_settings_set_value() with
   // g_variant_new().
   // 
   // It is a programmer error to give a @key that isn't contained in the
   // schema for @settings or for the #GVariantType of @format to mismatch
   // the type given in the schema.
   // RETURNS: %TRUE if setting the key succeeded, %FALSE if the key was not writable
   // <key>: the name of the key to set
   // <format>: a #GVariant format string
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_settings_set set; // Variadic
   +/

   // Sets @key in @settings to @value.
   // 
   // A convenience variant of g_settings_set() for booleans.
   // 
   // It is a programmer error to give a @key that isn't specified as
   // having a boolean type in the schema for @settings.
   // RETURNS: %TRUE if setting the key succeeded, %FALSE if the key was not writable
   // <key>: the name of the key to set
   // <value>: the value to set it to
   int set_boolean(char* key, int value) {
      return g_settings_set_boolean(&this, key, value);
   }

   // Sets @key in @settings to @value.
   // 
   // A convenience variant of g_settings_set() for doubles.
   // 
   // It is a programmer error to give a @key that isn't specified as
   // having a 'double' type in the schema for @settings.
   // RETURNS: %TRUE if setting the key succeeded, %FALSE if the key was not writable
   // <key>: the name of the key to set
   // <value>: the value to set it to
   int set_double(char* key, double value) {
      return g_settings_set_double(&this, key, value);
   }

   // Looks up the enumerated type nick for @value and writes it to @key,
   // within @settings.
   // 
   // It is a programmer error to give a @key that isn't contained in the
   // schema for @settings or is not marked as an enumerated type, or for
   // @value not to be a valid value for the named type.
   // 
   // After performing the write, accessing @key directly with
   // g_settings_get_string() will return the 'nick' associated with
   // @value.
   // RETURNS: %TRUE, if the set succeeds
   // <key>: a key, within @settings
   // <value>: an enumerated value
   int set_enum(char* key, int value) {
      return g_settings_set_enum(&this, key, value);
   }

   // Looks up the flags type nicks for the bits specified by @value, puts
   // them in an array of strings and writes the array to @key, within
   // @settings.
   // 
   // It is a programmer error to give a @key that isn't contained in the
   // schema for @settings or is not marked as a flags type, or for @value
   // to contain any bits that are not value for the named type.
   // 
   // After performing the write, accessing @key directly with
   // g_settings_get_strv() will return an array of 'nicks'; one for each
   // bit in @value.
   // RETURNS: %TRUE, if the set succeeds
   // <key>: a key, within @settings
   // <value>: a flags value
   int set_flags(char* key, uint value) {
      return g_settings_set_flags(&this, key, value);
   }

   // Sets @key in @settings to @value.
   // 
   // A convenience variant of g_settings_set() for 32-bit integers.
   // 
   // It is a programmer error to give a @key that isn't specified as
   // having a int32 type in the schema for @settings.
   // RETURNS: %TRUE if setting the key succeeded, %FALSE if the key was not writable
   // <key>: the name of the key to set
   // <value>: the value to set it to
   int set_int(char* key, int value) {
      return g_settings_set_int(&this, key, value);
   }

   // Sets @key in @settings to @value.
   // 
   // A convenience variant of g_settings_set() for strings.
   // 
   // It is a programmer error to give a @key that isn't specified as
   // having a string type in the schema for @settings.
   // RETURNS: %TRUE if setting the key succeeded, %FALSE if the key was not writable
   // <key>: the name of the key to set
   // <value>: the value to set it to
   int set_string(char* key, char* value) {
      return g_settings_set_string(&this, key, value);
   }

   // Sets @key in @settings to @value.
   // 
   // A convenience variant of g_settings_set() for string arrays.  If
   // @value is %NULL, then @key is set to be the empty array.
   // 
   // It is a programmer error to give a @key that isn't specified as
   // having an array of strings type in the schema for @settings.
   // RETURNS: %TRUE if setting the key succeeded, %FALSE if the key was not writable
   // <key>: the name of the key to set
   // <value>: the value to set it to, or %NULL
   int set_strv(char* key, char** value=null) {
      return g_settings_set_strv(&this, key, value);
   }

   // Sets @key in @settings to @value.
   // 
   // A convenience variant of g_settings_set() for 32-bit unsigned
   // integers.
   // 
   // It is a programmer error to give a @key that isn't specified as
   // having a uint32 type in the schema for @settings.
   // RETURNS: %TRUE if setting the key succeeded, %FALSE if the key was not writable
   // <key>: the name of the key to set
   // <value>: the value to set it to
   int set_uint(char* key, uint value) {
      return g_settings_set_uint(&this, key, value);
   }

   // Sets @key in @settings to @value.
   // 
   // It is a programmer error to give a @key that isn't contained in the
   // schema for @settings or for @value to have the incorrect type, per
   // the schema.
   // 
   // If @value is floating then this function consumes the reference.
   // RETURNS: %TRUE if setting the key succeeded, %FALSE if the key was not writable
   // <key>: the name of the key to set
   // <value>: a #GVariant of the correct type
   int set_value(char* key, GLib2.Variant* value) {
      return g_settings_set_value(&this, key, value);
   }

   // The "change-event" signal is emitted once per change event that
   // affects this settings object.  You should connect to this signal
   // only if you are interested in viewing groups of changes before they
   // are split out into multiple emissions of the "changed" signal.
   // For most use cases it is more appropriate to use the "changed" signal.
   // 
   // In the event that the change event applies to one or more specified
   // keys, @keys will be an array of #GQuark of length @n_keys.  In the
   // event that the change event applies to the #GSettings object as a
   // whole (ie: potentially every key has been changed) then @keys will
   // be %NULL and @n_keys will be 0.
   // 
   // The default handler for this signal invokes the "changed" signal
   // for each affected key.  If any other connected handler returns
   // %TRUE then this default functionality will be suppressed.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
   // <keys>: an array of #GQuark<!-- -->s for the changed keys, or %NULL
   // <n_keys>: the length of the @keys array, or 0
   extern (C) alias static c_int function (Settings* this_, GLib2.Quark* keys, int n_keys, void* user_data=null) signal_change_event;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"change-event", CB:signal_change_event)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"change-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The "changed" signal is emitted when a key has potentially changed.
   // You should call one of the g_settings_get() calls to check the new
   // value.
   // 
   // This signal supports detailed connections.  You can connect to the
   // detailed signal "changed::x" in order to only receive callbacks
   // when key "x" changes.
   // <key>: the name of the key that changed
   extern (C) alias static void function (Settings* this_, char* key, void* user_data=null) signal_changed;
   ulong signal_connect(string name:"changed", CB:signal_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The "writable-change-event" signal is emitted once per writability
   // change event that affects this settings object.  You should connect
   // to this signal if you are interested in viewing groups of changes
   // before they are split out into multiple emissions of the
   // "writable-changed" signal.  For most use cases it is more
   // appropriate to use the "writable-changed" signal.
   // 
   // In the event that the writability change applies only to a single
   // key, @key will be set to the #GQuark for that key.  In the event
   // that the writability change affects the entire settings object,
   // @key will be 0.
   // 
   // The default handler for this signal invokes the "writable-changed"
   // and "changed" signals for each affected key.  This is done because
   // changes in writability might also imply changes in value (if for
   // example, a new mandatory setting is introduced).  If any other
   // connected handler returns %TRUE then this default functionality
   // will be suppressed.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
   // <key>: the quark of the key, or 0
   extern (C) alias static c_int function (Settings* this_, c_uint key, void* user_data=null) signal_writable_change_event;
   ulong signal_connect(string name:"writable-change-event", CB:signal_writable_change_event)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"writable-change-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The "writable-changed" signal is emitted when the writability of a
   // key has potentially changed.  You should call
   // g_settings_is_writable() in order to determine the new status.
   // 
   // This signal supports detailed connections.  You can connect to the
   // detailed signal "writable-changed::x" in order to only receive
   // callbacks when the writability of "x" changes.
   // <key>: the key
   extern (C) alias static void function (Settings* this_, char* key, void* user_data=null) signal_writable_changed;
   ulong signal_connect(string name:"writable-changed", CB:signal_writable_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"writable-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}


// The #GSettingsBackend interface defines a generic interface for
// non-strictly-typed data that is stored in a hierarchy. To implement
// an alternative storage backend for #GSettings, you need to implement
// the #GSettingsBackend interface and then make it implement the
// extension point #G_SETTINGS_BACKEND_EXTENSION_POINT_NAME.
// 
// The interface defines methods for reading and writing values, a
// method for determining if writing of certain values will fail
// (lockdown) and a change notification mechanism.
// 
// The semantics of the interface are very precisely defined and
// implementations must carefully adhere to the expectations of
// callers that are documented on each of the interface methods.
// 
// Some of the GSettingsBackend functions accept or return a #GTree.
// These trees always have strings as keys and #GVariant as values.
// g_settings_backend_create_tree() is a convenience function to create
// suitable trees.
// 
// <note><para>
// The #GSettingsBackend API is exported to allow third-party
// implementations, but does not carry the same stability guarantees
// as the public GIO API. For this reason, you have to define the
// C preprocessor symbol #G_SETTINGS_ENABLE_BACKEND before including
// <filename>gio/gsettingsbackend.h</filename>
// </para></note>
struct SettingsBackend {
}


// Flags used when creating a binding. These flags determine in which
// direction the binding works. The default is to synchronize in both
// directions.
enum SettingsBindFlags {
   DEFAULT = 0,
   GET = 1,
   SET = 2,
   NO_SENSITIVITY = 4,
   GET_NO_CHANGES = 8,
   INVERT_BOOLEAN = 16
}

// The type for the function that is used to convert from #GSettings to
// an object property. The @value is already initialized to hold values
// of the appropriate type.
// RETURNS: %TRUE if the conversion succeeded, %FALSE in case of an error
// <value>: return location for the property value
// <variant>: the #GVariant
// <user_data>: user data that was specified when the binding was created
extern (C) alias int function (GObject2.Value* value, GLib2.Variant* variant, void* user_data) SettingsBindGetMapping;


// The type for the function that is used to convert an object property
// value to a #GVariant for storing it in #GSettings.
// RETURNS: a new #GVariant holding the data from @value, or %NULL in case of an error
// <value>: a #GValue containing the property value to map
// <expected_type>: the #GVariantType to create
// <user_data>: user data that was specified when the binding was created
extern (C) alias GLib2.Variant* /*new*/ function (GObject2.Value* value, GLib2.VariantType* expected_type, void* user_data) SettingsBindSetMapping;

struct SettingsClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (Settings* settings, char* key) writable_changed;
   extern (C) void function (Settings* settings, char* key) changed;
   extern (C) int function (Settings* settings, GLib2.Quark key) writable_change_event;
   extern (C) int function (Settings* settings, GLib2.Quark* keys, int n_keys) change_event;
   void*[20] padding;
}


// The type of the function that is used to convert from a value stored
// in a #GSettings to a value that is useful to the application.
// 
// If the value is successfully mapped, the result should be stored at
// @result and %TRUE returned.  If mapping fails (for example, if @value
// is not in the right format) then %FALSE should be returned.
// 
// If @value is %NULL then it means that the mapping function is being
// given a "last chance" to successfully return a valid value.  %TRUE
// must be returned in this case.
// RETURNS: %TRUE if the conversion succeeded, %FALSE in case of an error
// <value>: the #GVariant to map, or %NULL
// <result>: the result of the mapping
// <user_data>: the user data that was passed to g_settings_get_mapped()
extern (C) alias int function (GLib2.Variant* value, /*out*/ void** result, void* user_data) SettingsGetMapping;

struct SettingsPrivate {
}


// A #GSimpleAction is the obvious simple implementation of the #GAction
// interface.  This is the easiest way to create an action for purposes of
// adding it to a #GSimpleActionGroup.
// 
// See also #GtkAction.
struct SimpleAction /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new action.
   // 
   // The created action is stateless.  See g_simple_action_new_stateful().
   // RETURNS: a new #GSimpleAction
   // <name>: the name of the action
   // <parameter_type>: the type of parameter to the activate function
   static SimpleAction* /*new*/ new_(char* name, GLib2.VariantType* parameter_type=null) {
      return g_simple_action_new(name, parameter_type);
   }

   // Creates a new stateful action.
   // 
   // @state is the initial state of the action.  All future state values
   // must have the same #GVariantType as the initial state.
   // 
   // If the @state GVariant is floating, it is consumed.
   // RETURNS: a new #GSimpleAction
   // <name>: the name of the action
   // <parameter_type>: the type of the parameter to the activate function
   // <state>: the initial state of the action
   static SimpleAction* /*new*/ new_stateful(char* name, GLib2.VariantType* parameter_type, GLib2.Variant* state) {
      return g_simple_action_new_stateful(name, parameter_type, state);
   }

   // Sets the action as enabled or not.
   // 
   // An action must be enabled in order to be activated or in order to
   // have its state changed from outside callers.
   // 
   // This should only be called by the implementor of the action.  Users
   // of the action should not attempt to modify its enabled flag.
   // <enabled>: whether the action is enabled
   void set_enabled(int enabled) {
      g_simple_action_set_enabled(&this, enabled);
   }

   // Sets the state of the action.
   // 
   // This directly updates the 'state' property to the given value.
   // 
   // This should only be called by the implementor of the action.  Users
   // of the action should not attempt to directly modify the 'state'
   // property.  Instead, they should call g_action_change_state() to
   // request the change.
   // <value>: the new #GVariant for the state
   void set_state(GLib2.Variant* value) {
      g_simple_action_set_state(&this, value);
   }

   // Indicates that the action was just activated.
   // 
   // @parameter will always be of the expected type.  In the event that
   // an incorrect type was given, no signal will be emitted.
   // <parameter>: the parameter to the activation
   extern (C) alias static void function (SimpleAction* this_, GLib2.Variant* parameter=null, void* user_data=null) signal_activate;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"activate", CB:signal_activate)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"activate",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Indicates that the action just received a request to change its
   // state.
   // 
   // @value will always be of the correct state type.  In the event that
   // an incorrect type was given, no signal will be emitted.
   // 
   // If no handler is connected to this signal then the default
   // behaviour is to call g_simple_action_set_state() to set the state
   // to the requested value.  If you connect a signal handler then no
   // default action is taken.  If the state should change then you must
   // call g_simple_action_set_state() from the handler.
   // 
   // <example>
   // <title>Example 'change-state' handler</title>
   // <programlisting>
   // static void
   // change_volume_state (GSimpleAction *action,
   // GVariant      *value,
   // gpointer       user_data)
   // {
   // gint requested;
   // 
   // requested = g_variant_get_int32 (value);
   // 
   // // Volume only goes from 0 to 10
   // if (0 <= requested && requested <= 10)
   // g_simple_action_set_state (action, value);
   // }
   // </programlisting>
   // </example>
   // 
   // The handler need not set the state to the requested value.  It
   // could set it to any value at all, or take some other action.
   // <value>: the requested value for the state
   extern (C) alias static void function (SimpleAction* this_, GLib2.Variant* value=null, void* user_data=null) signal_change_state;
   ulong signal_connect(string name:"change-state", CB:signal_change_state)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"change-state",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}


// #GSimpleActionGroup is a hash table filled with #GAction objects,
// implementing the #GActionGroup interface.
struct SimpleActionGroup /* : GObject.Object */ /* Version 2.28 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private SimpleActionGroupPrivate* priv;


   // Creates a new, empty, #GSimpleActionGroup.
   // RETURNS: a new #GSimpleActionGroup
   static SimpleActionGroup* /*new*/ new_() {
      return g_simple_action_group_new();
   }

   // A convenience function for creating multiple #GSimpleAction instances
   // and adding them to the action group.
   // 
   // Each action is constructed as per one #GActionEntry.
   // 
   // <example>
   // <title>Using g_simple_action_group_add_entries()</title>
   // <programlisting>
   // static void
   // activate_quit (GSimpleAction *simple,
   // GVariant      *parameter,
   // gpointer       user_data)
   // {
   // exit (0);
   // }
   // 
   // static void
   // activate_print_string (GSimpleAction *simple,
   // GVariant      *parameter,
   // gpointer       user_data)
   // {
   // g_print ("%s\n", g_variant_get_string (parameter, NULL));
   // }
   // 
   // static GActionGroup *
   // create_action_group (void)
   // {
   // const GActionEntry entries[] = {
   // { "quit",         activate_quit              },
   // { "print-string", activate_print_string, "s" }
   // };
   // GSimpleActionGroup *group;
   // 
   // group = g_simple_action_group_new ();
   // g_simple_action_group_add_entries (group, entries, G_N_ELEMENTS (entries), NULL);
   // 
   // return G_ACTION_GROUP (group);
   // }
   // </programlisting>
   // </example>
   // <entries>: a pointer to the first item in an array of #GActionEntry structs
   // <n_entries>: the length of @entries, or -1
   // <user_data>: the user data for signal connections
   void add_entries(ActionEntry* entries, int n_entries, void* user_data) {
      g_simple_action_group_add_entries(&this, entries, n_entries, user_data);
   }

   // Adds an action to the action group.
   // 
   // If the action group already contains an action with the same name as
   // @action then the old action is dropped from the group.
   // 
   // The action group takes its own reference on @action.
   // <action>: a #GAction
   void insert(Action* action) {
      g_simple_action_group_insert(&this, action);
   }

   // Looks up the action with the name @action_name in the group.
   // 
   // If no such action exists, returns %NULL.
   // RETURNS: a #GAction, or %NULL
   // <action_name>: the name of an action
   Action* lookup(char* action_name) {
      return g_simple_action_group_lookup(&this, action_name);
   }

   // Removes the named action from the action group.
   // 
   // If no action of this name is in the group then nothing happens.
   // <action_name>: the name of the action
   void remove(char* action_name) {
      g_simple_action_group_remove(&this, action_name);
   }
}

struct SimpleActionGroupClass {
   private GObject2.ObjectClass parent_class;
   private void*[12] padding;
}

struct SimpleActionGroupPrivate {
}


// Implements #GAsyncResult for simple cases. Most of the time, this
// will be all an application needs, and will be used transparently.
// Because of this, #GSimpleAsyncResult is used throughout GIO for
// handling asynchronous functions.
// 
// GSimpleAsyncResult handles #GAsyncReadyCallback<!-- -->s, error
// reporting, operation cancellation and the final state of an operation,
// completely transparent to the application. Results can be returned
// as a pointer e.g. for functions that return data that is collected
// asynchronously, a boolean value for checking the success or failure
// of an operation, or a #gssize for operations which return the number
// of bytes modified by the operation; all of the simple return cases
// are covered.
// 
// Most of the time, an application will not need to know of the details
// of this API; it is handled transparently, and any necessary operations
// are handled by #GAsyncResult's interface. However, if implementing a
// new GIO module, for writing language bindings, or for complex
// applications that need better control of how asynchronous operations
// are completed, it is important to understand this functionality.
// 
// GSimpleAsyncResults are tagged with the calling function to ensure
// that asynchronous functions and their finishing functions are used
// together correctly.
// 
// To create a new #GSimpleAsyncResult, call g_simple_async_result_new().
// If the result needs to be created for a #GError, use
// g_simple_async_result_new_from_error() or
// g_simple_async_result_new_take_error(). If a #GError is not available
// (e.g. the asynchronous operation's doesn't take a #GError argument),
// but the result still needs to be created for an error condition, use
// g_simple_async_result_new_error() (or g_simple_async_result_set_error_va()
// if your application or binding requires passing a variable argument list
// directly), and the error can then be propagated through the use of
// g_simple_async_result_propagate_error().
// 
// An asynchronous operation can be made to ignore a cancellation event by
// calling g_simple_async_result_set_handle_cancellation() with a
// #GSimpleAsyncResult for the operation and %FALSE. This is useful for
// operations that are dangerous to cancel, such as close (which would
// cause a leak if cancelled before being run).
// 
// GSimpleAsyncResult can integrate into GLib's event loop, #GMainLoop,
// or it can use #GThread<!-- -->s if available.
// g_simple_async_result_complete() will finish an I/O task directly
// from the point where it is called. g_simple_async_result_complete_in_idle()
// will finish it from an idle handler in the <link
// linkend="g-main-context-push-thread-default">thread-default main
// context</link>. g_simple_async_result_run_in_thread() will run the
// job in a separate thread and then deliver the result to the
// thread-default main context.
// 
// To set the results of an asynchronous function,
// g_simple_async_result_set_op_res_gpointer(),
// g_simple_async_result_set_op_res_gboolean(), and
// g_simple_async_result_set_op_res_gssize()
// are provided, setting the operation's result to a gpointer, gboolean, or
// gssize, respectively.
// 
// Likewise, to get the result of an asynchronous function,
// g_simple_async_result_get_op_res_gpointer(),
// g_simple_async_result_get_op_res_gboolean(), and
// g_simple_async_result_get_op_res_gssize() are
// provided, getting the operation's result as a gpointer, gboolean, and
// gssize, respectively.
// 
// For the details of the requirements implementations must respect, see
// #GAsyncResult.  A typical implementation of an asynchronous operation
// using GSimpleAsyncResult looks something like this:
// 
// |[
// static void
// baked_cb (Cake    *cake,
// gpointer user_data)
// {
// /&ast; In this example, this callback is not given a reference to the cake, so
// &ast; the GSimpleAsyncResult has to take a reference to it.
// &ast;/
// GSimpleAsyncResult *result = user_data;
// 
// if (cake == NULL)
// g_simple_async_result_set_error (result,
// BAKER_ERRORS,
// BAKER_ERROR_NO_FLOUR,
// "Go to the supermarket");
// else
// g_simple_async_result_set_op_res_gpointer (result,
// g_object_ref (cake),
// g_object_unref);
// 
// 
// /&ast; In this example, we assume that baked_cb is called as a callback from
// &ast; the mainloop, so it's safe to complete the operation synchronously here.
// &ast; If, however, _baker_prepare_cake () might call its callback without
// &ast; first returning to the mainloop — inadvisable, but some APIs do so —
// &ast; we would need to use g_simple_async_result_complete_in_idle().
// &ast;/
// g_simple_async_result_complete (result);
// g_object_unref (result);
// }
// 
// void
// baker_bake_cake_async (Baker              *self,
// guint               radius,
// GAsyncReadyCallback callback,
// gpointer            user_data)
// {
// GSimpleAsyncResult *simple;
// Cake               *cake;
// 
// if (radius < 3)
// {
// g_simple_async_report_error_in_idle (G_OBJECT (self),
// callback,
// user_data,
// BAKER_ERRORS,
// BAKER_ERROR_TOO_SMALL,
// "%ucm radius cakes are silly",
// radius);
// return;
// }
// 
// simple = g_simple_async_result_new (G_OBJECT (self),
// callback,
// user_data,
// baker_bake_cake_async);
// cake = _baker_get_cached_cake (self, radius);
// 
// if (cake != NULL)
// {
// g_simple_async_result_set_op_res_gpointer (simple,
// g_object_ref (cake),
// g_object_unref);
// g_simple_async_result_complete_in_idle (simple);
// g_object_unref (simple);
// /&ast; Drop the reference returned by _baker_get_cached_cake(); the
// &ast; GSimpleAsyncResult has taken its own reference.
// &ast;/
// g_object_unref (cake);
// return;
// }
// 
// _baker_prepare_cake (self, radius, baked_cb, simple);
// }
// 
// Cake *
// baker_bake_cake_finish (Baker        *self,
// GAsyncResult *result,
// GError      **error)
// {
// GSimpleAsyncResult *simple;
// Cake               *cake;
// 
// g_return_val_if_fail (g_simple_async_result_is_valid (result,
// G_OBJECT (self),
// baker_bake_cake_async),
// NULL);
// 
// simple = (GSimpleAsyncResult *) result;
// 
// if (g_simple_async_result_propagate_error (simple, error))
// return NULL;
// 
// cake = CAKE (g_simple_async_result_get_op_res_gpointer (simple));
// return g_object_ref (cake);
// }
// ]|
struct SimpleAsyncResult /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a #GSimpleAsyncResult.
   // RETURNS: a #GSimpleAsyncResult.
   // <source_object>: a #GObject, or %NULL.
   // <callback>: a #GAsyncReadyCallback.
   // <user_data>: user data passed to @callback.
   // <source_tag>: the asynchronous function.
   static SimpleAsyncResult* /*new*/ new_(GObject2.Object* source_object, AsyncReadyCallback callback, void* user_data, void* source_tag) {
      return g_simple_async_result_new(source_object, callback, user_data, source_tag);
   }

   // Unintrospectable constructor: new_error() / g_simple_async_result_new_error()
   // Creates a new #GSimpleAsyncResult with a set error.
   // RETURNS: a #GSimpleAsyncResult.
   // <source_object>: a #GObject, or %NULL.
   // <callback>: a #GAsyncReadyCallback.
   // <user_data>: user data passed to @callback.
   // <domain>: a #GQuark.
   // <code>: an error code.
   // <format>: a string with format characters.
   alias g_simple_async_result_new_error new_error; // Variadic

   // Creates a #GSimpleAsyncResult from an error condition.
   // RETURNS: a #GSimpleAsyncResult.
   // <source_object>: a #GObject, or %NULL.
   // <callback>: a #GAsyncReadyCallback.
   // <user_data>: user data passed to @callback.
   // <error>: a #GError
   static SimpleAsyncResult* /*new*/ new_from_error(GObject2.Object* source_object, AsyncReadyCallback callback, void* user_data, GLib2.Error* error) {
      return g_simple_async_result_new_from_error(source_object, callback, user_data, error);
   }

   // Unintrospectable constructor: new_take_error() / g_simple_async_result_new_take_error()
   // Creates a #GSimpleAsyncResult from an error condition, and takes over the
   // caller's ownership of @error, so the caller does not need to free it anymore.
   // RETURNS: a #GSimpleAsyncResult
   // <source_object>: a #GObject, or %NULL
   // <callback>: a #GAsyncReadyCallback
   // <user_data>: user data passed to @callback
   // <error>: a #GError
   static SimpleAsyncResult* /*new*/ new_take_error(GObject2.Object* source_object, AsyncReadyCallback callback, void* user_data, GLib2.Error* error) {
      return g_simple_async_result_new_take_error(source_object, callback, user_data, error);
   }

   // Ensures that the data passed to the _finish function of an async
   // operation is consistent.  Three checks are performed.
   // 
   // First, @result is checked to ensure that it is really a
   // #GSimpleAsyncResult.  Second, @source is checked to ensure that it
   // matches the source object of @result.  Third, @source_tag is
   // checked to ensure that it is either %NULL (as it is when the result was
   // created by g_simple_async_report_error_in_idle() or
   // g_simple_async_report_gerror_in_idle()) or equal to the
   // @source_tag argument given to g_simple_async_result_new() (which, by
   // convention, is a pointer to the _async function corresponding to the
   // _finish function from which this function is called).
   // RETURNS: #TRUE if all checks passed or #FALSE if any failed.
   // <result>: the #GAsyncResult passed to the _finish function.
   // <source>: the #GObject passed to the _finish function.
   // <source_tag>: the asynchronous function.
   static int is_valid(AsyncResult* result, GObject2.Object* source, void* source_tag) {
      return g_simple_async_result_is_valid(result, source, source_tag);
   }

   // Completes an asynchronous I/O job immediately. Must be called in
   // the thread where the asynchronous result was to be delivered, as it
   // invokes the callback directly. If you are in a different thread use
   // g_simple_async_result_complete_in_idle().
   // 
   // Calling this function takes a reference to @simple for as long as
   // is needed to complete the call.
   void complete() {
      g_simple_async_result_complete(&this);
   }

   // Completes an asynchronous function in an idle handler in the <link
   // linkend="g-main-context-push-thread-default">thread-default main
   // loop</link> of the thread that @simple was initially created in.
   // 
   // Calling this function takes a reference to @simple for as long as
   // is needed to complete the call.
   void complete_in_idle() {
      g_simple_async_result_complete_in_idle(&this);
   }

   // Gets the operation result boolean from within the asynchronous result.
   // 
   // if the operation's result was %FALSE.
   // RETURNS: %TRUE if the operation's result was %TRUE, %FALSE
   int get_op_res_gboolean() {
      return g_simple_async_result_get_op_res_gboolean(&this);
   }

   // Unintrospectable method: get_op_res_gpointer() / g_simple_async_result_get_op_res_gpointer()
   // Gets a pointer result as returned by the asynchronous function.
   // RETURNS: a pointer from the result.
   void* get_op_res_gpointer() {
      return g_simple_async_result_get_op_res_gpointer(&this);
   }

   // Gets a gssize from the asynchronous result.
   // RETURNS: a gssize returned from the asynchronous function.
   ssize_t get_op_res_gssize() {
      return g_simple_async_result_get_op_res_gssize(&this);
   }

   // Unintrospectable method: get_source_tag() / g_simple_async_result_get_source_tag()
   // Gets the source tag for the #GSimpleAsyncResult.
   // RETURNS: a #gpointer to the source object for the #GSimpleAsyncResult.
   void* get_source_tag() {
      return g_simple_async_result_get_source_tag(&this);
   }

   // Propagates an error from within the simple asynchronous result to
   // a given destination.
   // RETURNS: %TRUE if the error was propagated to @dest. %FALSE otherwise.
   int propagate_error(GLib2.Error** error=null) {
      return g_simple_async_result_propagate_error(&this, error);
   }

   // Unintrospectable method: run_in_thread() / g_simple_async_result_run_in_thread()
   // Runs the asynchronous job in a separate thread and then calls
   // g_simple_async_result_complete_in_idle() on @simple to return
   // the result to the appropriate main loop.
   // 
   // Calling this function takes a reference to @simple for as long as
   // is needed to run the job and report its completion.
   // <func>: a #GSimpleAsyncThreadFunc.
   // <io_priority>: the io priority of the request.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   void run_in_thread(SimpleAsyncThreadFunc func, int io_priority, Cancellable* cancellable=null) {
      g_simple_async_result_run_in_thread(&this, func, io_priority, cancellable);
   }

   // Unintrospectable method: set_error() / g_simple_async_result_set_error()
   // Sets an error within the asynchronous result without a #GError.
   // <domain>: a #GQuark (usually #G_IO_ERROR).
   // <code>: an error code.
   // <format>: a formatted error reporting string.
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_simple_async_result_set_error set_error; // Variadic
   +/

   // Unintrospectable method: set_error_va() / g_simple_async_result_set_error_va()
   // Sets an error within the asynchronous result without a #GError.
   // Unless writing a binding, see g_simple_async_result_set_error().
   // <domain>: a #GQuark (usually #G_IO_ERROR).
   // <code>: an error code.
   // <format>: a formatted error reporting string.
   // <args>: va_list of arguments.
   void set_error_va(GLib2.Quark domain, int code, char* format, va_list args) {
      g_simple_async_result_set_error_va(&this, domain, code, format, args);
   }

   // Sets the result from a #GError.
   // <error>: #GError.
   void set_from_error(GLib2.Error* error) {
      g_simple_async_result_set_from_error(&this, error);
   }

   // Sets whether to handle cancellation within the asynchronous operation.
   // <handle_cancellation>: a #gboolean.
   void set_handle_cancellation(int handle_cancellation) {
      g_simple_async_result_set_handle_cancellation(&this, handle_cancellation);
   }

   // Sets the operation result to a boolean within the asynchronous result.
   // <op_res>: a #gboolean.
   void set_op_res_gboolean(int op_res) {
      g_simple_async_result_set_op_res_gboolean(&this, op_res);
   }

   // Unintrospectable method: set_op_res_gpointer() / g_simple_async_result_set_op_res_gpointer()
   // Sets the operation result within the asynchronous result to a pointer.
   // <op_res>: a pointer result from an asynchronous function.
   // <destroy_op_res>: a #GDestroyNotify function.
   void set_op_res_gpointer(void* op_res, GLib2.DestroyNotify destroy_op_res) {
      g_simple_async_result_set_op_res_gpointer(&this, op_res, destroy_op_res);
   }

   // Sets the operation result within the asynchronous result to
   // the given @op_res.
   // <op_res>: a #gssize.
   void set_op_res_gssize(ssize_t op_res) {
      g_simple_async_result_set_op_res_gssize(&this, op_res);
   }

   // Unintrospectable method: take_error() / g_simple_async_result_take_error()
   // Sets the result from @error, and takes over the caller's ownership
   // of @error, so the caller does not need to free it any more.
   // <error>: a #GError
   void take_error(GLib2.Error* error) {
      g_simple_async_result_take_error(&this, error);
   }
}

struct SimpleAsyncResultClass {
}


// Simple thread function that runs an asynchronous operation and
// checks for cancellation.
// <res>: a #GSimpleAsyncResult.
// <object>: a #GObject.
// <cancellable>: optional #GCancellable object, %NULL to ignore.
extern (C) alias void function (SimpleAsyncResult* res, GObject2.Object* object, Cancellable* cancellable=null) SimpleAsyncThreadFunc;


// #GSimplePermission is a trivial implementation of #GPermission that
// represents a permission that is either always or never allowed.  The
// value is given at construction and doesn't change.
// 
// Calling request or release will result in errors.
struct SimplePermission /* : Permission */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent permission;
   Permission method_parent;


   // Creates a new #GPermission instance that represents an action that is
   // either always or never allowed.
   // RETURNS: the #GSimplePermission, as a #GPermission
   // <allowed>: %TRUE if the action is allowed
   static SimplePermission* /*new*/ new_(int allowed) {
      return g_simple_permission_new(allowed);
   }
}


// A #GSocket is a low-level networking primitive. It is a more or less
// direct mapping of the BSD socket API in a portable GObject based API.
// It supports both the UNIX socket implementations and winsock2 on Windows.
// 
// #GSocket is the platform independent base upon which the higher level
// network primitives are based. Applications are not typically meant to
// use it directly, but rather through classes like #GSocketClient,
// #GSocketService and #GSocketConnection. However there may be cases where
// direct use of #GSocket is useful.
// 
// #GSocket implements the #GInitable interface, so if it is manually constructed
// by e.g. g_object_new() you must call g_initable_init() and check the
// results before using the object. This is done automatically in
// g_socket_new() and g_socket_new_from_fd(), so these functions can return
// %NULL.
// 
// Sockets operate in two general modes, blocking or non-blocking. When
// in blocking mode all operations block until the requested operation
// is finished or there is an error. In non-blocking mode all calls that
// would block return immediately with a %G_IO_ERROR_WOULD_BLOCK error.
// To know when a call would successfully run you can call g_socket_condition_check(),
// or g_socket_condition_wait(). You can also use g_socket_create_source() and
// attach it to a #GMainContext to get callbacks when I/O is possible.
// Note that all sockets are always set to non blocking mode in the system, and
// blocking mode is emulated in GSocket.
// 
// When working in non-blocking mode applications should always be able to
// handle getting a %G_IO_ERROR_WOULD_BLOCK error even when some other
// function said that I/O was possible. This can easily happen in case
// of a race condition in the application, but it can also happen for other
// reasons. For instance, on Windows a socket is always seen as writable
// until a write returns %G_IO_ERROR_WOULD_BLOCK.
// 
// #GSocket<!-- -->s can be either connection oriented or datagram based.
// For connection oriented types you must first establish a connection by
// either connecting to an address or accepting a connection from another
// address. For connectionless socket types the target/source address is
// specified or received in each I/O operation.
// 
// All socket file descriptors are set to be close-on-exec.
// 
// Note that creating a #GSocket causes the signal %SIGPIPE to be
// ignored for the remainder of the program. If you are writing a
// command-line utility that uses #GSocket, you may need to take into
// account the fact that your program will not automatically be killed
// if it tries to write to %stdout after it has been closed.
struct Socket /* : GObject.Object */ /* Version 2.22 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   SocketPrivate* priv;


   // Creates a new #GSocket with the defined family, type and protocol.
   // If @protocol is 0 (%G_SOCKET_PROTOCOL_DEFAULT) the default protocol type
   // for the family and type is used.
   // 
   // The @protocol is a family and type specific int that specifies what
   // kind of protocol to use. #GSocketProtocol lists several common ones.
   // Many families only support one protocol, and use 0 for this, others
   // support several and using 0 means to use the default protocol for
   // the family and type.
   // 
   // The protocol id is passed directly to the operating
   // system, so you can use protocols not listed in #GSocketProtocol if you
   // know the protocol number used for it.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GSocket or %NULL on error.
   // <family>: the socket family to use, e.g. %G_SOCKET_FAMILY_IPV4.
   // <type>: the socket type to use.
   // <protocol>: the id of the protocol to use, or 0 for default.
   static Socket* /*new*/ new_(SocketFamily family, SocketType type, SocketProtocol protocol, GLib2.Error** error=null) {
      return g_socket_new(family, type, protocol, error);
   }

   // Creates a new #GSocket from a native file descriptor
   // or winsock SOCKET handle.
   // 
   // This reads all the settings from the file descriptor so that
   // all properties should work. Note that the file descriptor
   // will be set to non-blocking mode, independent on the blocking
   // mode of the #GSocket.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GSocket or %NULL on error.
   // <fd>: a native socket file descriptor.
   static Socket* /*new*/ new_from_fd(int fd, GLib2.Error** error=null) {
      return g_socket_new_from_fd(fd, error);
   }

   // Accept incoming connections on a connection-based socket. This removes
   // the first outstanding connection request from the listening socket and
   // creates a #GSocket object for it.
   // 
   // The @socket must be bound to a local address with g_socket_bind() and
   // must be listening for incoming connections (g_socket_listen()).
   // 
   // If there are no outstanding connections then the operation will block
   // or return %G_IO_ERROR_WOULD_BLOCK if non-blocking I/O is enabled.
   // To be notified of an incoming connection, wait for the %G_IO_IN condition.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a new #GSocket, or %NULL on error.
   // <cancellable>: a %GCancellable or %NULL
   Socket* /*new*/ accept(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_accept(&this, cancellable, error);
   }

   // When a socket is created it is attached to an address family, but it
   // doesn't have an address in this family. g_socket_bind() assigns the
   // address (sometimes called name) of the socket.
   // 
   // It is generally required to bind to a local address before you can
   // receive connections. (See g_socket_listen() and g_socket_accept() ).
   // In certain situations, you may also want to bind a socket that will be
   // used to initiate connections, though this is not normally required.
   // 
   // @allow_reuse should be %TRUE for server sockets (sockets that you will
   // eventually call g_socket_accept() on), and %FALSE for client sockets.
   // (Specifically, if it is %TRUE, then g_socket_bind() will set the
   // %SO_REUSEADDR flag on the socket, allowing it to bind @address even if
   // that address was previously used by another socket that has not yet been
   // fully cleaned-up by the kernel. Failing to set this flag on a server
   // socket may cause the bind call to return %G_IO_ERROR_ADDRESS_IN_USE if
   // the server program is stopped and then immediately restarted.)
   // RETURNS: %TRUE on success, %FALSE on error.
   // <address>: a #GSocketAddress specifying the local address.
   // <allow_reuse>: whether to allow reusing this address
   int bind(SocketAddress* address, int allow_reuse, GLib2.Error** error=null) {
      return g_socket_bind(&this, address, allow_reuse, error);
   }

   // Checks and resets the pending connect error for the socket.
   // This is used to check for errors when g_socket_connect() is
   // used in non-blocking mode.
   // RETURNS: %TRUE if no error, %FALSE otherwise, setting @error to the error
   int check_connect_result(GLib2.Error** error=null) {
      return g_socket_check_connect_result(&this, error);
   }

   // Closes the socket, shutting down any active connection.
   // 
   // Closing a socket does not wait for all outstanding I/O operations
   // to finish, so the caller should not rely on them to be guaranteed
   // to complete even if the close returns with no error.
   // 
   // Once the socket is closed, all other operations will return
   // %G_IO_ERROR_CLOSED. Closing a socket multiple times will not
   // return an error.
   // 
   // Sockets will be automatically closed when the last reference
   // is dropped, but you might want to call this function to make sure
   // resources are released as early as possible.
   // 
   // Beware that due to the way that TCP works, it is possible for
   // recently-sent data to be lost if either you close a socket while the
   // %G_IO_IN condition is set, or else if the remote connection tries to
   // send something to you after you close the socket but before it has
   // finished reading all of the data you sent. There is no easy generic
   // way to avoid this problem; the easiest fix is to design the network
   // protocol such that the client will never send data "out of turn".
   // Another solution is for the server to half-close the connection by
   // calling g_socket_shutdown() with only the @shutdown_write flag set,
   // and then wait for the client to notice this and close its side of the
   // connection, after which the server can safely call g_socket_close().
   // (This is what #GTcpConnection does if you call
   // g_tcp_connection_set_graceful_disconnect(). But of course, this
   // only works if the client will close its connection after the server
   // does.)
   // RETURNS: %TRUE on success, %FALSE on error
   int close(GLib2.Error** error=null) {
      return g_socket_close(&this, error);
   }

   // Checks on the readiness of @socket to perform operations.
   // The operations specified in @condition are checked for and masked
   // against the currently-satisfied conditions on @socket. The result
   // is returned.
   // 
   // Note that on Windows, it is possible for an operation to return
   // %G_IO_ERROR_WOULD_BLOCK even immediately after
   // g_socket_condition_check() has claimed that the socket is ready for
   // writing. Rather than calling g_socket_condition_check() and then
   // writing to the socket if it succeeds, it is generally better to
   // simply try writing to the socket right away, and try again later if
   // the initial attempt returns %G_IO_ERROR_WOULD_BLOCK.
   // 
   // It is meaningless to specify %G_IO_ERR or %G_IO_HUP in condition;
   // these conditions will always be set in the output if they are true.
   // 
   // This call never blocks.
   // RETURNS: the @GIOCondition mask of the current state
   // <condition>: a #GIOCondition mask to check
   GLib2.IOCondition condition_check(GLib2.IOCondition condition) {
      return g_socket_condition_check(&this, condition);
   }

   // Waits for @condition to become true on @socket. When the condition
   // is met, %TRUE is returned.
   // 
   // If @cancellable is cancelled before the condition is met, or if the
   // socket has a timeout set and it is reached before the condition is
   // met, then %FALSE is returned and @error, if non-%NULL, is set to
   // the appropriate value (%G_IO_ERROR_CANCELLED or
   // %G_IO_ERROR_TIMED_OUT).
   // RETURNS: %TRUE if the condition was met, %FALSE otherwise
   // <condition>: a #GIOCondition mask to wait for
   // <cancellable>: a #GCancellable, or %NULL
   int condition_wait(GLib2.IOCondition condition, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_condition_wait(&this, condition, cancellable, error);
   }

   // Connect the socket to the specified remote address.
   // 
   // For connection oriented socket this generally means we attempt to make
   // a connection to the @address. For a connection-less socket it sets
   // the default address for g_socket_send() and discards all incoming datagrams
   // from other sources.
   // 
   // Generally connection oriented sockets can only connect once, but
   // connection-less sockets can connect multiple times to change the
   // default address.
   // 
   // If the connect call needs to do network I/O it will block, unless
   // non-blocking I/O is enabled. Then %G_IO_ERROR_PENDING is returned
   // and the user can be notified of the connection finishing by waiting
   // for the G_IO_OUT condition. The result of the connection must then be
   // checked with g_socket_check_connect_result().
   // RETURNS: %TRUE if connected, %FALSE on error.
   // <address>: a #GSocketAddress specifying the remote address.
   // <cancellable>: a %GCancellable or %NULL
   int connect(SocketAddress* address, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_connect(&this, address, cancellable, error);
   }

   // Creates a #GSocketConnection subclass of the right type for
   // @socket.
   // RETURNS: a #GSocketConnection
   SocketConnection* /*new*/ connection_factory_create_connection() {
      return g_socket_connection_factory_create_connection(&this);
   }

   // Unintrospectable method: create_source() / g_socket_create_source()
   // Creates a %GSource that can be attached to a %GMainContext to monitor
   // for the availibility of the specified @condition on the socket.
   // 
   // The callback on the source is of the #GSocketSourceFunc type.
   // 
   // It is meaningless to specify %G_IO_ERR or %G_IO_HUP in @condition;
   // these conditions will always be reported output if they are true.
   // 
   // @cancellable if not %NULL can be used to cancel the source, which will
   // cause the source to trigger, reporting the current condition (which
   // is likely 0 unless cancellation happened at the same time as a
   // condition change). You can check for this in the callback using
   // g_cancellable_is_cancelled().
   // 
   // If @socket has a timeout set, and it is reached before @condition
   // occurs, the source will then trigger anyway, reporting %G_IO_IN or
   // %G_IO_OUT depending on @condition. However, @socket will have been
   // marked as having had a timeout, and so the next #GSocket I/O method
   // you call will then fail with a %G_IO_ERROR_TIMED_OUT.
   // RETURNS: a newly allocated %GSource, free with g_source_unref().
   // <condition>: a #GIOCondition mask to monitor
   // <cancellable>: a %GCancellable or %NULL
   GLib2.Source* /*new*/ create_source(GLib2.IOCondition condition, Cancellable* cancellable=null) {
      return g_socket_create_source(&this, condition, cancellable);
   }

   // Gets the blocking mode of the socket. For details on blocking I/O,
   // see g_socket_set_blocking().
   // RETURNS: %TRUE if blocking I/O is used, %FALSE otherwise.
   int get_blocking() {
      return g_socket_get_blocking(&this);
   }

   // Returns the credentials of the foreign process connected to this
   // socket, if any (e.g. it is only supported for %G_SOCKET_FAMILY_UNIX
   // sockets).
   // 
   // If this operation isn't supported on the OS, the method fails with
   // the %G_IO_ERROR_NOT_SUPPORTED error. On Linux this is implemented
   // by reading the %SO_PEERCRED option on the underlying socket.
   // 
   // Other ways to obtain credentials from a foreign peer includes the
   // #GUnixCredentialsMessage type and
   // g_unix_connection_send_credentials() /
   // g_unix_connection_receive_credentials() functions.
   // 
   // that must be freed with g_object_unref().
   // RETURNS: %NULL if @error is set, otherwise a #GCredentials object
   Credentials* /*new*/ get_credentials(GLib2.Error** error=null) {
      return g_socket_get_credentials(&this, error);
   }

   // Gets the socket family of the socket.
   // RETURNS: a #GSocketFamily
   SocketFamily get_family() {
      return g_socket_get_family(&this);
   }

   // Returns the underlying OS socket object. On unix this
   // is a socket file descriptor, and on windows this is
   // a Winsock2 SOCKET handle. This may be useful for
   // doing platform specific or otherwise unusual operations
   // on the socket.
   // RETURNS: the file descriptor of the socket.
   int get_fd() {
      return g_socket_get_fd(&this);
   }

   // Gets the keepalive mode of the socket. For details on this,
   // see g_socket_set_keepalive().
   // RETURNS: %TRUE if keepalive is active, %FALSE otherwise.
   int get_keepalive() {
      return g_socket_get_keepalive(&this);
   }

   // Gets the listen backlog setting of the socket. For details on this,
   // see g_socket_set_listen_backlog().
   // RETURNS: the maximum number of pending connections.
   int get_listen_backlog() {
      return g_socket_get_listen_backlog(&this);
   }

   // Try to get the local address of a bound socket. This is only
   // useful if the socket has been bound to a local address,
   // either explicitly or implicitly when connecting.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GSocketAddress or %NULL on error.
   SocketAddress* /*new*/ get_local_address(GLib2.Error** error=null) {
      return g_socket_get_local_address(&this, error);
   }

   // Gets the socket protocol id the socket was created with.
   // In case the protocol is unknown, -1 is returned.
   // RETURNS: a protocol id, or -1 if unknown
   SocketProtocol get_protocol() {
      return g_socket_get_protocol(&this);
   }

   // Try to get the remove address of a connected socket. This is only
   // useful for connection oriented sockets that have been connected.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GSocketAddress or %NULL on error.
   SocketAddress* /*new*/ get_remote_address(GLib2.Error** error=null) {
      return g_socket_get_remote_address(&this, error);
   }

   // Gets the socket type of the socket.
   // RETURNS: a #GSocketType
   SocketType get_socket_type() {
      return g_socket_get_socket_type(&this);
   }

   // Gets the timeout setting of the socket. For details on this, see
   // g_socket_set_timeout().
   // RETURNS: the timeout in seconds
   uint get_timeout() {
      return g_socket_get_timeout(&this);
   }

   // Checks whether a socket is closed.
   // RETURNS: %TRUE if socket is closed, %FALSE otherwise
   int is_closed() {
      return g_socket_is_closed(&this);
   }

   // Check whether the socket is connected. This is only useful for
   // connection-oriented sockets.
   // RETURNS: %TRUE if socket is connected, %FALSE otherwise.
   int is_connected() {
      return g_socket_is_connected(&this);
   }

   // Marks the socket as a server socket, i.e. a socket that is used
   // to accept incoming requests using g_socket_accept().
   // 
   // Before calling this the socket must be bound to a local address using
   // g_socket_bind().
   // 
   // To set the maximum amount of outstanding clients, use
   // g_socket_set_listen_backlog().
   // RETURNS: %TRUE on success, %FALSE on error.
   int listen(GLib2.Error** error=null) {
      return g_socket_listen(&this, error);
   }

   // Receive data (up to @size bytes) from a socket. This is mainly used by
   // connection-oriented sockets; it is identical to g_socket_receive_from()
   // with @address set to %NULL.
   // 
   // For %G_SOCKET_TYPE_DATAGRAM and %G_SOCKET_TYPE_SEQPACKET sockets,
   // g_socket_receive() will always read either 0 or 1 complete messages from
   // the socket. If the received message is too large to fit in @buffer, then
   // the data beyond @size bytes will be discarded, without any explicit
   // indication that this has occurred.
   // 
   // For %G_SOCKET_TYPE_STREAM sockets, g_socket_receive() can return any
   // number of bytes, up to @size. If more than @size bytes have been
   // received, the additional data will be returned in future calls to
   // g_socket_receive().
   // 
   // If the socket is in blocking mode the call will block until there
   // is some data to receive, the connection is closed, or there is an
   // error. If there is no data available and the socket is in
   // non-blocking mode, a %G_IO_ERROR_WOULD_BLOCK error will be
   // returned. To be notified when data is available, wait for the
   // %G_IO_IN condition.
   // 
   // On error -1 is returned and @error is set accordingly.
   // 
   // the peer, or -1 on error
   // RETURNS: Number of bytes read, or 0 if the connection was closed by
   // <buffer>: a buffer to read data into (which should be at least @size bytes long).
   // <size>: the number of bytes you want to read from the socket
   // <cancellable>: a %GCancellable or %NULL
   ssize_t receive(char* buffer, size_t size, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_receive(&this, buffer, size, cancellable, error);
   }

   // Receive data (up to @size bytes) from a socket.
   // 
   // If @address is non-%NULL then @address will be set equal to the
   // source address of the received packet.
   // @address is owned by the caller.
   // 
   // See g_socket_receive() for additional information.
   // 
   // the peer, or -1 on error
   // RETURNS: Number of bytes read, or 0 if the connection was closed by
   // <address>: a pointer to a #GSocketAddress pointer, or %NULL
   // <buffer>: a buffer to read data into (which should be at least @size bytes long).
   // <size>: the number of bytes you want to read from the socket
   // <cancellable>: a %GCancellable or %NULL
   ssize_t receive_from(SocketAddress** address, char* buffer, size_t size, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_receive_from(&this, address, buffer, size, cancellable, error);
   }

   // Receive data from a socket.  This is the most complicated and
   // fully-featured version of this call. For easier use, see
   // g_socket_receive() and g_socket_receive_from().
   // 
   // If @address is non-%NULL then @address will be set equal to the
   // source address of the received packet.
   // @address is owned by the caller.
   // 
   // @vector must point to an array of #GInputVector structs and
   // @num_vectors must be the length of this array.  These structs
   // describe the buffers that received data will be scattered into.
   // If @num_vectors is -1, then @vectors is assumed to be terminated
   // by a #GInputVector with a %NULL buffer pointer.
   // 
   // As a special case, if @num_vectors is 0 (in which case, @vectors
   // may of course be %NULL), then a single byte is received and
   // discarded. This is to facilitate the common practice of sending a
   // single '\0' byte for the purposes of transferring ancillary data.
   // 
   // @messages, if non-%NULL, will be set to point to a newly-allocated
   // array of #GSocketControlMessage instances or %NULL if no such
   // messages was received. These correspond to the control messages
   // received from the kernel, one #GSocketControlMessage per message
   // from the kernel. This array is %NULL-terminated and must be freed
   // by the caller using g_free() after calling g_object_unref() on each
   // element. If @messages is %NULL, any control messages received will
   // be discarded.
   // 
   // @num_messages, if non-%NULL, will be set to the number of control
   // messages received.
   // 
   // If both @messages and @num_messages are non-%NULL, then
   // @num_messages gives the number of #GSocketControlMessage instances
   // in @messages (ie: not including the %NULL terminator).
   // 
   // @flags is an in/out parameter. The commonly available arguments
   // for this are available in the #GSocketMsgFlags enum, but the
   // values there are the same as the system values, and the flags
   // are passed in as-is, so you can pass in system-specific flags too
   // (and g_socket_receive_message() may pass system-specific flags out).
   // 
   // As with g_socket_receive(), data may be discarded if @socket is
   // %G_SOCKET_TYPE_DATAGRAM or %G_SOCKET_TYPE_SEQPACKET and you do not
   // provide enough buffer space to read a complete message. You can pass
   // %G_SOCKET_MSG_PEEK in @flags to peek at the current message without
   // removing it from the receive queue, but there is no portable way to find
   // out the length of the message other than by reading it into a
   // sufficiently-large buffer.
   // 
   // If the socket is in blocking mode the call will block until there
   // is some data to receive, the connection is closed, or there is an
   // error. If there is no data available and the socket is in
   // non-blocking mode, a %G_IO_ERROR_WOULD_BLOCK error will be
   // returned. To be notified when data is available, wait for the
   // %G_IO_IN condition.
   // 
   // On error -1 is returned and @error is set accordingly.
   // 
   // the peer, or -1 on error
   // RETURNS: Number of bytes read, or 0 if the connection was closed by
   // <address>: a pointer to a #GSocketAddress pointer, or %NULL
   // <vectors>: an array of #GInputVector structs
   // <num_vectors>: the number of elements in @vectors, or -1
   // <messages>: a pointer which may be filled with an array of #GSocketControlMessages, or %NULL
   // <num_messages>: a pointer which will be filled with the number of elements in @messages, or %NULL
   // <flags>: a pointer to an int containing #GSocketMsgFlags flags
   // <cancellable>: a %GCancellable or %NULL
   ssize_t receive_message(SocketAddress** address, InputVector* vectors, int num_vectors, SocketControlMessage*** messages, int* num_messages, int* flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_receive_message(&this, address, vectors, num_vectors, messages, num_messages, flags, cancellable, error);
   }

   // This behaves exactly the same as g_socket_receive(), except that
   // the choice of blocking or non-blocking behavior is determined by
   // the @blocking argument rather than by @socket's properties.
   // 
   // the peer, or -1 on error
   // RETURNS: Number of bytes read, or 0 if the connection was closed by
   // <buffer>: a buffer to read data into (which should be at least @size bytes long).
   // <size>: the number of bytes you want to read from the socket
   // <blocking>: whether to do blocking or non-blocking I/O
   // <cancellable>: a %GCancellable or %NULL
   ssize_t receive_with_blocking(char* buffer, size_t size, int blocking, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_receive_with_blocking(&this, buffer, size, blocking, cancellable, error);
   }

   // Tries to send @size bytes from @buffer on the socket. This is
   // mainly used by connection-oriented sockets; it is identical to
   // g_socket_send_to() with @address set to %NULL.
   // 
   // If the socket is in blocking mode the call will block until there is
   // space for the data in the socket queue. If there is no space available
   // and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error
   // will be returned. To be notified when space is available, wait for the
   // %G_IO_OUT condition. Note though that you may still receive
   // %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously
   // notified of a %G_IO_OUT condition. (On Windows in particular, this is
   // very common due to the way the underlying APIs work.)
   // 
   // On error -1 is returned and @error is set accordingly.
   // 
   // on error
   // RETURNS: Number of bytes written (which may be less than @size), or -1
   // <buffer>: the buffer containing the data to send.
   // <size>: the number of bytes to send
   // <cancellable>: a %GCancellable or %NULL
   ssize_t send(char* buffer, size_t size, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_send(&this, buffer, size, cancellable, error);
   }

   // Send data to @address on @socket.  This is the most complicated and
   // fully-featured version of this call. For easier use, see
   // g_socket_send() and g_socket_send_to().
   // 
   // If @address is %NULL then the message is sent to the default receiver
   // (set by g_socket_connect()).
   // 
   // @vectors must point to an array of #GOutputVector structs and
   // @num_vectors must be the length of this array. (If @num_vectors is -1,
   // then @vectors is assumed to be terminated by a #GOutputVector with a
   // %NULL buffer pointer.) The #GOutputVector structs describe the buffers
   // that the sent data will be gathered from. Using multiple
   // #GOutputVector<!-- -->s is more memory-efficient than manually copying
   // data from multiple sources into a single buffer, and more
   // network-efficient than making multiple calls to g_socket_send().
   // 
   // @messages, if non-%NULL, is taken to point to an array of @num_messages
   // #GSocketControlMessage instances. These correspond to the control
   // messages to be sent on the socket.
   // If @num_messages is -1 then @messages is treated as a %NULL-terminated
   // array.
   // 
   // @flags modify how the message is sent. The commonly available arguments
   // for this are available in the #GSocketMsgFlags enum, but the
   // values there are the same as the system values, and the flags
   // are passed in as-is, so you can pass in system-specific flags too.
   // 
   // If the socket is in blocking mode the call will block until there is
   // space for the data in the socket queue. If there is no space available
   // and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error
   // will be returned. To be notified when space is available, wait for the
   // %G_IO_OUT condition. Note though that you may still receive
   // %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously
   // notified of a %G_IO_OUT condition. (On Windows in particular, this is
   // very common due to the way the underlying APIs work.)
   // 
   // On error -1 is returned and @error is set accordingly.
   // 
   // on error
   // RETURNS: Number of bytes written (which may be less than @size), or -1
   // <address>: a #GSocketAddress, or %NULL
   // <vectors>: an array of #GOutputVector structs
   // <num_vectors>: the number of elements in @vectors, or -1
   // <messages>: a pointer to an array of #GSocketControlMessages, or %NULL.
   // <num_messages>: number of elements in @messages, or -1.
   // <flags>: an int containing #GSocketMsgFlags flags
   // <cancellable>: a %GCancellable or %NULL
   ssize_t send_message(SocketAddress* address, OutputVector* vectors, int num_vectors, SocketControlMessage** messages, int num_messages, int flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_send_message(&this, address, vectors, num_vectors, messages, num_messages, flags, cancellable, error);
   }

   // Tries to send @size bytes from @buffer to @address. If @address is
   // %NULL then the message is sent to the default receiver (set by
   // g_socket_connect()).
   // 
   // See g_socket_send() for additional information.
   // 
   // on error
   // RETURNS: Number of bytes written (which may be less than @size), or -1
   // <address>: a #GSocketAddress, or %NULL
   // <buffer>: the buffer containing the data to send.
   // <size>: the number of bytes to send
   // <cancellable>: a %GCancellable or %NULL
   ssize_t send_to(SocketAddress* address, char* buffer, size_t size, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_send_to(&this, address, buffer, size, cancellable, error);
   }

   // This behaves exactly the same as g_socket_send(), except that
   // the choice of blocking or non-blocking behavior is determined by
   // the @blocking argument rather than by @socket's properties.
   // 
   // on error
   // RETURNS: Number of bytes written (which may be less than @size), or -1
   // <buffer>: the buffer containing the data to send.
   // <size>: the number of bytes to send
   // <blocking>: whether to do blocking or non-blocking I/O
   // <cancellable>: a %GCancellable or %NULL
   ssize_t send_with_blocking(char* buffer, size_t size, int blocking, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_send_with_blocking(&this, buffer, size, blocking, cancellable, error);
   }

   // Sets the blocking mode of the socket. In blocking mode
   // all operations block until they succeed or there is an error. In
   // non-blocking mode all functions return results immediately or
   // with a %G_IO_ERROR_WOULD_BLOCK error.
   // 
   // All sockets are created in blocking mode. However, note that the
   // platform level socket is always non-blocking, and blocking mode
   // is a GSocket level feature.
   // <blocking>: Whether to use blocking I/O or not.
   void set_blocking(int blocking) {
      g_socket_set_blocking(&this, blocking);
   }

   // Sets or unsets the %SO_KEEPALIVE flag on the underlying socket. When
   // this flag is set on a socket, the system will attempt to verify that the
   // remote socket endpoint is still present if a sufficiently long period of
   // time passes with no data being exchanged. If the system is unable to
   // verify the presence of the remote endpoint, it will automatically close
   // the connection.
   // 
   // This option is only functional on certain kinds of sockets. (Notably,
   // %G_SOCKET_PROTOCOL_TCP sockets.)
   // 
   // The exact time between pings is system- and protocol-dependent, but will
   // normally be at least two hours. Most commonly, you would set this flag
   // on a server socket if you want to allow clients to remain idle for long
   // periods of time, but also want to ensure that connections are eventually
   // garbage-collected if clients crash or become unreachable.
   // <keepalive>: Value for the keepalive flag
   void set_keepalive(int keepalive) {
      g_socket_set_keepalive(&this, keepalive);
   }

   // Sets the maximum number of outstanding connections allowed
   // when listening on this socket. If more clients than this are
   // connecting to the socket and the application is not handling them
   // on time then the new connections will be refused.
   // 
   // Note that this must be called before g_socket_listen() and has no
   // effect if called after that.
   // <backlog>: the maximum number of pending connections.
   void set_listen_backlog(int backlog) {
      g_socket_set_listen_backlog(&this, backlog);
   }

   // Sets the time in seconds after which I/O operations on @socket will
   // time out if they have not yet completed.
   // 
   // On a blocking socket, this means that any blocking #GSocket
   // operation will time out after @timeout seconds of inactivity,
   // returning %G_IO_ERROR_TIMED_OUT.
   // 
   // On a non-blocking socket, calls to g_socket_condition_wait() will
   // also fail with %G_IO_ERROR_TIMED_OUT after the given time. Sources
   // created with g_socket_create_source() will trigger after
   // @timeout seconds of inactivity, with the requested condition
   // set, at which point calling g_socket_receive(), g_socket_send(),
   // g_socket_check_connect_result(), etc, will fail with
   // %G_IO_ERROR_TIMED_OUT.
   // 
   // If @timeout is 0 (the default), operations will never time out
   // on their own.
   // 
   // Note that if an I/O operation is interrupted by a signal, this may
   // cause the timeout to be reset.
   // <timeout>: the timeout for @socket, in seconds, or 0 for none
   void set_timeout(uint timeout) {
      g_socket_set_timeout(&this, timeout);
   }

   // Shut down part of a full-duplex connection.
   // 
   // If @shutdown_read is %TRUE then the receiving side of the connection
   // is shut down, and further reading is disallowed.
   // 
   // If @shutdown_write is %TRUE then the sending side of the connection
   // is shut down, and further writing is disallowed.
   // 
   // It is allowed for both @shutdown_read and @shutdown_write to be %TRUE.
   // 
   // One example where this is used is graceful disconnect for TCP connections
   // where you close the sending side, then wait for the other side to close
   // the connection, thus ensuring that the other side saw all sent data.
   // RETURNS: %TRUE on success, %FALSE on error
   // <shutdown_read>: whether to shut down the read side
   // <shutdown_write>: whether to shut down the write side
   int shutdown(int shutdown_read, int shutdown_write, GLib2.Error** error=null) {
      return g_socket_shutdown(&this, shutdown_read, shutdown_write, error);
   }

   // Checks if a socket is capable of speaking IPv4.
   // 
   // IPv4 sockets are capable of speaking IPv4.  On some operating systems
   // and under some combinations of circumstances IPv6 sockets are also
   // capable of speaking IPv4.  See RFC 3493 section 3.7 for more
   // information.
   // 
   // No other types of sockets are currently considered as being capable
   // of speaking IPv4.
   // RETURNS: %TRUE if this socket can be used with IPv4.
   int speaks_ipv4() {
      return g_socket_speaks_ipv4(&this);
   }
}


// #GSocketAddress is the equivalent of <type>struct sockaddr</type>
// in the BSD sockets API. This is an abstract class; use
// #GInetSocketAddress for internet sockets, or #GUnixSocketAddress
// for UNIX domain sockets.
struct SocketAddress /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;


   // Creates a #GSocketAddress subclass corresponding to the native
   // <type>struct sockaddr</type> @native.
   // 
   // otherwise %NULL.
   // RETURNS: a new #GSocketAddress if @native could successfully be converted,
   // <native>: a pointer to a <type>struct sockaddr</type>
   // <len>: the size of the memory location pointed to by @native
   static SocketAddress* /*new*/ new_from_native(void* native, size_t len) {
      return g_socket_address_new_from_native(native, len);
   }

   // Gets the socket family type of @address.
   // RETURNS: the socket family type of @address.
   SocketFamily get_family() {
      return g_socket_address_get_family(&this);
   }

   // Gets the size of @address's native <type>struct sockaddr</type>.
   // You can use this to allocate memory to pass to
   // g_socket_address_to_native().
   // 
   // @address represents
   // RETURNS: the size of the native <type>struct sockaddr</type> that
   ssize_t get_native_size() {
      return g_socket_address_get_native_size(&this);
   }

   // Converts a #GSocketAddress to a native <type>struct
   // sockaddr</type>, which can be passed to low-level functions like
   // connect() or bind().
   // 
   // If not enough space is available, a %G_IO_ERROR_NO_SPACE error is
   // returned. If the address type is not known on the system
   // then a %G_IO_ERROR_NOT_SUPPORTED error is returned.
   // RETURNS: %TRUE if @dest was filled in, %FALSE on error
   // <dest>: a pointer to a memory location that will contain the native <type>struct sockaddr</type>.
   // <destlen>: the size of @dest. Must be at least as large as g_socket_address_get_native_size().
   int to_native(void* dest, size_t destlen, GLib2.Error** error=null) {
      return g_socket_address_to_native(&this, dest, destlen, error);
   }
}

struct SocketAddressClass {
   GObject2.ObjectClass parent_class;
   // RETURNS: the socket family type of @address.
   extern (C) SocketFamily function (SocketAddress* address) get_family;
   // RETURNS: the size of the native <type>struct sockaddr</type> that
   extern (C) ssize_t function (SocketAddress* address) get_native_size;

   // RETURNS: %TRUE if @dest was filled in, %FALSE on error
   // <dest>: a pointer to a memory location that will contain the native <type>struct sockaddr</type>.
   // <destlen>: the size of @dest. Must be at least as large as g_socket_address_get_native_size().
   extern (C) int function (SocketAddress* address, void* dest, size_t destlen, GLib2.Error** error=null) to_native;
}


// Enumerator type for objects that contain or generate
// #GSocketAddress<!-- -->es.
struct SocketAddressEnumerator /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;


   // Retrieves the next #GSocketAddress from @enumerator. Note that this
   // may block for some amount of time. (Eg, a #GNetworkAddress may need
   // to do a DNS lookup before it can return an address.) Use
   // g_socket_address_enumerator_next_async() if you need to avoid
   // blocking.
   // 
   // If @enumerator is expected to yield addresses, but for some reason
   // is unable to (eg, because of a DNS error), then the first call to
   // g_socket_address_enumerator_next() will return an appropriate error
   // in *@error. However, if the first call to
   // g_socket_address_enumerator_next() succeeds, then any further
   // internal errors (other than @cancellable being triggered) will be
   // ignored.
   // 
   // error (in which case *@error will be set) or if there are no
   // more addresses.
   // RETURNS: a #GSocketAddress (owned by the caller), or %NULL on
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   SocketAddress* /*new*/ next(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_address_enumerator_next(&this, cancellable, error);
   }

   // Asynchronously retrieves the next #GSocketAddress from @enumerator
   // and then calls @callback, which must call
   // g_socket_address_enumerator_next_finish() to get the result.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   void next_async(Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_socket_address_enumerator_next_async(&this, cancellable, callback, user_data);
   }

   // Retrieves the result of a completed call to
   // g_socket_address_enumerator_next_async(). See
   // g_socket_address_enumerator_next() for more information about
   // error handling.
   // 
   // error (in which case *@error will be set) or if there are no
   // more addresses.
   // RETURNS: a #GSocketAddress (owned by the caller), or %NULL on
   // <result>: a #GAsyncResult
   SocketAddress* /*new*/ next_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_socket_address_enumerator_next_finish(&this, result, error);
   }
}

struct SocketAddressEnumeratorClass {
   GObject2.ObjectClass parent_class;

   // RETURNS: a #GSocketAddress (owned by the caller), or %NULL on
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   extern (C) SocketAddress* /*new*/ function (SocketAddressEnumerator* enumerator, Cancellable* cancellable, GLib2.Error** error=null) next;

   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback to call when the request is satisfied
   // <user_data>: the data to pass to callback function
   extern (C) void function (SocketAddressEnumerator* enumerator, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) next_async;

   // RETURNS: a #GSocketAddress (owned by the caller), or %NULL on
   // <result>: a #GAsyncResult
   extern (C) SocketAddress* /*new*/ function (SocketAddressEnumerator* enumerator, AsyncResult* result, GLib2.Error** error=null) next_finish;
}

struct SocketClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
   extern (C) void function () _g_reserved6;
   extern (C) void function () _g_reserved7;
   extern (C) void function () _g_reserved8;
   extern (C) void function () _g_reserved9;
   extern (C) void function () _g_reserved10;
}


// #GSocketClient is a high-level utility class for connecting to a
// network host using a connection oriented socket type.
// 
// You create a #GSocketClient object, set any options you want, and then
// call a sync or async connect operation, which returns a #GSocketConnection
// subclass on success.
// 
// The type of the #GSocketConnection object returned depends on the type of
// the underlying socket that is in use. For instance, for a TCP/IP connection
// it will be a #GTcpConnection.
struct SocketClient /* : GObject.Object */ /* Version 2.22 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   SocketClientPrivate* priv;


   // Creates a new #GSocketClient with the default options.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GSocketClient.
   static SocketClient* /*new*/ new_() {
      return g_socket_client_new();
   }

   // Enable proxy protocols to be handled by the application. When the
   // indicated proxy protocol is returned by the #GProxyResolver,
   // #GSocketClient will consider this protocol as supported but will
   // not try to find a #GProxy instance to handle handshaking. The
   // application must check for this case by calling
   // g_socket_connection_get_remote_address() on the returned
   // #GSocketConnection, and seeing if it's a #GProxyAddress of the
   // appropriate type, to determine whether or not it needs to handle
   // the proxy handshaking itself.
   // 
   // This should be used for proxy protocols that are dialects of
   // another protocol such as HTTP proxy. It also allows cohabitation of
   // proxy protocols that are reused between protocols. A good example
   // is HTTP. It can be used to proxy HTTP, FTP and Gopher and can also
   // be use as generic socket proxy through the HTTP CONNECT method.
   // <protocol>: The proxy protocol
   void add_application_proxy(char* protocol) {
      g_socket_client_add_application_proxy(&this, protocol);
   }

   // Tries to resolve the @connectable and make a network connection to it.
   // 
   // Upon a successful connection, a new #GSocketConnection is constructed
   // and returned.  The caller owns this new object and must drop their
   // reference to it when finished with it.
   // 
   // The type of the #GSocketConnection object returned depends on the type of
   // the underlying socket that is used. For instance, for a TCP/IP connection
   // it will be a #GTcpConnection.
   // 
   // The socket created will be the same family as the address that the
   // @connectable resolves to, unless family is set with g_socket_client_set_family()
   // or indirectly via g_socket_client_set_local_address(). The socket type
   // defaults to %G_SOCKET_TYPE_STREAM but can be set with
   // g_socket_client_set_socket_type().
   // 
   // If a local address is specified with g_socket_client_set_local_address() the
   // socket will be bound to this address before connecting.
   // RETURNS: a #GSocketConnection on success, %NULL on error.
   // <connectable>: a #GSocketConnectable specifying the remote address.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   SocketConnection* /*new*/ connect(SocketConnectable* connectable, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_client_connect(&this, connectable, cancellable, error);
   }

   // This is the asynchronous version of g_socket_client_connect().
   // 
   // When the operation is finished @callback will be
   // called. You can then call g_socket_client_connect_finish() to get
   // the result of the operation.
   // <connectable>: a #GSocketConnectable specifying the remote address.
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: a #GAsyncReadyCallback
   // <user_data>: user data for the callback
   void connect_async(SocketConnectable* connectable, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_socket_client_connect_async(&this, connectable, cancellable, callback, user_data);
   }

   // Finishes an async connect operation. See g_socket_client_connect_async()
   // RETURNS: a #GSocketConnection on success, %NULL on error.
   // <result>: a #GAsyncResult.
   SocketConnection* /*new*/ connect_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_socket_client_connect_finish(&this, result, error);
   }

   // This is a helper function for g_socket_client_connect().
   // 
   // Attempts to create a TCP connection to the named host.
   // 
   // @host_and_port may be in any of a number of recognized formats; an IPv6
   // address, an IPv4 address, or a domain name (in which case a DNS
   // lookup is performed).  Quoting with [] is supported for all address
   // types.  A port override may be specified in the usual way with a
   // colon.  Ports may be given as decimal numbers or symbolic names (in
   // which case an /etc/services lookup is performed).
   // 
   // If no port override is given in @host_and_port then @default_port will be
   // used as the port number to connect to.
   // 
   // In general, @host_and_port is expected to be provided by the user (allowing
   // them to give the hostname, and a port override if necessary) and
   // @default_port is expected to be provided by the application.
   // 
   // In the case that an IP address is given, a single connection
   // attempt is made.  In the case that a name is given, multiple
   // connection attempts may be made, in turn and according to the
   // number of address records in DNS, until a connection succeeds.
   // 
   // Upon a successful connection, a new #GSocketConnection is constructed
   // and returned.  The caller owns this new object and must drop their
   // reference to it when finished with it.
   // 
   // In the event of any failure (DNS error, service not found, no hosts
   // connectable) %NULL is returned and @error (if non-%NULL) is set
   // accordingly.
   // RETURNS: a #GSocketConnection on success, %NULL on error.
   // <host_and_port>: the name and optionally port of the host to connect to
   // <default_port>: the default port to connect to
   // <cancellable>: a #GCancellable, or %NULL
   SocketConnection* /*new*/ connect_to_host(char* host_and_port, ushort default_port, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_client_connect_to_host(&this, host_and_port, default_port, cancellable, error);
   }

   // This is the asynchronous version of g_socket_client_connect_to_host().
   // 
   // When the operation is finished @callback will be
   // called. You can then call g_socket_client_connect_to_host_finish() to get
   // the result of the operation.
   // <host_and_port>: the name and optionally the port of the host to connect to
   // <default_port>: the default port to connect to
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: a #GAsyncReadyCallback
   // <user_data>: user data for the callback
   void connect_to_host_async(char* host_and_port, ushort default_port, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_socket_client_connect_to_host_async(&this, host_and_port, default_port, cancellable, callback, user_data);
   }

   // Finishes an async connect operation. See g_socket_client_connect_to_host_async()
   // RETURNS: a #GSocketConnection on success, %NULL on error.
   // <result>: a #GAsyncResult.
   SocketConnection* /*new*/ connect_to_host_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_socket_client_connect_to_host_finish(&this, result, error);
   }

   // Attempts to create a TCP connection to a service.
   // 
   // This call looks up the SRV record for @service at @domain for the
   // "tcp" protocol.  It then attempts to connect, in turn, to each of
   // the hosts providing the service until either a connection succeeds
   // or there are no hosts remaining.
   // 
   // Upon a successful connection, a new #GSocketConnection is constructed
   // and returned.  The caller owns this new object and must drop their
   // reference to it when finished with it.
   // 
   // In the event of any failure (DNS error, service not found, no hosts
   // connectable) %NULL is returned and @error (if non-%NULL) is set
   // accordingly.
   // RETURNS: a #GSocketConnection if successful, or %NULL on error
   // <domain>: a domain name
   // <service>: the name of the service to connect to
   // <cancellable>: a #GCancellable, or %NULL
   SocketConnection* /*new*/ connect_to_service(char* domain, char* service, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_client_connect_to_service(&this, domain, service, cancellable, error);
   }

   // This is the asynchronous version of
   // g_socket_client_connect_to_service().
   // <domain>: a domain name
   // <service>: the name of the service to connect to
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: a #GAsyncReadyCallback
   // <user_data>: user data for the callback
   void connect_to_service_async(char* domain, char* service, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_socket_client_connect_to_service_async(&this, domain, service, cancellable, callback, user_data);
   }

   // Finishes an async connect operation. See g_socket_client_connect_to_service_async()
   // RETURNS: a #GSocketConnection on success, %NULL on error.
   // <result>: a #GAsyncResult.
   SocketConnection* /*new*/ connect_to_service_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_socket_client_connect_to_service_finish(&this, result, error);
   }

   // This is a helper function for g_socket_client_connect().
   // 
   // Attempts to create a TCP connection with a network URI.
   // 
   // @uri may be any valid URI containing an "authority" (hostname/port)
   // component. If a port is not specified in the URI, @default_port
   // will be used. TLS will be negotiated if #GSocketClient:tls is %TRUE.
   // (#GSocketClient does not know to automatically assume TLS for
   // certain URI schemes.)
   // 
   // Using this rather than g_socket_client_connect() or
   // g_socket_client_connect_to_host() allows #GSocketClient to
   // determine when to use application-specific proxy protocols.
   // 
   // Upon a successful connection, a new #GSocketConnection is constructed
   // and returned.  The caller owns this new object and must drop their
   // reference to it when finished with it.
   // 
   // In the event of any failure (DNS error, service not found, no hosts
   // connectable) %NULL is returned and @error (if non-%NULL) is set
   // accordingly.
   // RETURNS: a #GSocketConnection on success, %NULL on error.
   // <uri>: A network URI
   // <default_port>: the default port to connect to
   // <cancellable>: a #GCancellable, or %NULL
   SocketConnection* /*new*/ connect_to_uri(char* uri, ushort default_port, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_client_connect_to_uri(&this, uri, default_port, cancellable, error);
   }

   // This is the asynchronous version of g_socket_client_connect_to_uri().
   // 
   // When the operation is finished @callback will be
   // called. You can then call g_socket_client_connect_to_uri_finish() to get
   // the result of the operation.
   // <uri>: a network uri
   // <default_port>: the default port to connect to
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: a #GAsyncReadyCallback
   // <user_data>: user data for the callback
   void connect_to_uri_async(char* uri, ushort default_port, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_socket_client_connect_to_uri_async(&this, uri, default_port, cancellable, callback, user_data);
   }

   // Finishes an async connect operation. See g_socket_client_connect_to_uri_async()
   // RETURNS: a #GSocketConnection on success, %NULL on error.
   // <result>: a #GAsyncResult.
   SocketConnection* /*new*/ connect_to_uri_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_socket_client_connect_to_uri_finish(&this, result, error);
   }

   // Gets the proxy enable state; see g_socket_client_set_enable_proxy()
   // RETURNS: whether proxying is enabled
   int get_enable_proxy() {
      return g_socket_client_get_enable_proxy(&this);
   }

   // Gets the socket family of the socket client.
   // 
   // See g_socket_client_set_family() for details.
   // RETURNS: a #GSocketFamily
   SocketFamily get_family() {
      return g_socket_client_get_family(&this);
   }

   // Gets the local address of the socket client.
   // 
   // See g_socket_client_set_local_address() for details.
   // RETURNS: a #GSocketAddress or %NULL. Do not free.
   SocketAddress* get_local_address() {
      return g_socket_client_get_local_address(&this);
   }

   // Gets the protocol name type of the socket client.
   // 
   // See g_socket_client_set_protocol() for details.
   // RETURNS: a #GSocketProtocol
   SocketProtocol get_protocol() {
      return g_socket_client_get_protocol(&this);
   }

   // Gets the socket type of the socket client.
   // 
   // See g_socket_client_set_socket_type() for details.
   // RETURNS: a #GSocketFamily
   SocketType get_socket_type() {
      return g_socket_client_get_socket_type(&this);
   }

   // Gets the I/O timeout time for sockets created by @client.
   // 
   // See g_socket_client_set_timeout() for details.
   // RETURNS: the timeout in seconds
   uint get_timeout() {
      return g_socket_client_get_timeout(&this);
   }

   // Gets whether @client creates TLS connections. See
   // g_socket_client_set_tls() for details.
   // RETURNS: whether @client uses TLS
   int get_tls() {
      return g_socket_client_get_tls(&this);
   }

   // Gets the TLS validation flags used creating TLS connections via
   // @client.
   // RETURNS: the TLS validation flags
   TlsCertificateFlags get_tls_validation_flags() {
      return g_socket_client_get_tls_validation_flags(&this);
   }

   // Sets whether or not @client attempts to make connections via a
   // proxy server. When enabled (the default), #GSocketClient will use a
   // #GProxyResolver to determine if a proxy protocol such as SOCKS is
   // needed, and automatically do the necessary proxy negotiation.
   // <enable>: whether to enable proxies
   void set_enable_proxy(int enable) {
      g_socket_client_set_enable_proxy(&this, enable);
   }

   // Sets the socket family of the socket client.
   // If this is set to something other than %G_SOCKET_FAMILY_INVALID
   // then the sockets created by this object will be of the specified
   // family.
   // 
   // This might be useful for instance if you want to force the local
   // connection to be an ipv4 socket, even though the address might
   // be an ipv6 mapped to ipv4 address.
   // <family>: a #GSocketFamily
   void set_family(SocketFamily family) {
      g_socket_client_set_family(&this, family);
   }

   // Sets the local address of the socket client.
   // The sockets created by this object will bound to the
   // specified address (if not %NULL) before connecting.
   // 
   // This is useful if you want to ensure that the local
   // side of the connection is on a specific port, or on
   // a specific interface.
   // <address>: a #GSocketAddress, or %NULL
   void set_local_address(SocketAddress* address) {
      g_socket_client_set_local_address(&this, address);
   }

   // Sets the protocol of the socket client.
   // The sockets created by this object will use of the specified
   // protocol.
   // 
   // If @protocol is %0 that means to use the default
   // protocol for the socket family and type.
   // <protocol>: a #GSocketProtocol
   void set_protocol(SocketProtocol protocol) {
      g_socket_client_set_protocol(&this, protocol);
   }

   // Sets the socket type of the socket client.
   // The sockets created by this object will be of the specified
   // type.
   // 
   // It doesn't make sense to specify a type of %G_SOCKET_TYPE_DATAGRAM,
   // as GSocketClient is used for connection oriented services.
   // <type>: a #GSocketType
   void set_socket_type(SocketType type) {
      g_socket_client_set_socket_type(&this, type);
   }

   // Sets the I/O timeout for sockets created by @client. @timeout is a
   // time in seconds, or 0 for no timeout (the default).
   // 
   // The timeout value affects the initial connection attempt as well,
   // so setting this may cause calls to g_socket_client_connect(), etc,
   // to fail with %G_IO_ERROR_TIMED_OUT.
   // <timeout>: the timeout
   void set_timeout(uint timeout) {
      g_socket_client_set_timeout(&this, timeout);
   }

   // Sets whether @client creates TLS (aka SSL) connections. If @tls is
   // %TRUE, @client will wrap its connections in a #GTlsClientConnection
   // and perform a TLS handshake when connecting.
   // 
   // Note that since #GSocketClient must return a #GSocketConnection,
   // but #GTlsClientConnection is not a #GSocketConnection, this
   // actually wraps the resulting #GTlsClientConnection in a
   // #GTcpWrapperConnection when returning it. You can use
   // g_tcp_wrapper_connection_get_base_io_stream() on the return value
   // to extract the #GTlsClientConnection.
   // <tls>: whether to use TLS
   void set_tls(int tls) {
      g_socket_client_set_tls(&this, tls);
   }

   // Sets the TLS validation flags used when creating TLS connections
   // via @client. The default value is %G_TLS_CERTIFICATE_VALIDATE_ALL.
   // <flags>: the validation flags
   void set_tls_validation_flags(TlsCertificateFlags flags) {
      g_socket_client_set_tls_validation_flags(&this, flags);
   }
}

struct SocketClientClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct SocketClientPrivate {
}


// Objects that describe one or more potential socket endpoints
// implement #GSocketConnectable. Callers can then use
// g_socket_connectable_enumerate() to get a #GSocketAddressEnumerator
// to try out each socket address in turn until one succeeds, as shown
// in the sample code below.
// 
// |[
// MyConnectionType *
// connect_to_host (const char    *hostname,
// guint16        port,
// GCancellable  *cancellable,
// GError       **error)
// {
// MyConnection *conn = NULL;
// GSocketConnectable *addr;
// GSocketAddressEnumerator *enumerator;
// GSocketAddress *sockaddr;
// GError *conn_error = NULL;
// 
// addr = g_network_address_new ("www.gnome.org", 80);
// enumerator = g_socket_connectable_enumerate (addr);
// g_object_unref (addr);
// 
// /<!-- -->* Try each sockaddr until we succeed. Record the first
// * connection error, but not any further ones (since they'll probably
// * be basically the same as the first).
// *<!-- -->/
// while (!conn && (sockaddr = g_socket_address_enumerator_next (enumerator, cancellable, error))
// {
// conn = connect_to_sockaddr (sockaddr, conn_error ? NULL : &conn_error);
// g_object_unref (sockaddr);
// }
// g_object_unref (enumerator);
// 
// if (conn)
// {
// if (conn_error)
// {
// /<!-- -->* We couldn't connect to the first address, but we succeeded
// * in connecting to a later address.
// *<!-- -->/
// g_error_free (conn_error);
// }
// return conn;
// }
// else if (error)
// {
// /<!-- -->* Either the initial lookup failed, or else the caller
// * cancelled us.
// *<!-- -->/
// if (conn_error)
// g_error_free (conn_error);
// return NULL;
// }
// else
// {
// g_error_propagate (error, conn_error);
// return NULL;
// }
// }
// ]|
struct SocketConnectable {

   // Creates a #GSocketAddressEnumerator for @connectable.
   // RETURNS: a new #GSocketAddressEnumerator.
   SocketAddressEnumerator* /*new*/ enumerate() {
      return g_socket_connectable_enumerate(&this);
   }

   // Creates a #GSocketAddressEnumerator for @connectable that will
   // return #GProxyAddress<!-- -->es for addresses that you must connect
   // to via a proxy.
   // 
   // If @connectable does not implement
   // g_socket_connectable_proxy_enumerate(), this will fall back to
   // calling g_socket_connectable_enumerate().
   // RETURNS: a new #GSocketAddressEnumerator.
   SocketAddressEnumerator* /*new*/ proxy_enumerate() {
      return g_socket_connectable_proxy_enumerate(&this);
   }
}


// Provides an interface for returning a #GSocketAddressEnumerator
// and #GProxyAddressEnumerator
struct SocketConnectableIface {
   GObject2.TypeInterface g_iface;
   // RETURNS: a new #GSocketAddressEnumerator.
   extern (C) SocketAddressEnumerator* /*new*/ function (SocketConnectable* connectable) enumerate;
   // RETURNS: a new #GSocketAddressEnumerator.
   extern (C) SocketAddressEnumerator* /*new*/ function (SocketConnectable* connectable) proxy_enumerate;
}


// #GSocketConnection is a #GIOStream for a connected socket. They
// can be created either by #GSocketClient when connecting to a host,
// or by #GSocketListener when accepting a new client.
// 
// The type of the #GSocketConnection object returned from these calls
// depends on the type of the underlying socket that is in use. For
// instance, for a TCP/IP connection it will be a #GTcpConnection.
// 
// Choosing what type of object to construct is done with the socket
// connection factory, and it is possible for 3rd parties to register
// custom socket connection types for specific combination of socket
// family/type/protocol using g_socket_connection_factory_register_type().
struct SocketConnection /* : IOStream */ /* Version 2.22 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance iostream;
   IOStream parent_instance;
   SocketConnectionPrivate* priv;


   // Looks up the #GType to be used when creating socket connections on
   // sockets with the specified @family, @type and @protocol_id.
   // 
   // If no type is registered, the #GSocketConnection base type is returned.
   // RETURNS: a #GType
   // <family>: a #GSocketFamily
   // <type>: a #GSocketType
   // <protocol_id>: a protocol id
   static Type factory_lookup_type(SocketFamily family, SocketType type, int protocol_id) {
      return g_socket_connection_factory_lookup_type(family, type, protocol_id);
   }

   // Looks up the #GType to be used when creating socket connections on
   // sockets with the specified @family, @type and @protocol.
   // 
   // If no type is registered, the #GSocketConnection base type is returned.
   // <g_type>: a #GType, inheriting from %G_TYPE_SOCKET_CONNECTION
   // <family>: a #GSocketFamily
   // <type>: a #GSocketType
   // <protocol>: a protocol id
   static void factory_register_type(Type g_type, SocketFamily family, SocketType type, int protocol) {
      g_socket_connection_factory_register_type(g_type, family, type, protocol);
   }

   // Try to get the local address of a socket connection.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GSocketAddress or %NULL on error.
   SocketAddress* /*new*/ get_local_address(GLib2.Error** error=null) {
      return g_socket_connection_get_local_address(&this, error);
   }

   // Try to get the remote address of a socket connection.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GSocketAddress or %NULL on error.
   SocketAddress* /*new*/ get_remote_address(GLib2.Error** error=null) {
      return g_socket_connection_get_remote_address(&this, error);
   }

   // Gets the underlying #GSocket object of the connection.
   // This can be useful if you want to do something unusual on it
   // not supported by the #GSocketConnection APIs.
   // RETURNS: a #GSocketAddress or %NULL on error.
   Socket* get_socket() {
      return g_socket_connection_get_socket(&this);
   }
}

struct SocketConnectionClass {
   IOStreamClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
   extern (C) void function () _g_reserved6;
}

struct SocketConnectionPrivate {
}


// A #GSocketControlMessage is a special-purpose utility message that
// can be sent to or received from a #GSocket. These types of
// messages are often called "ancillary data".
// 
// The message can represent some sort of special instruction to or
// information from the socket or can represent a special kind of
// transfer to the peer (for example, sending a file description over
// a UNIX socket).
// 
// These messages are sent with g_socket_send_message() and received
// with g_socket_receive_message().
// 
// To extend the set of control message that can be sent, subclass this
// class and override the get_size, get_level, get_type and serialize
// methods.
// 
// To extend the set of control messages that can be received, subclass
// this class and implement the deserialize method. Also, make sure your
// class is registered with the GType typesystem before calling
// g_socket_receive_message() to read such a message.
struct SocketControlMessage /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   SocketControlMessagePrivate* priv;


   // Tries to deserialize a socket control message of a given
   // @level and @type. This will ask all known (to GType) subclasses
   // of #GSocketControlMessage if they can understand this kind
   // of message and if so deserialize it into a #GSocketControlMessage.
   // 
   // If there is no implementation for this kind of control message, %NULL
   // will be returned.
   // RETURNS: the deserialized message or %NULL
   // <level>: a socket level
   // <type>: a socket control message type for the given @level
   // <size>: the size of the data in bytes
   // <data>: pointer to the message data
   static SocketControlMessage* /*new*/ deserialize(int level, int type, size_t size, void* data) {
      return g_socket_control_message_deserialize(level, type, size, data);
   }

   // Returns the "level" (i.e. the originating protocol) of the control message.
   // This is often SOL_SOCKET.
   // RETURNS: an integer describing the level
   int get_level() {
      return g_socket_control_message_get_level(&this);
   }

   // Returns the protocol specific type of the control message.
   // For instance, for UNIX fd passing this would be SCM_RIGHTS.
   // RETURNS: an integer describing the type of control message
   int get_msg_type() {
      return g_socket_control_message_get_msg_type(&this);
   }

   // Returns the space required for the control message, not including
   // headers or alignment.
   // RETURNS: The number of bytes required.
   size_t get_size() {
      return g_socket_control_message_get_size(&this);
   }

   // Converts the data in the message to bytes placed in the
   // message.
   // 
   // @data is guaranteed to have enough space to fit the size
   // returned by g_socket_control_message_get_size() on this
   // object.
   // <data>: A buffer to write data to
   void serialize(void* data) {
      g_socket_control_message_serialize(&this, data);
   }
}

struct SocketControlMessageClass {
   GObject2.ObjectClass parent_class;
   // RETURNS: The number of bytes required.
   extern (C) size_t function (SocketControlMessage* message) get_size;
   // RETURNS: an integer describing the level
   extern (C) int function (SocketControlMessage* message) get_level;
   extern (C) int function (SocketControlMessage* message) get_type;
   // <data>: A buffer to write data to
   extern (C) void function (SocketControlMessage* message, void* data) serialize;
   // Unintrospectable functionp: deserialize() / ()
   extern (C) SocketControlMessage* function (int level, int type, size_t size, void* data) deserialize;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct SocketControlMessagePrivate {
}


// The protocol family of a #GSocketAddress. (These values are
// identical to the system defines %AF_INET, %AF_INET6 and %AF_UNIX,
// if available.)
enum SocketFamily /* Version 2.22 */ {
   INVALID = 0,
   UNIX = 1,
   IPV4 = 2,
   IPV6 = 10
}

// A #GSocketListener is an object that keeps track of a set
// of server sockets and helps you accept sockets from any of the
// socket, either sync or async.
// 
// If you want to implement a network server, also look at #GSocketService
// and #GThreadedSocketService which are subclass of #GSocketListener
// that makes this even easier.
struct SocketListener /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   SocketListenerPrivate* priv;


   // Creates a new #GSocketListener with no sockets to listen for.
   // New listeners can be added with e.g. g_socket_listener_add_address()
   // or g_socket_listener_add_inet_port().
   // RETURNS: a new #GSocketListener.
   static SocketListener* /*new*/ new_() {
      return g_socket_listener_new();
   }

   // Blocks waiting for a client to connect to any of the sockets added
   // to the listener. Returns a #GSocketConnection for the socket that was
   // accepted.
   // 
   // If @source_object is not %NULL it will be filled out with the source
   // object specified when the corresponding socket or address was added
   // to the listener.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // RETURNS: a #GSocketConnection on success, %NULL on error.
   // <source_object>: location where #GObject pointer will be stored, or %NULL
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   SocketConnection* /*new*/ accept(/*out*/ GObject2.Object** source_object, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_listener_accept(&this, source_object, cancellable, error);
   }

   // This is the asynchronous version of g_socket_listener_accept().
   // 
   // When the operation is finished @callback will be
   // called. You can then call g_socket_listener_accept_socket()
   // to get the result of the operation.
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: a #GAsyncReadyCallback
   // <user_data>: user data for the callback
   void accept_async(Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_socket_listener_accept_async(&this, cancellable, callback, user_data);
   }

   // Finishes an async accept operation. See g_socket_listener_accept_async()
   // RETURNS: a #GSocketConnection on success, %NULL on error.
   // <result>: a #GAsyncResult.
   // <source_object>: Optional #GObject identifying this source
   SocketConnection* /*new*/ accept_finish(AsyncResult* result, /*out*/ GObject2.Object** source_object, GLib2.Error** error=null) {
      return g_socket_listener_accept_finish(&this, result, source_object, error);
   }

   // Blocks waiting for a client to connect to any of the sockets added
   // to the listener. Returns the #GSocket that was accepted.
   // 
   // If you want to accept the high-level #GSocketConnection, not a #GSocket,
   // which is often the case, then you should use g_socket_listener_accept()
   // instead.
   // 
   // If @source_object is not %NULL it will be filled out with the source
   // object specified when the corresponding socket or address was added
   // to the listener.
   // 
   // If @cancellable is not %NULL, then the operation can be cancelled by
   // triggering the cancellable object from another thread. If the operation
   // was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
   // RETURNS: a #GSocket on success, %NULL on error.
   // <source_object>: location where #GObject pointer will be stored, or %NULL.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   Socket* /*new*/ accept_socket(/*out*/ GObject2.Object** source_object, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_socket_listener_accept_socket(&this, source_object, cancellable, error);
   }

   // This is the asynchronous version of g_socket_listener_accept_socket().
   // 
   // When the operation is finished @callback will be
   // called. You can then call g_socket_listener_accept_socket_finish()
   // to get the result of the operation.
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: a #GAsyncReadyCallback
   // <user_data>: user data for the callback
   void accept_socket_async(Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_socket_listener_accept_socket_async(&this, cancellable, callback, user_data);
   }

   // Finishes an async accept operation. See g_socket_listener_accept_socket_async()
   // RETURNS: a #GSocket on success, %NULL on error.
   // <result>: a #GAsyncResult.
   // <source_object>: Optional #GObject identifying this source
   Socket* /*new*/ accept_socket_finish(AsyncResult* result, /*out*/ GObject2.Object** source_object, GLib2.Error** error=null) {
      return g_socket_listener_accept_socket_finish(&this, result, source_object, error);
   }

   // Creates a socket of type @type and protocol @protocol, binds
   // it to @address and adds it to the set of sockets we're accepting
   // sockets from.
   // 
   // Note that adding an IPv6 address, depending on the platform,
   // may or may not result in a listener that also accepts IPv4
   // connections.  For more deterministic behavior, see
   // g_socket_listener_add_inet_port().
   // 
   // @source_object will be passed out in the various calls
   // to accept to identify this particular source, which is
   // useful if you're listening on multiple addresses and do
   // different things depending on what address is connected to.
   // 
   // If successful and @effective_address is non-%NULL then it will
   // be set to the address that the binding actually occurred at.  This
   // is helpful for determining the port number that was used for when
   // requesting a binding to port 0 (ie: "any port").  This address, if
   // requested, belongs to the caller and must be freed.
   // RETURNS: %TRUE on success, %FALSE on error.
   // <address>: a #GSocketAddress
   // <type>: a #GSocketType
   // <protocol>: a #GSocketProtocol
   // <source_object>: Optional #GObject identifying this source
   // <effective_address>: location to store the address that was bound to, or %NULL.
   int add_address(SocketAddress* address, SocketType type, SocketProtocol protocol, GObject2.Object* source_object, /*out*/ SocketAddress** effective_address, GLib2.Error** error=null) {
      return g_socket_listener_add_address(&this, address, type, protocol, source_object, effective_address, error);
   }

   // Listens for TCP connections on any available port number for both
   // IPv6 and IPv4 (if each is available).
   // 
   // This is useful if you need to have a socket for incoming connections
   // but don't care about the specific port number.
   // 
   // @source_object will be passed out in the various calls
   // to accept to identify this particular source, which is
   // useful if you're listening on multiple addresses and do
   // different things depending on what address is connected to.
   // RETURNS: the port number, or 0 in case of failure.
   // <source_object>: Optional #GObject identifying this source
   ushort add_any_inet_port(GObject2.Object* source_object, GLib2.Error** error=null) {
      return g_socket_listener_add_any_inet_port(&this, source_object, error);
   }

   // Helper function for g_socket_listener_add_address() that
   // creates a TCP/IP socket listening on IPv4 and IPv6 (if
   // supported) on the specified port on all interfaces.
   // 
   // @source_object will be passed out in the various calls
   // to accept to identify this particular source, which is
   // useful if you're listening on multiple addresses and do
   // different things depending on what address is connected to.
   // RETURNS: %TRUE on success, %FALSE on error.
   // <port>: an IP port number (non-zero)
   // <source_object>: Optional #GObject identifying this source
   int add_inet_port(ushort port, GObject2.Object* source_object, GLib2.Error** error=null) {
      return g_socket_listener_add_inet_port(&this, port, source_object, error);
   }

   // Adds @socket to the set of sockets that we try to accept
   // new clients from. The socket must be bound to a local
   // address and listened to.
   // 
   // @source_object will be passed out in the various calls
   // to accept to identify this particular source, which is
   // useful if you're listening on multiple addresses and do
   // different things depending on what address is connected to.
   // RETURNS: %TRUE on success, %FALSE on error.
   // <socket>: a listening #GSocket
   // <source_object>: Optional #GObject identifying this source
   int add_socket(Socket* socket, GObject2.Object* source_object, GLib2.Error** error=null) {
      return g_socket_listener_add_socket(&this, socket, source_object, error);
   }
   // Closes all the sockets in the listener.
   void close() {
      g_socket_listener_close(&this);
   }

   // Sets the listen backlog on the sockets in the listener.
   // 
   // See g_socket_set_listen_backlog() for details
   // <listen_backlog>: an integer
   void set_backlog(int listen_backlog) {
      g_socket_listener_set_backlog(&this, listen_backlog);
   }
}

struct SocketListenerClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (SocketListener* listener) changed;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
   extern (C) void function () _g_reserved6;
}

struct SocketListenerPrivate {
}


// Flags used in g_socket_receive_message() and g_socket_send_message().
// The flags listed in the enum are some commonly available flags, but the
// values used for them are the same as on the platform, and any other flags
// are passed in/out as is. So to use a platform specific flag, just include
// the right system header and pass in the flag.
enum SocketMsgFlags /* Version 2.22 */ {
   NONE = 0,
   OOB = 1,
   PEEK = 2,
   DONTROUTE = 4
}
struct SocketPrivate {
}


// A protocol identifier is specified when creating a #GSocket, which is a
// family/type specific identifier, where 0 means the default protocol for
// the particular family/type.
// 
// This enum contains a set of commonly available and used protocols. You
// can also pass any other identifiers handled by the platform in order to
// use protocols not listed here.
enum SocketProtocol /* Version 2.22 */ {
   UNKNOWN = -1,
   DEFAULT = 0,
   TCP = 6,
   UDP = 17,
   SCTP = 132
}

// A #GSocketService is an object that represents a service that
// is provided to the network or over local sockets.  When a new
// connection is made to the service the #GSocketService::incoming
// signal is emitted.
// 
// A #GSocketService is a subclass of #GSocketListener and you need
// to add the addresses you want to accept connections on with the
// #GSocketListener APIs.
// 
// There are two options for implementing a network service based on
// #GSocketService. The first is to create the service using
// g_socket_service_new() and to connect to the #GSocketService::incoming
// signal. The second is to subclass #GSocketService and override the
// default signal handler implementation.
// 
// In either case, the handler must immediately return, or else it
// will block additional incoming connections from being serviced.
// If you are interested in writing connection handlers that contain
// blocking code then see #GThreadedSocketService.
// 
// The socket service runs on the main loop in the main thread, and is
// not threadsafe in general. However, the calls to start and stop
// the service are threadsafe so these can be used from threads that
// handle incoming clients.
struct SocketService /* : SocketListener */ /* Version 2.22 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance socketlistener;
   SocketListener parent_instance;
   SocketServicePrivate* priv;


   // Creates a new #GSocketService with no sockets to listen for.
   // New listeners can be added with e.g. g_socket_listener_add_address()
   // or g_socket_listener_add_inet_port().
   // RETURNS: a new #GSocketService.
   static SocketService* /*new*/ new_() {
      return g_socket_service_new();
   }

   // Check whether the service is active or not. An active
   // service will accept new clients that connect, while
   // a non-active service will let connecting clients queue
   // up until the service is started.
   // RETURNS: %TRUE if the service is active, %FALSE otherwise
   int is_active() {
      return g_socket_service_is_active(&this);
   }

   // Starts the service, i.e. start accepting connections
   // from the added sockets when the mainloop runs.
   // 
   // This call is threadsafe, so it may be called from a thread
   // handling an incoming client request.
   void start() {
      g_socket_service_start(&this);
   }

   // Stops the service, i.e. stops accepting connections
   // from the added sockets when the mainloop runs.
   // 
   // This call is threadsafe, so it may be called from a thread
   // handling an incoming client request.
   void stop() {
      g_socket_service_stop(&this);
   }

   // The ::incoming signal is emitted when a new incoming connection
   // to @service needs to be handled. The handler must initiate the
   // handling of @connection, but may not block; in essence,
   // asynchronous operations must be used.
   // 
   // @connection will be unreffed once the signal handler returns,
   // so you need to ref it yourself if you are planning to use it.
   // RETURNS: %TRUE to stop other handlers from being called
   // <connection>: a new #GSocketConnection object
   // <source_object>: the source_object passed to g_socket_listener_add_address()
   extern (C) alias static c_int function (SocketService* this_, SocketConnection* connection, GObject2.Object* source_object, void* user_data=null) signal_incoming;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"incoming", CB:signal_incoming)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"incoming",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct SocketServiceClass {
   SocketListenerClass parent_class;
   extern (C) int function (SocketService* service, SocketConnection* connection, GObject2.Object* source_object) incoming;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
   extern (C) void function () _g_reserved6;
}

struct SocketServicePrivate {
}


// This is the function type of the callback used for the #GSource
// returned by g_socket_create_source().
// RETURNS: it should return %FALSE if the source should be removed.
// <socket>: the #GSocket
// <condition>: the current condition at the source fired.
// <user_data>: data passed in by the user.
extern (C) alias int function (Socket* socket, GLib2.IOCondition condition, void* user_data) SocketSourceFunc;


// Flags used when creating a #GSocket. Some protocols may not implement
// all the socket types.
enum SocketType /* Version 2.22 */ {
   INVALID = 0,
   STREAM = 1,
   DATAGRAM = 2,
   SEQPACKET = 3
}

// SRV (service) records are used by some network protocols to provide
// service-specific aliasing and load-balancing. For example, XMPP
// (Jabber) uses SRV records to locate the XMPP server for a domain;
// rather than connecting directly to "example.com" or assuming a
// specific server hostname like "xmpp.example.com", an XMPP client
// would look up the "xmpp-client" SRV record for "example.com", and
// then connect to whatever host was pointed to by that record.
// 
// You can use g_resolver_lookup_service() or
// g_resolver_lookup_service_async() to find the #GSrvTarget<!-- -->s
// for a given service. However, if you are simply planning to connect
// to the remote service, you can use #GNetworkService's
// #GSocketConnectable interface and not need to worry about
// #GSrvTarget at all.
struct SrvTarget {

   // Creates a new #GSrvTarget with the given parameters.
   // 
   // You should not need to use this; normally #GSrvTarget<!-- -->s are
   // created by #GResolver.
   // RETURNS: a new #GSrvTarget.
   // <hostname>: the host that the service is running on
   // <port>: the port that the service is running on
   // <priority>: the target's priority
   // <weight>: the target's weight
   static SrvTarget* /*new*/ new_(char* hostname, ushort port, ushort priority, ushort weight) {
      return g_srv_target_new(hostname, port, priority, weight);
   }

   // Copies @target
   // RETURNS: a copy of @target
   SrvTarget* /*new*/ copy() {
      return g_srv_target_copy(&this);
   }
   // Frees @target
   void free() {
      g_srv_target_free(&this);
   }

   // Gets @target's hostname (in ASCII form; if you are going to present
   // this to the user, you should use g_hostname_is_ascii_encoded() to
   // check if it contains encoded Unicode segments, and use
   // g_hostname_to_unicode() to convert it if it does.)
   // RETURNS: @target's hostname
   char* get_hostname() {
      return g_srv_target_get_hostname(&this);
   }

   // Gets @target's port
   // RETURNS: @target's port
   ushort get_port() {
      return g_srv_target_get_port(&this);
   }

   // Gets @target's priority. You should not need to look at this;
   // #GResolver already sorts the targets according to the algorithm in
   // RFC 2782.
   // RETURNS: @target's priority
   ushort get_priority() {
      return g_srv_target_get_priority(&this);
   }

   // Gets @target's weight. You should not need to look at this;
   // #GResolver already sorts the targets according to the algorithm in
   // RFC 2782.
   // RETURNS: @target's weight
   ushort get_weight() {
      return g_srv_target_get_weight(&this);
   }

   // Unintrospectable function: list_sort() / g_srv_target_list_sort()
   // Sorts @targets in place according to the algorithm in RFC 2782.
   // RETURNS: the head of the sorted list.
   // <targets>: a #GList of #GSrvTarget
   static GLib2.List* /*new*/ list_sort(GLib2.List* targets) {
      return g_srv_target_list_sort(targets);
   }
}

enum TLS_BACKEND_EXTENSION_POINT_NAME = "gio-tls-backend";
enum TLS_DATABASE_PURPOSE_AUTHENTICATE_CLIENT = "1.3.6.1.5.5.7.3.2";
enum TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER = "1.3.6.1.5.5.7.3.1";

// This is the subclass of #GSocketConnection that is created
// for TCP/IP sockets.
struct TcpConnection /* : SocketConnection */ /* Version 2.22 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance socketconnection;
   SocketConnection parent_instance;
   TcpConnectionPrivate* priv;


   // Checks if graceful disconnects are used. See
   // g_tcp_connection_set_graceful_disconnect().
   // RETURNS: %TRUE if graceful disconnect is used on close, %FALSE otherwise
   int get_graceful_disconnect() {
      return g_tcp_connection_get_graceful_disconnect(&this);
   }

   // This enabled graceful disconnects on close. A graceful disconnect
   // means that we signal the receiving end that the connection is terminated
   // and wait for it to close the connection before closing the connection.
   // 
   // A graceful disconnect means that we can be sure that we successfully sent
   // all the outstanding data to the other end, or get an error reported.
   // However, it also means we have to wait for all the data to reach the
   // other side and for it to acknowledge this by closing the socket, which may
   // take a while. For this reason it is disabled by default.
   // <graceful_disconnect>: Whether to do graceful disconnects or not
   void set_graceful_disconnect(int graceful_disconnect) {
      g_tcp_connection_set_graceful_disconnect(&this, graceful_disconnect);
   }
}

struct TcpConnectionClass {
   SocketConnectionClass parent_class;
}

struct TcpConnectionPrivate {
}


// A #GTcpWrapperConnection can be used to wrap a #GIOStream that is
// based on a #GSocket, but which is not actually a
// #GSocketConnection. This is used by #GSocketClient so that it can
// always return a #GSocketConnection, even when the connection it has
// actually created is not directly a #GSocketConnection.
struct TcpWrapperConnection /* : TcpConnection */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance tcpconnection;
   TcpConnection parent_instance;
   TcpWrapperConnectionPrivate* priv;


   // Wraps @base_io_stream and @socket together as a #GSocketConnection.
   // RETURNS: the new #GSocketConnection.
   // <base_io_stream>: the #GIOStream to wrap
   // <socket>: the #GSocket associated with @base_io_stream
   static TcpWrapperConnection* /*new*/ new_(IOStream* base_io_stream, Socket* socket) {
      return g_tcp_wrapper_connection_new(base_io_stream, socket);
   }

   // Get's @conn's base #GIOStream
   // RETURNS: @conn's base #GIOStream
   IOStream* get_base_io_stream() {
      return g_tcp_wrapper_connection_get_base_io_stream(&this);
   }
}

struct TcpWrapperConnectionClass {
   TcpConnectionClass parent_class;
}

struct TcpWrapperConnectionPrivate {
}


// #GThemedIcon is an implementation of #GIcon that supports icon themes.
// #GThemedIcon contains a list of all of the icons present in an icon
// theme, so that icons can be looked up quickly. #GThemedIcon does
// not provide actual pixmaps for icons, just the icon names.
// Ideally something like gtk_icon_theme_choose_icon() should be used to
// resolve the list of names so that fallback icons work nicely with
// themes that inherit other themes.
struct ThemedIcon /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new themed icon for @iconname.
   // RETURNS: a new #GThemedIcon.
   // <iconname>: a string containing an icon name.
   static Icon* /*new*/ new_(char* iconname) {
      return g_themed_icon_new(iconname);
   }

   // Creates a new themed icon for @iconnames.
   // RETURNS: a new #GThemedIcon
   // <iconnames>: an array of strings containing icon names.
   // <len>: the length of the @iconnames array, or -1 if @iconnames is %NULL-terminated
   static Icon* /*new*/ new_from_names(char** iconnames, int len) {
      return g_themed_icon_new_from_names(iconnames, len);
   }

   // Creates a new themed icon for @iconname, and all the names
   // that can be created by shortening @iconname at '-' characters.
   // 
   // In the following example, @icon1 and @icon2 are equivalent:
   // |[
   // const char *names[] = {
   // "gnome-dev-cdrom-audio",
   // "gnome-dev-cdrom",
   // "gnome-dev",
   // "gnome"
   // };
   // 
   // icon1 = g_themed_icon_new_from_names (names, 4);
   // icon2 = g_themed_icon_new_with_default_fallbacks ("gnome-dev-cdrom-audio");
   // ]|
   // RETURNS: a new #GThemedIcon.
   // <iconname>: a string containing an icon name
   static Icon* /*new*/ new_with_default_fallbacks(char* iconname) {
      return g_themed_icon_new_with_default_fallbacks(iconname);
   }

   // Append a name to the list of icons from within @icon.
   // 
   // <note><para>
   // Note that doing so invalidates the hash computed by prior calls
   // to g_icon_hash().
   // </para></note>
   // <iconname>: name of icon to append to list of icons from within @icon.
   void append_name(char* iconname) {
      g_themed_icon_append_name(&this, iconname);
   }

   // Gets the names of icons from within @icon.
   // RETURNS: a list of icon names.
   char** get_names() {
      return g_themed_icon_get_names(&this);
   }

   // Prepend a name to the list of icons from within @icon.
   // 
   // <note><para>
   // Note that doing so invalidates the hash computed by prior calls
   // to g_icon_hash().
   // </para></note>
   // <iconname>: name of icon to prepend to list of icons from within @icon.
   void prepend_name(char* iconname) {
      g_themed_icon_prepend_name(&this, iconname);
   }
}

struct ThemedIconClass {
}


// A #GThreadedSocketService is a simple subclass of #GSocketService
// that handles incoming connections by creating a worker thread and
// dispatching the connection to it by emitting the
// #GThreadedSocketService::run signal in the new thread.
// 
// The signal handler may perform blocking IO and need not return
// until the connection is closed.
// 
// The service is implemented using a thread pool, so there is a
// limited amount of threads available to serve incoming requests.
// The service automatically stops the #GSocketService from accepting
// new connections when all threads are busy.
// 
// As with #GSocketService, you may connect to #GThreadedSocketService::run,
// or subclass and override the default handler.
struct ThreadedSocketService /* : SocketService */ /* Version 2.22 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance socketservice;
   SocketService parent_instance;
   ThreadedSocketServicePrivate* priv;


   // Creates a new #GThreadedSocketService with no listeners. Listeners
   // must be added with one of the #GSocketListener "add" methods.
   // RETURNS: a new #GSocketService.
   // <max_threads>: the maximal number of threads to execute concurrently handling incoming clients, -1 means no limit
   static ThreadedSocketService* /*new*/ new_(int max_threads) {
      return g_threaded_socket_service_new(max_threads);
   }

   // The ::run signal is emitted in a worker thread in response to an
   // incoming connection. This thread is dedicated to handling
   // @connection and may perform blocking IO. The signal handler need
   // not return until the connection is closed.
   // RETURNS: %TRUE to stop further signal handlers from being called
   // <connection>: a new #GSocketConnection object.
   // <source_object>: the source_object passed to g_socket_listener_add_address().
   extern (C) alias static c_int function (ThreadedSocketService* this_, SocketConnection* connection, GObject2.Object* source_object, void* user_data=null) signal_run;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"run", CB:signal_run)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"run",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ThreadedSocketServiceClass {
   SocketServiceClass parent_class;
   extern (C) int function (ThreadedSocketService* service, SocketConnection* connection, GObject2.Object* source_object) run;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct ThreadedSocketServicePrivate {
}

// The client authentication mode for a #GTlsServerConnection.
enum TlsAuthenticationMode /* Version 2.28 */ {
   NONE = 0,
   REQUESTED = 1,
   REQUIRED = 2
}
struct TlsBackend /* Version 2.28 */ {

   // Gets the default #GTlsBackend for the system.
   // RETURNS: a #GTlsBackend
   static TlsBackend* get_default() {
      return g_tls_backend_get_default();
   }

   // Gets the #GType of @backend's #GTlsCertificate implementation.
   // 
   // implementation.
   // RETURNS: the #GType of @backend's #GTlsCertificate
   Type get_certificate_type() {
      return g_tls_backend_get_certificate_type(&this);
   }

   // Gets the #GType of @backend's #GTlsClientConnection implementation.
   // 
   // implementation.
   // RETURNS: the #GType of @backend's #GTlsClientConnection
   Type get_client_connection_type() {
      return g_tls_backend_get_client_connection_type(&this);
   }

   // Gets the default #GTlsDatabase used to verify TLS connections.
   // 
   // unreffed when done.
   // RETURNS: the default database, which should be
   TlsDatabase* /*new*/ get_default_database() {
      return g_tls_backend_get_default_database(&this);
   }

   // Gets the #GTyep of @backend's #GTlsFileDatabase implementation.
   // RETURNS: the #GType of backend's #GTlsFileDatabase implementation.
   Type get_file_database_type() {
      return g_tls_backend_get_file_database_type(&this);
   }

   // Gets the #GType of @backend's #GTlsServerConnection implementation.
   // 
   // implementation.
   // RETURNS: the #GType of @backend's #GTlsServerConnection
   Type get_server_connection_type() {
      return g_tls_backend_get_server_connection_type(&this);
   }

   // Checks if TLS is supported; if this returns %FALSE for the default
   // #GTlsBackend, it means no "real" TLS backend is available.
   // RETURNS: whether or not TLS is supported
   int supports_tls() {
      return g_tls_backend_supports_tls(&this);
   }
}

// Provides an interface for describing TLS-related types.
struct TlsBackendInterface /* Version 2.28 */ {
   GObject2.TypeInterface g_iface;
   // RETURNS: whether or not TLS is supported
   extern (C) int function (TlsBackend* backend) supports_tls;
   extern (C) Type function () get_certificate_type;
   extern (C) Type function () get_client_connection_type;
   extern (C) Type function () get_server_connection_type;
   extern (C) Type function () get_file_database_type;
   // RETURNS: the default database, which should be
   extern (C) TlsDatabase* /*new*/ function (TlsBackend* backend) get_default_database;
}


// A certificate used for TLS authentication and encryption.
// This can represent either a public key only (eg, the certificate
// received by a client from a server), or the combination of
// a public key and a private key (which is needed when acting as a
// #GTlsServerConnection).
struct TlsCertificate /* : GObject.Object */ /* Version 2.28 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   TlsCertificatePrivate* priv;


   // Creates a #GTlsCertificate from the PEM-encoded data in @file. If
   // @file cannot be read or parsed, the function will return %NULL and
   // set @error. Otherwise, this behaves like g_tls_certificate_new().
   // RETURNS: the new certificate, or %NULL on error
   // <file>: file containing a PEM-encoded certificate to import
   static TlsCertificate* /*new*/ new_from_file(char* file, GLib2.Error** error=null) {
      return g_tls_certificate_new_from_file(file, error);
   }

   // Creates a #GTlsCertificate from the PEM-encoded data in @cert_file
   // and @key_file. If either file cannot be read or parsed, the
   // function will return %NULL and set @error. Otherwise, this behaves
   // like g_tls_certificate_new().
   // RETURNS: the new certificate, or %NULL on error
   // <cert_file>: file containing a PEM-encoded certificate to import
   // <key_file>: file containing a PEM-encoded private key to import
   static TlsCertificate* /*new*/ new_from_files(char* cert_file, char* key_file, GLib2.Error** error=null) {
      return g_tls_certificate_new_from_files(cert_file, key_file, error);
   }

   // Creates a new #GTlsCertificate from the PEM-encoded data in @data.
   // If @data includes both a certificate and a private key, then the
   // returned certificate will include the private key data as well.
   // 
   // If @data includes multiple certificates, only the first one will be
   // parsed.
   // RETURNS: the new certificate, or %NULL if @data is invalid
   // <data>: PEM-encoded certificate data
   // <length>: the length of @data, or -1 if it's 0-terminated.
   static TlsCertificate* /*new*/ new_from_pem(char* data, ssize_t length, GLib2.Error** error=null) {
      return g_tls_certificate_new_from_pem(data, length, error);
   }

   // Creates one or more #GTlsCertificate<!-- -->s from the PEM-encoded
   // data in @file. If @file cannot be read or parsed, the function will
   // return %NULL and set @error. If @file does not contain any
   // PEM-encoded certificates, this will return an empty list and not
   // set @error.
   // 
   // #GList containing #GTlsCertificate objects. You must free the list
   // and its contents when you are done with it.
   // RETURNS: a
   // <file>: file containing PEM-encoded certificates to import
   static GLib2.List* /*new*/ list_new_from_file(char* file, GLib2.Error** error=null) {
      return g_tls_certificate_list_new_from_file(file, error);
   }

   // Gets the #GTlsCertificate representing @cert's issuer, if known
   // 
   // or %NULL if @cert is self-signed or signed with an unknown
   // certificate.
   // RETURNS: The certificate of @cert's issuer,
   TlsCertificate* get_issuer() {
      return g_tls_certificate_get_issuer(&this);
   }

   // This verifies @cert and returns a set of #GTlsCertificateFlags
   // indicating any problems found with it. This can be used to verify a
   // certificate outside the context of making a connection, or to
   // check a certificate against a CA that is not part of the system
   // CA database.
   // 
   // If @identity is not %NULL, @cert's name(s) will be compared against
   // it, and %G_TLS_CERTIFICATE_BAD_IDENTITY will be set in the return
   // value if it does not match. If @identity is %NULL, that bit will
   // never be set in the return value.
   // 
   // If @trusted_ca is not %NULL, then @cert (or one of the certificates
   // in its chain) must be signed by it, or else
   // %G_TLS_CERTIFICATE_UNKNOWN_CA will be set in the return value. If
   // @trusted_ca is %NULL, that bit will never be set in the return
   // value.
   // 
   // (All other #GTlsCertificateFlags values will always be set or unset
   // as appropriate.)
   // RETURNS: the appropriate #GTlsCertificateFlags
   // <identity>: the expected peer identity
   // <trusted_ca>: the certificate of a trusted authority
   TlsCertificateFlags verify(SocketConnectable* identity=null, TlsCertificate* trusted_ca=null) {
      return g_tls_certificate_verify(&this, identity, trusted_ca);
   }
}

struct TlsCertificateClass {
   GObject2.ObjectClass parent_class;

   // RETURNS: the appropriate #GTlsCertificateFlags
   // <identity>: the expected peer identity
   // <trusted_ca>: the certificate of a trusted authority
   extern (C) TlsCertificateFlags function (TlsCertificate* cert, SocketConnectable* identity=null, TlsCertificate* trusted_ca=null) verify;
   private void*[8] padding;
}


// A set of flags describing TLS certification validation. This can be
// used to set which validation steps to perform (eg, with
// g_tls_client_connection_set_validation_flags()), or to describe why
// a particular certificate was rejected (eg, in
// #GTlsConnection::accept-certificate).
enum TlsCertificateFlags /* Version 2.28 */ {
   UNKNOWN_CA = 1,
   BAD_IDENTITY = 2,
   NOT_ACTIVATED = 4,
   EXPIRED = 8,
   REVOKED = 16,
   INSECURE = 32,
   GENERIC_ERROR = 64,
   VALIDATE_ALL = 127
}
struct TlsCertificatePrivate {
}


// #GTlsClientConnection is the client-side subclass of
// #GTlsConnection, representing a client-side TLS connection.
struct TlsClientConnection /* Version 2.28 */ {

   // Creates a new #GTlsClientConnection wrapping @base_io_stream (which
   // must have pollable input and output streams) which is assumed to
   // communicate with the server identified by @server_identity.
   // RETURNS: the new #GTlsClientConnection, or %NULL on error
   // <base_io_stream>: the #GIOStream to wrap
   // <server_identity>: the expected identity of the server
   static IOStream* /*new*/ new_(IOStream* base_io_stream, SocketConnectable* server_identity, GLib2.Error** error=null) {
      return g_tls_client_connection_new(base_io_stream, server_identity, error);
   }

   // Gets the list of distinguished names of the Certificate Authorities
   // that the server will accept certificates from. This will be set
   // during the TLS handshake if the server requests a certificate.
   // Otherwise, it will be %NULL.
   // 
   // Each item in the list is a #GByteArray which contains the complete
   // subject DN of the certificate authority.
   // 
   // CA DNs. You should unref each element with g_byte_array_unref() and then
   // the free the list with g_list_free().
   // RETURNS: the list of
   GLib2.List* /*new*/ get_accepted_cas() {
      return g_tls_client_connection_get_accepted_cas(&this);
   }

   // Gets @conn's expected server identity
   // 
   // expected server identity, or %NULL if the expected identity is not
   // known.
   // RETURNS: a #GSocketConnectable describing the
   SocketConnectable* get_server_identity() {
      return g_tls_client_connection_get_server_identity(&this);
   }

   // Gets whether @conn will use SSL 3.0 rather than the
   // highest-supported version of TLS; see
   // g_tls_client_connection_set_use_ssl3().
   // RETURNS: whether @conn will use SSL 3.0
   int get_use_ssl3() {
      return g_tls_client_connection_get_use_ssl3(&this);
   }

   // Gets @conn's validation flags
   // RETURNS: the validation flags
   TlsCertificateFlags get_validation_flags() {
      return g_tls_client_connection_get_validation_flags(&this);
   }

   // Sets @conn's expected server identity, which is used both to tell
   // servers on virtual hosts which certificate to present, and also
   // to let @conn know what name to look for in the certificate when
   // performing %G_TLS_CERTIFICATE_BAD_IDENTITY validation, if enabled.
   // <identity>: a #GSocketConnectable describing the expected server identity
   void set_server_identity(SocketConnectable* identity) {
      g_tls_client_connection_set_server_identity(&this, identity);
   }

   // If @use_ssl3 is %TRUE, this forces @conn to use SSL 3.0 rather than
   // trying to properly negotiate the right version of TLS or SSL to use.
   // This can be used when talking to servers that do not implement the
   // fallbacks correctly and which will therefore fail to handshake with
   // a "modern" TLS handshake attempt.
   // <use_ssl3>: whether to use SSL 3.0
   void set_use_ssl3(int use_ssl3) {
      g_tls_client_connection_set_use_ssl3(&this, use_ssl3);
   }

   // Sets @conn's validation flags, to override the default set of
   // checks performed when validating a server certificate. By default,
   // %G_TLS_CERTIFICATE_VALIDATE_ALL is used.
   // <flags>: the #GTlsCertificateFlags to use
   void set_validation_flags(TlsCertificateFlags flags) {
      g_tls_client_connection_set_validation_flags(&this, flags);
   }
}

struct TlsClientConnectionInterface {
   GObject2.TypeInterface g_iface;
}


// #GTlsConnection is the base TLS connection class type, which wraps
// a #GIOStream and provides TLS encryption on top of it. Its
// subclasses, #GTlsClientConnection and #GTlsServerConnection,
// implement client-side and server-side TLS, respectively.
struct TlsConnection /* : IOStream */ /* Version 2.28 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance iostream;
   IOStream parent_instance;
   TlsConnectionPrivate* priv;


   // Used by #GTlsConnection implementations to emit the
   // #GTlsConnection::accept-certificate signal.
   // 
   // %TRUE to accept @peer_cert
   // RETURNS: %TRUE if one of the signal handlers has returned
   // <peer_cert>: the peer's #GTlsCertificate
   // <errors>: the problems with @peer_cert
   int emit_accept_certificate(TlsCertificate* peer_cert, TlsCertificateFlags errors) {
      return g_tls_connection_emit_accept_certificate(&this, peer_cert, errors);
   }

   // Gets @conn's certificate, as set by
   // g_tls_connection_set_certificate().
   // RETURNS: @conn's certificate, or %NULL
   TlsCertificate* get_certificate() {
      return g_tls_connection_get_certificate(&this);
   }

   // Gets the certificate database that @conn uses to verify
   // peer certificates. See g_tls_connection_set_database().
   // RETURNS: the certificate database that @conn uses or %NULL
   TlsDatabase* get_database() {
      return g_tls_connection_get_database(&this);
   }

   // Get the object that will be used to interact with the user. It will be used
   // for things like prompting the user for passwords. If %NULL is returned, then
   // no user interaction will occur for this connection.
   // RETURNS: The interaction object.
   TlsInteraction* get_interaction() {
      return g_tls_connection_get_interaction(&this);
   }

   // Gets @conn's peer's certificate after the handshake has completed.
   // (It is not set during the emission of
   // #GTlsConnection::accept-certificate.)
   // RETURNS: @conn's peer's certificate, or %NULL
   TlsCertificate* get_peer_certificate() {
      return g_tls_connection_get_peer_certificate(&this);
   }

   // Gets the errors associated with validating @conn's peer's
   // certificate, after the handshake has completed. (It is not set
   // during the emission of #GTlsConnection::accept-certificate.)
   // RETURNS: @conn's peer's certificate errors
   TlsCertificateFlags get_peer_certificate_errors() {
      return g_tls_connection_get_peer_certificate_errors(&this);
   }

   // Gets @conn rehandshaking mode. See
   // g_tls_connection_set_rehandshake_mode() for details.
   // RETURNS: @conn's rehandshaking mode
   TlsRehandshakeMode get_rehandshake_mode() {
      return g_tls_connection_get_rehandshake_mode(&this);
   }

   // Tests whether or not @conn expects a proper TLS close notification
   // when the connection is closed. See
   // g_tls_connection_set_require_close_notify() for details.
   // 
   // notification.
   // RETURNS: %TRUE if @conn requires a proper TLS close
   int get_require_close_notify() {
      return g_tls_connection_get_require_close_notify(&this);
   }

   // Gets whether @conn uses the system certificate database to verify
   // peer certificates. See g_tls_connection_set_use_system_certdb().
   // RETURNS: whether @conn uses the system certificate database
   int get_use_system_certdb() {
      return g_tls_connection_get_use_system_certdb(&this);
   }

   // Attempts a TLS handshake on @conn.
   // 
   // On the client side, it is never necessary to call this method;
   // although the connection needs to perform a handshake after
   // connecting (or after sending a "STARTTLS"-type command) and may
   // need to rehandshake later if the server requests it,
   // #GTlsConnection will handle this for you automatically when you try
   // to send or receive data on the connection. However, you can call
   // g_tls_connection_handshake() manually if you want to know for sure
   // whether the initial handshake succeeded or failed (as opposed to
   // just immediately trying to write to @conn's output stream, in which
   // case if it fails, it may not be possible to tell if it failed
   // before or after completing the handshake).
   // 
   // Likewise, on the server side, although a handshake is necessary at
   // the beginning of the communication, you do not need to call this
   // function explicitly unless you want clearer error reporting.
   // However, you may call g_tls_connection_handshake() later on to
   // renegotiate parameters (encryption methods, etc) with the client.
   // 
   // #GTlsConnection::accept_certificate may be emitted during the
   // handshake.
   // RETURNS: success or failure
   // <cancellable>: a #GCancellable, or %NULL
   int handshake(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_tls_connection_handshake(&this, cancellable, error);
   }

   // Asynchronously performs a TLS handshake on @conn. See
   // g_tls_connection_handshake() for more information.
   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call when the handshake is complete
   // <user_data>: the data to pass to the callback function
   void handshake_async(int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_tls_connection_handshake_async(&this, io_priority, cancellable, callback, user_data);
   }

   // Finish an asynchronous TLS handshake operation. See
   // g_tls_connection_handshake() for more information.
   // 
   // case @error will be set.
   // RETURNS: %TRUE on success, %FALSE on failure, in which
   // <result>: a #GAsyncResult.
   int handshake_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_tls_connection_handshake_finish(&this, result, error);
   }

   // This sets the certificate that @conn will present to its peer
   // during the TLS handshake. For a #GTlsServerConnection, it is
   // mandatory to set this, and that will normally be done at construct
   // time.
   // 
   // For a #GTlsClientConnection, this is optional. If a handshake fails
   // with %G_TLS_ERROR_CERTIFICATE_REQUIRED, that means that the server
   // requires a certificate, and if you try connecting again, you should
   // call this method first. You can call
   // g_tls_client_connection_get_accepted_cas() on the failed connection
   // to get a list of Certificate Authorities that the server will
   // accept certificates from.
   // 
   // (It is also possible that a server will allow the connection with
   // or without a certificate; in that case, if you don't provide a
   // certificate, you can tell that the server requested one by the fact
   // that g_tls_client_connection_get_accepted_cas() will return
   // non-%NULL.)
   // <certificate>: the certificate to use for @conn
   void set_certificate(TlsCertificate* certificate) {
      g_tls_connection_set_certificate(&this, certificate);
   }

   // Sets the certificate database that is used to verify peer certificates.
   // This is set to the default database by default. See
   // g_tls_backend_get_default_database(). If set to %NULL, then
   // peer certificate validation will always set the
   // %G_TLS_CERTIFICATE_UNKNOWN_CA error (meaning
   // #GTlsConnection::accept-certificate will always be emitted on
   // client-side connections, unless that bit is not set in
   // #GTlsClientConnection:validation-flags).
   // <database>: a #GTlsDatabase
   void set_database(TlsDatabase* database) {
      g_tls_connection_set_database(&this, database);
   }

   // Set the object that will be used to interact with the user. It will be used
   // for things like prompting the user for passwords.
   // 
   // The @interaction argument will normally be a derived subclass of
   // #GTlsInteraction. %NULL can also be provided if no user interaction
   // should occur for this connection.
   // <interaction>: an interaction object, or %NULL
   void set_interaction(TlsInteraction* interaction=null) {
      g_tls_connection_set_interaction(&this, interaction);
   }

   // Sets how @conn behaves with respect to rehandshaking requests.
   // 
   // %G_TLS_REHANDSHAKE_NEVER means that it will never agree to
   // rehandshake after the initial handshake is complete. (For a client,
   // this means it will refuse rehandshake requests from the server, and
   // for a server, this means it will close the connection with an error
   // if the client attempts to rehandshake.)
   // 
   // %G_TLS_REHANDSHAKE_SAFELY means that the connection will allow a
   // rehandshake only if the other end of the connection supports the
   // TLS <literal>renegotiation_info</literal> extension. This is the
   // default behavior, but means that rehandshaking will not work
   // against older implementations that do not support that extension.
   // 
   // %G_TLS_REHANDSHAKE_UNSAFELY means that the connection will allow
   // rehandshaking even without the
   // <literal>renegotiation_info</literal> extension. On the server side
   // in particular, this is not recommended, since it leaves the server
   // open to certain attacks. However, this mode is necessary if you
   // need to allow renegotiation with older client software.
   // <mode>: the rehandshaking mode
   void set_rehandshake_mode(TlsRehandshakeMode mode) {
      g_tls_connection_set_rehandshake_mode(&this, mode);
   }

   // Sets whether or not @conn expects a proper TLS close notification
   // before the connection is closed. If this is %TRUE (the default),
   // then @conn will expect to receive a TLS close notification from its
   // peer before the connection is closed, and will return a
   // %G_TLS_ERROR_EOF error if the connection is closed without proper
   // notification (since this may indicate a network error, or
   // man-in-the-middle attack).
   // 
   // In some protocols, the application will know whether or not the
   // connection was closed cleanly based on application-level data
   // (because the application-level data includes a length field, or is
   // somehow self-delimiting); in this case, the close notify is
   // redundant and sometimes omitted. (TLS 1.1 explicitly allows this;
   // in TLS 1.0 it is technically an error, but often done anyway.) You
   // can use g_tls_connection_set_require_close_notify() to tell @conn
   // to allow an "unannounced" connection close, in which case the close
   // will show up as a 0-length read, as in a non-TLS
   // #GSocketConnection, and it is up to the application to check that
   // the data has been fully received.
   // 
   // Note that this only affects the behavior when the peer closes the
   // connection; when the application calls g_io_stream_close() itself
   // on @conn, this will send a close notification regardless of the
   // setting of this property. If you explicitly want to do an unclean
   // close, you can close @conn's #GTlsConnection:base-io-stream rather
   // than closing @conn itself.
   // <require_close_notify>: whether or not to require close notification
   void set_require_close_notify(int require_close_notify) {
      g_tls_connection_set_require_close_notify(&this, require_close_notify);
   }

   // Sets whether @conn uses the system certificate database to verify
   // peer certificates. This is %TRUE by default. If set to %FALSE, then
   // peer certificate validation will always set the
   // %G_TLS_CERTIFICATE_UNKNOWN_CA error (meaning
   // #GTlsConnection::accept-certificate will always be emitted on
   // client-side connections, unless that bit is not set in
   // #GTlsClientConnection:validation-flags).
   // <use_system_certdb>: whether to use the system certificate database
   void set_use_system_certdb(int use_system_certdb) {
      g_tls_connection_set_use_system_certdb(&this, use_system_certdb);
   }

   // Emitted during the TLS handshake after the peer certificate has
   // been received. You can examine @peer_cert's certification path by
   // calling g_tls_certificate_get_issuer() on it.
   // 
   // For a client-side connection, @peer_cert is the server's
   // certificate, and the signal will only be emitted if the
   // certificate was not acceptable according to @conn's
   // #GTlsClientConnection:validation_flags. If you would like the
   // certificate to be accepted despite @errors, return %TRUE from the
   // signal handler. Otherwise, if no handler accepts the certificate,
   // the handshake will fail with %G_TLS_ERROR_BAD_CERTIFICATE.
   // 
   // For a server-side connection, @peer_cert is the certificate
   // presented by the client, if this was requested via the server's
   // #GTlsServerConnection:authentication_mode. On the server side,
   // the signal is always emitted when the client presents a
   // certificate, and the certificate will only be accepted if a
   // handler returns %TRUE.
   // 
   // Note that if this signal is emitted as part of asynchronous I/O
   // in the main thread, then you should not attempt to interact with
   // the user before returning from the signal handler. If you want to
   // let the user decide whether or not to accept the certificate, you
   // would have to return %FALSE from the signal handler on the first
   // attempt, and then after the connection attempt returns a
   // %G_TLS_ERROR_HANDSHAKE, you can interact with the user, and if
   // the user decides to accept the certificate, remember that fact,
   // create a new connection, and return %TRUE from the signal handler
   // the next time.
   // 
   // If you are doing I/O in another thread, you do not
   // need to worry about this, and can simply block in the signal
   // handler until the UI thread returns an answer.
   // 
   // immediately end the signal emission). %FALSE to allow the signal
   // emission to continue, which will cause the handshake to fail if
   // no one else overrides it.
   // RETURNS: %TRUE to accept @peer_cert (which will also
   // <peer_cert>: the peer's #GTlsCertificate
   // <errors>: the problems with @peer_cert.
   extern (C) alias static c_int function (TlsConnection* this_, TlsCertificate* peer_cert, TlsCertificateFlags* errors, void* user_data=null) signal_accept_certificate;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"accept-certificate", CB:signal_accept_certificate)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"accept-certificate",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct TlsConnectionClass {
   IOStreamClass parent_class;
   extern (C) int function (TlsConnection* connection, TlsCertificate* peer_cert, TlsCertificateFlags errors) accept_certificate;

   // RETURNS: success or failure
   // <cancellable>: a #GCancellable, or %NULL
   extern (C) int function (TlsConnection* conn, Cancellable* cancellable, GLib2.Error** error=null) handshake;

   // <io_priority>: the <link linkend="io-priority">I/O priority</link> of the request.
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call when the handshake is complete
   // <user_data>: the data to pass to the callback function
   extern (C) void function (TlsConnection* conn, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) handshake_async;

   // RETURNS: %TRUE on success, %FALSE on failure, in which
   // <result>: a #GAsyncResult.
   extern (C) int function (TlsConnection* conn, AsyncResult* result, GLib2.Error** error=null) handshake_finish;
   private void*[8] padding;
}

struct TlsConnectionPrivate {
}


// #GTlsDatabase is used to lookup certificates and other information
// from a certificate or key store. It is an abstract base class which
// TLS library specific subtypes override.
// 
// Most common client applications will not directly interact with
// #GTlsDatabase. It is used internally by #GTlsConnection.
struct TlsDatabase /* : GObject.Object */ /* Version 2.30 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   TlsDatabasePrivate* priv;


   // Create a handle string for the certificate. The database will only be able
   // to create a handle for certificates that originate from the database. In
   // cases where the database cannot create a handle for a certificate, %NULL
   // will be returned.
   // 
   // This handle should be stable across various instances of the application,
   // and between applications. If a certificate is modified in the database,
   // then it is not guaranteed that this handle will continue to point to it.
   // RETURNS: a newly allocated string containing the handle.
   // <certificate>: certificate for which to create a handle.
   char* /*new*/ create_certificate_handle(TlsCertificate* certificate) {
      return g_tls_database_create_certificate_handle(&this, certificate);
   }

   // Lookup a certificate by its handle.
   // 
   // The handle should have been created by calling g_tls_database_create_handle()
   // on a #GTlsDatabase object of the same TLS backend. The handle is designed
   // to remain valid across instantiations of the database.
   // 
   // If the handle is no longer valid, or does not point to a certificate in
   // this database, then %NULL will be returned.
   // 
   // This function can block, use g_tls_database_lookup_certificate_for_handle_async() to perform
   // the lookup operation asynchronously.
   // 
   // #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate.
   // RETURNS: a newly allocated
   // <handle>: a certificate handle
   // <interaction>: used to interact with the user if necessary
   // <flags>: Flags which affect the lookup.
   // <cancellable>: a #GCancellable, or %NULL
   TlsCertificate* /*new*/ lookup_certificate_for_handle(char* handle, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_tls_database_lookup_certificate_for_handle(&this, handle, interaction, flags, cancellable, error);
   }

   // Asynchronously lookup a certificate by its handle in the database. See
   // g_tls_database_lookup_handle() for more information.
   // <handle>: a certificate handle
   // <interaction>: used to interact with the user if necessary
   // <flags>: Flags which affect the lookup.
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call when the operation completes
   // <user_data>: the data to pass to the callback function
   void lookup_certificate_for_handle_async(char* handle, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_tls_database_lookup_certificate_for_handle_async(&this, handle, interaction, flags, cancellable, callback, user_data);
   }

   // Finish an asynchronous lookup of a certificate by its handle. See
   // g_tls_database_lookup_handle() for more information.
   // 
   // If the handle is no longer valid, or does not point to a certificate in
   // this database, then %NULL will be returned.
   // 
   // Use g_object_unref() to release the certificate.
   // RETURNS: a newly allocated #GTlsCertificate object.
   // <result>: a #GAsyncResult.
   TlsCertificate* /*new*/ lookup_certificate_for_handle_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_tls_database_lookup_certificate_for_handle_finish(&this, result, error);
   }

   // Lookup the issuer of @certificate in the database.
   // 
   // The %issuer property
   // of @certificate is not modified, and the two certificates are not hooked
   // into a chain.
   // 
   // This function can block, use g_tls_database_lookup_certificate_issuer_async() to perform
   // the lookup operation asynchronously.
   // 
   // or %NULL. Use g_object_unref() to release the certificate.
   // RETURNS: a newly allocated issuer #GTlsCertificate,
   // <certificate>: a #GTlsCertificate
   // <interaction>: used to interact with the user if necessary
   // <flags>: flags which affect the lookup operation
   // <cancellable>: a #GCancellable, or %NULL
   TlsCertificate* /*new*/ lookup_certificate_issuer(TlsCertificate* certificate, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_tls_database_lookup_certificate_issuer(&this, certificate, interaction, flags, cancellable, error);
   }

   // Asynchronously lookup the issuer of @certificate in the database. See
   // g_tls_database_lookup_certificate_issuer() for more information.
   // <certificate>: a #GTlsCertificate
   // <interaction>: used to interact with the user if necessary
   // <flags>: flags which affect the lookup operation
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call when the operation completes
   // <user_data>: the data to pass to the callback function
   void lookup_certificate_issuer_async(TlsCertificate* certificate, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_tls_database_lookup_certificate_issuer_async(&this, certificate, interaction, flags, cancellable, callback, user_data);
   }

   // Finish an asynchronous lookup issuer operation. See
   // g_tls_database_lookup_certificate_issuer() for more information.
   // 
   // or %NULL. Use g_object_unref() to release the certificate.
   // RETURNS: a newly allocated issuer #GTlsCertificate,
   // <result>: a #GAsyncResult.
   TlsCertificate* /*new*/ lookup_certificate_issuer_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_tls_database_lookup_certificate_issuer_finish(&this, result, error);
   }

   // Unintrospectable method: lookup_certificates_issued_by() / g_tls_database_lookup_certificates_issued_by()
   // Lookup certificates issued by this issuer in the database.
   // 
   // This function can block, use g_tls_database_lookup_certificates_issued_by_async() to perform
   // the lookup operation asynchronously.
   // 
   // Use g_object_unref() on each certificate, and g_list_free() on the release the list.
   // RETURNS: a newly allocated list of #GTlsCertificate objects.
   // <issuer_raw_dn>: a #GByteArray which holds the DER encoded issuer DN.
   // <interaction>: used to interact with the user if necessary
   // <flags>: Flags which affect the lookup operation.
   // <cancellable>: a #GCancellable, or %NULL
   GLib2.List* /*new*/ lookup_certificates_issued_by(ByteArray* issuer_raw_dn, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_tls_database_lookup_certificates_issued_by(&this, issuer_raw_dn, interaction, flags, cancellable, error);
   }

   // Asynchronously lookup certificates issued by this issuer in the database. See
   // g_tls_database_lookup_certificates_issued_by() for more information.
   // 
   // The database may choose to hold a reference to the issuer byte array for the duration
   // of of this asynchronous operation. The byte array should not be modified during
   // this time.
   // <issuer_raw_dn>: a #GByteArray which holds the DER encoded issuer DN.
   // <interaction>: used to interact with the user if necessary
   // <flags>: Flags which affect the lookup operation.
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call when the operation completes
   // <user_data>: the data to pass to the callback function
   void lookup_certificates_issued_by_async(ByteArray* issuer_raw_dn, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_tls_database_lookup_certificates_issued_by_async(&this, issuer_raw_dn, interaction, flags, cancellable, callback, user_data);
   }

   // Unintrospectable method: lookup_certificates_issued_by_finish() / g_tls_database_lookup_certificates_issued_by_finish()
   // Finish an asynchronous lookup of certificates. See
   // g_tls_database_lookup_certificates_issued_by() for more information.
   // 
   // Use g_object_unref() on each certificate, and g_list_free() on the release the list.
   // RETURNS: a newly allocated list of #GTlsCertificate objects.
   // <result>: a #GAsyncResult.
   GLib2.List* /*new*/ lookup_certificates_issued_by_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_tls_database_lookup_certificates_issued_by_finish(&this, result, error);
   }

   // Verify's a certificate chain after looking up and adding any missing
   // certificates to the chain.
   // 
   // @chain is a chain of #GTlsCertificate objects each pointing to the next
   // certificate in the chain by its %issuer property. The chain may initially
   // consist of one or more certificates. After the verification process is
   // complete, @chain may be modified by adding missing certificates, or removing
   // extra certificates. If a certificate anchor was found, then it is added to
   // the @chain.
   // 
   // @purpose describes the purpose (or usage) for which the certificate
   // is being used. Typically @purpose will be set to #G_TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER
   // which means that the certificate is being used to authenticate a server
   // (and we are acting as the client).
   // 
   // The @identity is used to check for pinned certificates (trust exceptions)
   // in the database. These will override the normal verification process on a
   // host by host basis.
   // 
   // Currently there are no @flags, and %G_TLS_DATABASE_VERIFY_NONE should be
   // used.
   // 
   // This function can block, use g_tls_database_verify_chain_async() to perform
   // the verification operation asynchronously.
   // 
   // result of verification.
   // RETURNS: the appropriate #GTlsCertificateFlags which represents the
   // <chain>: a #GTlsCertificate chain
   // <purpose>: the purpose that this certificate chain will be used for.
   // <identity>: the expected peer identity
   // <interaction>: used to interact with the user if necessary
   // <flags>: additional verify flags
   // <cancellable>: a #GCancellable, or %NULL
   TlsCertificateFlags verify_chain(TlsCertificate* chain, char* purpose, SocketConnectable* identity, TlsInteraction* interaction, TlsDatabaseVerifyFlags flags, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_tls_database_verify_chain(&this, chain, purpose, identity, interaction, flags, cancellable, error);
   }

   // Asynchronously verify's a certificate chain after looking up and adding
   // any missing certificates to the chain. See g_tls_database_verify_chain()
   // for more information.
   // <chain>: a #GTlsCertificate chain
   // <purpose>: the purpose that this certificate chain will be used for.
   // <identity>: the expected peer identity
   // <interaction>: used to interact with the user if necessary
   // <flags>: additional verify flags
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call when the operation completes
   // <user_data>: the data to pass to the callback function
   void verify_chain_async(TlsCertificate* chain, char* purpose, SocketConnectable* identity, TlsInteraction* interaction, TlsDatabaseVerifyFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_tls_database_verify_chain_async(&this, chain, purpose, identity, interaction, flags, cancellable, callback, user_data);
   }

   // Finish an asynchronous verify chain operation. See
   // g_tls_database_verify_chain() for more information. *
   // result of verification.
   // RETURNS: the appropriate #GTlsCertificateFlags which represents the
   // <result>: a #GAsyncResult.
   TlsCertificateFlags verify_chain_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_tls_database_verify_chain_finish(&this, result, error);
   }
}

struct TlsDatabaseClass {
   GObject2.ObjectClass parent_class;

   // RETURNS: the appropriate #GTlsCertificateFlags which represents the
   // <chain>: a #GTlsCertificate chain
   // <purpose>: the purpose that this certificate chain will be used for.
   // <identity>: the expected peer identity
   // <interaction>: used to interact with the user if necessary
   // <flags>: additional verify flags
   // <cancellable>: a #GCancellable, or %NULL
   extern (C) TlsCertificateFlags function (TlsDatabase* self, TlsCertificate* chain, char* purpose, SocketConnectable* identity, TlsInteraction* interaction, TlsDatabaseVerifyFlags flags, Cancellable* cancellable, GLib2.Error** error=null) verify_chain;

   // <chain>: a #GTlsCertificate chain
   // <purpose>: the purpose that this certificate chain will be used for.
   // <identity>: the expected peer identity
   // <interaction>: used to interact with the user if necessary
   // <flags>: additional verify flags
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call when the operation completes
   // <user_data>: the data to pass to the callback function
   extern (C) void function (TlsDatabase* self, TlsCertificate* chain, char* purpose, SocketConnectable* identity, TlsInteraction* interaction, TlsDatabaseVerifyFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) verify_chain_async;

   // RETURNS: the appropriate #GTlsCertificateFlags which represents the
   // <result>: a #GAsyncResult.
   extern (C) TlsCertificateFlags function (TlsDatabase* self, AsyncResult* result, GLib2.Error** error=null) verify_chain_finish;

   // RETURNS: a newly allocated string containing the handle.
   // <certificate>: certificate for which to create a handle.
   extern (C) char* /*new*/ function (TlsDatabase* self, TlsCertificate* certificate) create_certificate_handle;

   // RETURNS: a newly allocated
   // <handle>: a certificate handle
   // <interaction>: used to interact with the user if necessary
   // <flags>: Flags which affect the lookup.
   // <cancellable>: a #GCancellable, or %NULL
   extern (C) TlsCertificate* /*new*/ function (TlsDatabase* self, char* handle, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, GLib2.Error** error=null) lookup_certificate_for_handle;

   // <handle>: a certificate handle
   // <interaction>: used to interact with the user if necessary
   // <flags>: Flags which affect the lookup.
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call when the operation completes
   // <user_data>: the data to pass to the callback function
   extern (C) void function (TlsDatabase* self, char* handle, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) lookup_certificate_for_handle_async;

   // RETURNS: a newly allocated #GTlsCertificate object.
   // <result>: a #GAsyncResult.
   extern (C) TlsCertificate* /*new*/ function (TlsDatabase* self, AsyncResult* result, GLib2.Error** error=null) lookup_certificate_for_handle_finish;

   // RETURNS: a newly allocated issuer #GTlsCertificate,
   // <certificate>: a #GTlsCertificate
   // <interaction>: used to interact with the user if necessary
   // <flags>: flags which affect the lookup operation
   // <cancellable>: a #GCancellable, or %NULL
   extern (C) TlsCertificate* /*new*/ function (TlsDatabase* self, TlsCertificate* certificate, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, GLib2.Error** error=null) lookup_certificate_issuer;

   // <certificate>: a #GTlsCertificate
   // <interaction>: used to interact with the user if necessary
   // <flags>: flags which affect the lookup operation
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call when the operation completes
   // <user_data>: the data to pass to the callback function
   extern (C) void function (TlsDatabase* self, TlsCertificate* certificate, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) lookup_certificate_issuer_async;

   // RETURNS: a newly allocated issuer #GTlsCertificate,
   // <result>: a #GAsyncResult.
   extern (C) TlsCertificate* /*new*/ function (TlsDatabase* self, AsyncResult* result, GLib2.Error** error=null) lookup_certificate_issuer_finish;

   // Unintrospectable functionp: lookup_certificates_issued_by() / ()
   // 
   // RETURNS: a newly allocated list of #GTlsCertificate objects.
   // <issuer_raw_dn>: a #GByteArray which holds the DER encoded issuer DN.
   // <interaction>: used to interact with the user if necessary
   // <flags>: Flags which affect the lookup operation.
   // <cancellable>: a #GCancellable, or %NULL
   extern (C) GLib2.List* /*new*/ function (TlsDatabase* self, ByteArray* issuer_raw_dn, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, GLib2.Error** error=null) lookup_certificates_issued_by;

   // <issuer_raw_dn>: a #GByteArray which holds the DER encoded issuer DN.
   // <interaction>: used to interact with the user if necessary
   // <flags>: Flags which affect the lookup operation.
   // <cancellable>: a #GCancellable, or %NULL
   // <callback>: callback to call when the operation completes
   // <user_data>: the data to pass to the callback function
   extern (C) void function (TlsDatabase* self, ByteArray* issuer_raw_dn, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) lookup_certificates_issued_by_async;

   // Unintrospectable functionp: lookup_certificates_issued_by_finish() / ()
   // 
   // RETURNS: a newly allocated list of #GTlsCertificate objects.
   // <result>: a #GAsyncResult.
   extern (C) GLib2.List* /*new*/ function (TlsDatabase* self, AsyncResult* result, GLib2.Error** error=null) lookup_certificates_issued_by_finish;
   private void*[16] padding;
}


// Flags for g_tls_database_lookup_handle(), g_tls_database_lookup_issuer(),
// and g_tls_database_lookup_issued().
enum TlsDatabaseLookupFlags /* Version 2.30 */ {
   NONE = 0,
   KEYPAIR = 1
}
struct TlsDatabasePrivate {
}

// Flags for g_tls_database_verify_chain().
enum TlsDatabaseVerifyFlags /* Version 2.30 */ {
   NONE = 0
}

// An error code used with %G_TLS_ERROR in a #GError returned from a
// TLS-related routine.
enum TlsError /* Version 2.28 */ {
   UNAVAILABLE = 0,
   MISC = 1,
   BAD_CERTIFICATE = 2,
   NOT_TLS = 3,
   HANDSHAKE = 4,
   CERTIFICATE_REQUIRED = 5,
   EOF = 6
}

// #GTlsFileDatabase is implemented by #GTlsDatabase objects which load
// their certificate information from a file. It is in interface which
// TLS library specific subtypes implement.
struct TlsFileDatabase /* Version 2.30 */ {

   // Creates a new #GTlsFileDatabase which uses anchor certificate authorities
   // in @anchors to verify certificate chains.
   // 
   // The certificates in @anchors must be PEM encoded.
   // RETURNS: the new #GTlsFileDatabase, or %NULL on error
   // <anchors>: filename of anchor certificate authorities.
   static TlsDatabase* /*new*/ new_(char* anchors, GLib2.Error** error=null) {
      return g_tls_file_database_new(anchors, error);
   }
}

// Provides an interface for #GTlsFileDatabase implementations.
struct TlsFileDatabaseInterface {
   GObject2.TypeInterface g_iface;
   private void*[8] padding;
}


// #GTlsInteraction provides a mechanism for the TLS connection and database
// code to interact with the user. It can be used to ask the user for passwords.
// 
// To use a #GTlsInteraction with a TLS connection use
// g_tls_connection_set_interaction().
// 
// Callers should instantiate a derived class that implements the various
// interaction methods to show the required dialogs.
// 
// Callers should use the 'invoke' functions like
// g_tls_interaction_invoke_ask_password() to run interaction methods. These
// functions make sure that the interaction is invoked in the main loop
// and not in the current thread, if the current thread is not running the
// main loop.
// 
// Derived classes can choose to implement whichever interactions methods they'd
// like to support by overriding those virtual methods in their class
// initialization function. Any interactions not implemented will return
// %G_TLS_INTERACTION_UNHANDLED. If a derived class implements an async method,
// it must also implement the corresponding finish method.
struct TlsInteraction /* : GObject.Object */ /* Version 2.30 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private TlsInteractionPrivate* priv;


   // Run synchronous interaction to ask the user for a password. In general,
   // g_tls_interaction_invoke_ask_password() should be used instead of this
   // function.
   // 
   // Derived subclasses usually implement a password prompt, although they may
   // also choose to provide a password from elsewhere. The @password value will
   // be filled in and then @callback will be called. Alternatively the user may
   // abort this password request, which will usually abort the TLS connection.
   // 
   // If the interaction is cancelled by the cancellation object, or by the
   // user then %G_TLS_INTERACTION_FAILED will be returned with an error that
   // contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
   // not support immediate cancellation.
   // RETURNS: The status of the ask password interaction.
   // <password>: a #GTlsPassword object
   // <cancellable>: an optional #GCancellable cancellation object
   TlsInteractionResult ask_password(TlsPassword* password, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_tls_interaction_ask_password(&this, password, cancellable, error);
   }

   // Run asynchronous interaction to ask the user for a password. In general,
   // g_tls_interaction_invoke_ask_password() should be used instead of this
   // function.
   // 
   // Derived subclasses usually implement a password prompt, although they may
   // also choose to provide a password from elsewhere. The @password value will
   // be filled in and then @callback will be called. Alternatively the user may
   // abort this password request, which will usually abort the TLS connection.
   // 
   // If the interaction is cancelled by the cancellation object, or by the
   // user then %G_TLS_INTERACTION_FAILED will be returned with an error that
   // contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
   // not support immediate cancellation.
   // 
   // Certain implementations may not support immediate cancellation.
   // <password>: a #GTlsPassword object
   // <cancellable>: an optional #GCancellable cancellation object
   // <callback>: will be called when the interaction completes
   // <user_data>: data to pass to the @callback
   void ask_password_async(TlsPassword* password, Cancellable* cancellable=null, AsyncReadyCallback callback=null, void* user_data=null) {
      g_tls_interaction_ask_password_async(&this, password, cancellable, callback, user_data);
   }

   // Complete an ask password user interaction request. This should be once
   // the g_tls_interaction_ask_password_async() completion callback is called.
   // 
   // If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsPassword passed
   // to g_tls_interaction_ask_password() will have its password filled in.
   // 
   // If the interaction is cancelled by the cancellation object, or by the
   // user then %G_TLS_INTERACTION_FAILED will be returned with an error that
   // contains a %G_IO_ERROR_CANCELLED error code.
   // RETURNS: The status of the ask password interaction.
   // <result>: the result passed to the callback
   TlsInteractionResult ask_password_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_tls_interaction_ask_password_finish(&this, result, error);
   }

   // Invoke the interaction to ask the user for a password. It invokes this
   // interaction in the main loop, specifically the #GMainContext returned by
   // g_main_context_get_thread_default() when the interaction is created. This
   // is called by called by #GTlsConnection or #GTlsDatabase to ask the user
   // for a password.
   // 
   // Derived subclasses usually implement a password prompt, although they may
   // also choose to provide a password from elsewhere. The @password value will
   // be filled in and then @callback will be called. Alternatively the user may
   // abort this password request, which will usually abort the TLS connection.
   // 
   // The implementation can either be a synchronous (eg: modal dialog) or an
   // asynchronous one (eg: modeless dialog). This function will take care of
   // calling which ever one correctly.
   // 
   // If the interaction is cancelled by the cancellation object, or by the
   // user then %G_TLS_INTERACTION_FAILED will be returned with an error that
   // contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
   // not support immediate cancellation.
   // RETURNS: The status of the ask password interaction.
   // <password>: a #GTlsPassword object
   // <cancellable>: an optional #GCancellable cancellation object
   TlsInteractionResult invoke_ask_password(TlsPassword* password, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_tls_interaction_invoke_ask_password(&this, password, cancellable, error);
   }
}


// The class for #GTlsInteraction. Derived classes implement the various
// virtual interaction methods to handle TLS interactions.
// 
// Derived classes can choose to implement whichever interactions methods they'd
// like to support by overriding those virtual methods in their class
// initialization function. If a derived class implements an async method,
// it must also implement the corresponding finish method.
// 
// The synchronous interaction methods should implement to display modal dialogs,
// and the asynchronous methods to display modeless dialogs.
// 
// If the user cancels an interaction, then the result should be
// %G_TLS_INTERACTION_FAILED and the error should be set with a domain of
// %G_IO_ERROR and code of %G_IO_ERROR_CANCELLED.
struct TlsInteractionClass /* Version 2.30 */ {
   private GObject2.ObjectClass parent_class;

   // RETURNS: The status of the ask password interaction.
   // <password>: a #GTlsPassword object
   // <cancellable>: an optional #GCancellable cancellation object
   extern (C) TlsInteractionResult function (TlsInteraction* interaction, TlsPassword* password, Cancellable* cancellable, GLib2.Error** error=null) ask_password;

   // <password>: a #GTlsPassword object
   // <cancellable>: an optional #GCancellable cancellation object
   // <callback>: will be called when the interaction completes
   // <user_data>: data to pass to the @callback
   extern (C) void function (TlsInteraction* interaction, TlsPassword* password, Cancellable* cancellable=null, AsyncReadyCallback callback=null, void* user_data=null) ask_password_async;

   // RETURNS: The status of the ask password interaction.
   // <result>: the result passed to the callback
   extern (C) TlsInteractionResult function (TlsInteraction* interaction, AsyncResult* result, GLib2.Error** error=null) ask_password_finish;
   private void*[24] padding;
}

struct TlsInteractionPrivate {
}


// #GTlsInteractionResult is returned by various functions in #GTlsInteraction
// when finishing an interaction request.
enum TlsInteractionResult /* Version 2.30 */ {
   UNHANDLED = 0,
   HANDLED = 1,
   FAILED = 2
}
// Holds a password used in TLS.
struct TlsPassword /* : GObject.Object */ /* Version 2.30 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   TlsPasswordPrivate* priv;


   // Create a new #GTlsPassword object.
   // RETURNS: The newly allocated password object
   // <flags>: the password flags
   // <description>: description of what the password is for
   static TlsPassword* /*new*/ new_(TlsPasswordFlags flags, char* description) {
      return g_tls_password_new(flags, description);
   }

   // Get a description string about what the password will be used for.
   // RETURNS: The description of the password.
   char* get_description() {
      return g_tls_password_get_description(&this);
   }

   // Get flags about the password.
   // RETURNS: The flags about the password.
   TlsPasswordFlags get_flags() {
      return g_tls_password_get_flags(&this);
   }

   // Get the password value. If @length is not %NULL then it will be filled
   // in with the length of the password value.
   // RETURNS: The password value owned by the password object.
   // <length>: location to place the length of the password.
   ubyte* get_value(size_t* length=null) {
      return g_tls_password_get_value(&this, length);
   }

   // Get a user readable translated warning. Usually this warning is a
   // representation of the password flags returned from
   // g_tls_password_get_flags().
   // RETURNS: The warning.
   char* get_warning() {
      return g_tls_password_get_warning(&this);
   }

   // Set a description string about what the password will be used for.
   // <description>: The description of the password
   void set_description(char* description) {
      g_tls_password_set_description(&this, description);
   }

   // Set flags about the password.
   // <flags>: The flags about the password
   void set_flags(TlsPasswordFlags flags) {
      g_tls_password_set_flags(&this, flags);
   }

   // Set the value for this password. The @value will be copied by the password
   // object.
   // 
   // Specify the @length, for a non-null-terminated password. Pass -1 as
   // @length if using a null-terminated password, and @length will be calculated
   // automatically.
   // <value>: the new password value
   // <length>: the length of the password, or -1
   void set_value(ubyte* value, ssize_t length) {
      g_tls_password_set_value(&this, value, length);
   }

   // Provide the value for this password.
   // 
   // The @value will be owned by the password object, and later freed using
   // the @destroy function callback.
   // 
   // Specify the @length, for a non-null-terminated password. Pass -1 as
   // @length if using a null-terminated password, and @length will be calculated
   // automatically.
   // <value>: the value for the password
   // <length>: the length of the password, or -1
   // <destroy>: a function to use to free the password.
   void set_value_full(ubyte* value, ssize_t length, GLib2.DestroyNotify destroy=null) {
      g_tls_password_set_value_full(&this, value, length, destroy);
   }

   // Set a user readable translated warning. Usually this warning is a
   // representation of the password flags returned from
   // g_tls_password_get_flags().
   // <warning>: The user readable warning
   void set_warning(char* warning) {
      g_tls_password_set_warning(&this, warning);
   }
}

struct TlsPasswordClass {
   GObject2.ObjectClass parent_class;

   // RETURNS: The password value owned by the password object.
   // <length>: location to place the length of the password.
   extern (C) ubyte* function (TlsPassword* password, size_t* length=null) get_value;
   extern (C) void function (TlsPassword* password, ubyte* value, ssize_t length, GLib2.DestroyNotify destroy) set_value;
   extern (C) char* function (TlsPassword* password) get_default_warning;
   private void*[4] padding;
}

// Various flags for the password.
enum TlsPasswordFlags /* Version 2.30 */ {
   NONE = 0,
   RETRY = 2,
   MANY_TRIES = 4,
   FINAL_TRY = 8
}
struct TlsPasswordPrivate {
}


// When to allow rehandshaking. See
// g_tls_connection_set_rehandshake_mode().
enum TlsRehandshakeMode /* Version 2.28 */ {
   NEVER = 0,
   SAFELY = 1,
   UNSAFELY = 2
}

// #GTlsServerConnection is the server-side subclass of #GTlsConnection,
// representing a server-side TLS connection.
struct TlsServerConnection /* Version 2.28 */ {

   // Creates a new #GTlsServerConnection wrapping @base_io_stream (which
   // must have pollable input and output streams).
   // RETURNS: the new #GTlsServerConnection, or %NULL on error
   // <base_io_stream>: the #GIOStream to wrap
   // <certificate>: the default server certificate, or %NULL
   static IOStream* /*new*/ new_(IOStream* base_io_stream, TlsCertificate* certificate, GLib2.Error** error=null) {
      return g_tls_server_connection_new(base_io_stream, certificate, error);
   }
}

struct TlsServerConnectionInterface {
   GObject2.TypeInterface g_iface;
}


// This is the subclass of #GSocketConnection that is created
// for UNIX domain sockets.
// 
// It contains functions to do some of the UNIX socket specific
// functionality like passing file descriptors.
// 
// Note that <filename>&lt;gio/gunixconnection.h&gt;</filename> belongs to
// the UNIX-specific GIO interfaces, thus you have to use the
// <filename>gio-unix-2.0.pc</filename> pkg-config file when using it.
struct UnixConnection /* : SocketConnection */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance socketconnection;
   SocketConnection parent_instance;
   UnixConnectionPrivate* priv;


   // Receives credentials from the sending end of the connection.  The
   // sending end has to call g_unix_connection_send_credentials() (or
   // similar) for this to work.
   // 
   // As well as reading the credentials this also reads (and discards) a
   // single byte from the stream, as this is required for credentials
   // passing to work on some implementations.
   // 
   // Other ways to exchange credentials with a foreign peer includes the
   // #GUnixCredentialsMessage type and g_socket_get_credentials() function.
   // 
   // g_object_unref()), %NULL if @error is set.
   // RETURNS: Received credentials on success (free with
   // <cancellable>: A #GCancellable or %NULL.
   Credentials* /*new*/ receive_credentials(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_unix_connection_receive_credentials(&this, cancellable, error);
   }

   // Receives a file descriptor from the sending end of the connection.
   // The sending end has to call g_unix_connection_send_fd() for this
   // to work.
   // 
   // As well as reading the fd this also reads a single byte from the
   // stream, as this is required for fd passing to work on some
   // implementations.
   // RETURNS: a file descriptor on success, -1 on error.
   // <cancellable>: optional #GCancellable object, %NULL to ignore
   int receive_fd(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_unix_connection_receive_fd(&this, cancellable, error);
   }

   // Passes the credentials of the current user the receiving side
   // of the connection. The receiving end has to call
   // g_unix_connection_receive_credentials() (or similar) to accept the
   // credentials.
   // 
   // As well as sending the credentials this also writes a single NUL
   // byte to the stream, as this is required for credentials passing to
   // work on some implementations.
   // 
   // Other ways to exchange credentials with a foreign peer includes the
   // #GUnixCredentialsMessage type and g_socket_get_credentials() function.
   // RETURNS: %TRUE on success, %FALSE if @error is set.
   // <cancellable>: A #GCancellable or %NULL.
   int send_credentials(Cancellable* cancellable, GLib2.Error** error=null) {
      return g_unix_connection_send_credentials(&this, cancellable, error);
   }

   // Passes a file descriptor to the receiving side of the
   // connection. The receiving end has to call g_unix_connection_receive_fd()
   // to accept the file descriptor.
   // 
   // As well as sending the fd this also writes a single byte to the
   // stream, as this is required for fd passing to work on some
   // implementations.
   // RETURNS: a %TRUE on success, %NULL on error.
   // <fd>: a file descriptor
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   int send_fd(int fd, Cancellable* cancellable, GLib2.Error** error=null) {
      return g_unix_connection_send_fd(&this, fd, cancellable, error);
   }
}

struct UnixConnectionClass {
   SocketConnectionClass parent_class;
}

struct UnixConnectionPrivate {
}


// This #GSocketControlMessage contains a #GCredentials instance.  It
// may be sent using g_socket_send_message() and received using
// g_socket_receive_message() over UNIX sockets (ie: sockets in the
// %G_SOCKET_FAMILY_UNIX family).
// 
// For an easier way to send and receive credentials over
// stream-oriented UNIX sockets, see
// g_unix_connection_send_credentials() and
// g_unix_connection_receive_credentials(). To receive credentials of
// a foreign process connected to a socket, use
// g_socket_get_credentials().
struct UnixCredentialsMessage /* : SocketControlMessage */ /* Version 2.26 */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance socketcontrolmessage;
   SocketControlMessage parent_instance;
   UnixCredentialsMessagePrivate* priv;


   // Creates a new #GUnixCredentialsMessage with credentials matching the current processes.
   // RETURNS: a new #GUnixCredentialsMessage
   static UnixCredentialsMessage* /*new*/ new_() {
      return g_unix_credentials_message_new();
   }

   // Creates a new #GUnixCredentialsMessage holding @credentials.
   // RETURNS: a new #GUnixCredentialsMessage
   // <credentials>: A #GCredentials object.
   static UnixCredentialsMessage* /*new*/ new_with_credentials(Credentials* credentials) {
      return g_unix_credentials_message_new_with_credentials(credentials);
   }

   // Checks if passing #GCredentials on a #GSocket is supported on this platform.
   // RETURNS: %TRUE if supported, %FALSE otherwise
   static int is_supported() {
      return g_unix_credentials_message_is_supported();
   }

   // Gets the credentials stored in @message.
   // RETURNS: A #GCredentials instance. Do not free, it is owned by @message.
   Credentials* get_credentials() {
      return g_unix_credentials_message_get_credentials(&this);
   }
}

// Class structure for #GUnixCredentialsMessage.
struct UnixCredentialsMessageClass /* Version 2.26 */ {
   SocketControlMessageClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
}

struct UnixCredentialsMessagePrivate {
}


// A #GUnixFDList contains a list of file descriptors.  It owns the file
// descriptors that it contains, closing them when finalized.
// 
// It may be wrapped in a #GUnixFDMessage and sent over a #GSocket in
// the %G_SOCKET_ADDRESS_UNIX family by using g_socket_send_message()
// and received using g_socket_receive_message().
// 
// Note that <filename>&lt;gio/gunixfdlist.h&gt;</filename> belongs to
// the UNIX-specific GIO interfaces, thus you have to use the
// <filename>gio-unix-2.0.pc</filename> pkg-config file when using it.
struct UnixFDList /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   UnixFDListPrivate* priv;


   // Creates a new #GUnixFDList containing no file descriptors.
   // RETURNS: a new #GUnixFDList
   static UnixFDList* /*new*/ new_() {
      return g_unix_fd_list_new();
   }

   // Creates a new #GUnixFDList containing the file descriptors given in
   // @fds.  The file descriptors become the property of the new list and
   // may no longer be used by the caller.  The array itself is owned by
   // the caller.
   // 
   // Each file descriptor in the array should be set to close-on-exec.
   // 
   // If @n_fds is -1 then @fds must be terminated with -1.
   // RETURNS: a new #GUnixFDList
   // <fds>: the initial list of file descriptors
   // <n_fds>: the length of #fds, or -1
   static UnixFDList* /*new*/ new_from_array(int* fds, int n_fds) {
      return g_unix_fd_list_new_from_array(fds, n_fds);
   }

   // Adds a file descriptor to @list.
   // 
   // The file descriptor is duplicated using dup(). You keep your copy
   // of the descriptor and the copy contained in @list will be closed
   // when @list is finalized.
   // 
   // A possible cause of failure is exceeding the per-process or
   // system-wide file descriptor limit.
   // 
   // The index of the file descriptor in the list is returned.  If you use
   // this index with g_unix_fd_list_get() then you will receive back a
   // duplicated copy of the same file descriptor.
   // 
   // (and @error is set)
   // RETURNS: the index of the appended fd in case of success, else -1
   // <fd>: a valid open file descriptor
   int append(int fd, GLib2.Error** error=null) {
      return g_unix_fd_list_append(&this, fd, error);
   }

   // Gets a file descriptor out of @list.
   // 
   // @index_ specifies the index of the file descriptor to get.  It is a
   // programmer error for @index_ to be out of range; see
   // g_unix_fd_list_get_length().
   // 
   // The file descriptor is duplicated using dup() and set as
   // close-on-exec before being returned.  You must call close() on it
   // when you are done.
   // 
   // A possible cause of failure is exceeding the per-process or
   // system-wide file descriptor limit.
   // RETURNS: the file descriptor, or -1 in case of error
   // <index_>: the index into the list
   int get(int index_, GLib2.Error** error=null) {
      return g_unix_fd_list_get(&this, index_, error);
   }

   // Gets the length of @list (ie: the number of file descriptors
   // contained within).
   // RETURNS: the length of @list
   int get_length() {
      return g_unix_fd_list_get_length(&this);
   }

   // Returns the array of file descriptors that is contained in this
   // object.
   // 
   // After this call, the descriptors remain the property of @list.  The
   // caller must not close them and must not free the array.  The array is
   // valid only until @list is changed in any way.
   // 
   // If @length is non-%NULL then it is set to the number of file
   // descriptors in the returned array. The returned array is also
   // terminated with -1.
   // 
   // This function never returns %NULL. In case there are no file
   // descriptors contained in @list, an empty array is returned.
   // 
   // descriptors
   // RETURNS: an array of file
   // <length>: pointer to the length of the returned array, or %NULL
   int* peek_fds(/*out*/ int* length=null) {
      return g_unix_fd_list_peek_fds(&this, length);
   }

   // Returns the array of file descriptors that is contained in this
   // object.
   // 
   // After this call, the descriptors are no longer contained in
   // @list. Further calls will return an empty list (unless more
   // descriptors have been added).
   // 
   // The return result of this function must be freed with g_free().
   // The caller is also responsible for closing all of the file
   // descriptors.  The file descriptors in the array are set to
   // close-on-exec.
   // 
   // If @length is non-%NULL then it is set to the number of file
   // descriptors in the returned array. The returned array is also
   // terminated with -1.
   // 
   // This function never returns %NULL. In case there are no file
   // descriptors contained in @list, an empty array is returned.
   // 
   // descriptors
   // RETURNS: an array of file
   // <length>: pointer to the length of the returned array, or %NULL
   int* /*new*/ steal_fds(/*out*/ int* length=null) {
      return g_unix_fd_list_steal_fds(&this, length);
   }
}

struct UnixFDListClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct UnixFDListPrivate {
}


// This #GSocketControlMessage contains a #GUnixFDList.
// It may be sent using g_socket_send_message() and received using
// g_socket_receive_message() over UNIX sockets (ie: sockets in the
// %G_SOCKET_ADDRESS_UNIX family). The file descriptors are copied
// between processes by the kernel.
// 
// For an easier way to send and receive file descriptors over
// stream-oriented UNIX sockets, see g_unix_connection_send_fd() and
// g_unix_connection_receive_fd().
// 
// Note that <filename>&lt;gio/gunixfdmessage.h&gt;</filename> belongs to
// the UNIX-specific GIO interfaces, thus you have to use the
// <filename>gio-unix-2.0.pc</filename> pkg-config file when using it.
struct UnixFDMessage /* : SocketControlMessage */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance socketcontrolmessage;
   SocketControlMessage parent_instance;
   UnixFDMessagePrivate* priv;


   // Creates a new #GUnixFDMessage containing an empty file descriptor
   // list.
   // RETURNS: a new #GUnixFDMessage
   static UnixFDMessage* /*new*/ new_() {
      return g_unix_fd_message_new();
   }

   // Creates a new #GUnixFDMessage containing @list.
   // RETURNS: a new #GUnixFDMessage
   // <fd_list>: a #GUnixFDList
   static UnixFDMessage* /*new*/ new_with_fd_list(UnixFDList* fd_list) {
      return g_unix_fd_message_new_with_fd_list(fd_list);
   }

   // Adds a file descriptor to @message.
   // 
   // The file descriptor is duplicated using dup(). You keep your copy
   // of the descriptor and the copy contained in @message will be closed
   // when @message is finalized.
   // 
   // A possible cause of failure is exceeding the per-process or
   // system-wide file descriptor limit.
   // RETURNS: %TRUE in case of success, else %FALSE (and @error is set)
   // <fd>: a valid open file descriptor
   int append_fd(int fd, GLib2.Error** error=null) {
      return g_unix_fd_message_append_fd(&this, fd, error);
   }

   // Gets the #GUnixFDList contained in @message.  This function does not
   // return a reference to the caller, but the returned list is valid for
   // the lifetime of @message.
   // RETURNS: the #GUnixFDList from @message
   UnixFDList* get_fd_list() {
      return g_unix_fd_message_get_fd_list(&this);
   }

   // Returns the array of file descriptors that is contained in this
   // object.
   // 
   // After this call, the descriptors are no longer contained in
   // @message. Further calls will return an empty list (unless more
   // descriptors have been added).
   // 
   // The return result of this function must be freed with g_free().
   // The caller is also responsible for closing all of the file
   // descriptors.
   // 
   // If @length is non-%NULL then it is set to the number of file
   // descriptors in the returned array. The returned array is also
   // terminated with -1.
   // 
   // This function never returns %NULL. In case there are no file
   // descriptors contained in @message, an empty array is returned.
   // 
   // descriptors
   // RETURNS: an array of file
   // <length>: pointer to the length of the returned array, or %NULL
   int* /*new*/ steal_fds(/*out*/ int* length=null) {
      return g_unix_fd_message_steal_fds(&this, length);
   }
}

struct UnixFDMessageClass {
   SocketControlMessageClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
}

struct UnixFDMessagePrivate {
}


// #GUnixInputStream implements #GInputStream for reading from a
// UNIX file descriptor, including asynchronous operations. The file
// descriptor must be selectable, so it doesn't work with opened files.
// 
// Note that <filename>&lt;gio/gunixinputstream.h&gt;</filename> belongs
// to the UNIX-specific GIO interfaces, thus you have to use the
// <filename>gio-unix-2.0.pc</filename> pkg-config file when using it.
struct UnixInputStream /* : InputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance inputstream;
   InputStream parent_instance;
   private UnixInputStreamPrivate* priv;


   // Creates a new #GUnixInputStream for the given @fd.
   // 
   // If @close_fd is %TRUE, the file descriptor will be closed
   // when the stream is closed.
   // RETURNS: a new #GUnixInputStream
   // <fd>: a UNIX file descriptor
   // <close_fd>: %TRUE to close the file descriptor when done
   static UnixInputStream* /*new*/ new_(int fd, int close_fd) {
      return g_unix_input_stream_new(fd, close_fd);
   }

   // Returns whether the file descriptor of @stream will be
   // closed when the stream is closed.
   // RETURNS: %TRUE if the file descriptor is closed when done
   int get_close_fd() {
      return g_unix_input_stream_get_close_fd(&this);
   }

   // Return the UNIX file descriptor that the stream reads from.
   // RETURNS: The file descriptor of @stream
   int get_fd() {
      return g_unix_input_stream_get_fd(&this);
   }

   // Sets whether the file descriptor of @stream shall be closed
   // when the stream is closed.
   // <close_fd>: %TRUE to close the file descriptor when done
   void set_close_fd(int close_fd) {
      g_unix_input_stream_set_close_fd(&this, close_fd);
   }
}

struct UnixInputStreamClass {
   InputStreamClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct UnixInputStreamPrivate {
}


// Defines a Unix mount entry (e.g. <filename>/media/cdrom</filename>).
// This corresponds roughly to a mtab entry.
struct UnixMountEntry {
}

// Watches #GUnixMount<!-- -->s for changes.
struct UnixMountMonitor /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Gets a new #GUnixMountMonitor. The default rate limit for which the
   // monitor will report consecutive changes for the mount and mount
   // point entry files is the default for a #GFileMonitor. Use
   // g_unix_mount_monitor_set_rate_limit() to change this.
   // RETURNS: a #GUnixMountMonitor.
   static UnixMountMonitor* /*new*/ new_() {
      return g_unix_mount_monitor_new();
   }

   // Sets the rate limit to which the @mount_monitor will report
   // consecutive change events to the mount and mount point entry files.
   // <limit_msec>: a integer with the limit in milliseconds to poll for changes.
   void set_rate_limit(int limit_msec) {
      g_unix_mount_monitor_set_rate_limit(&this, limit_msec);
   }
   // Emitted when the unix mount points have changed.
   extern (C) alias static void function (UnixMountMonitor* this_, void* user_data=null) signal_mountpoints_changed;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"mountpoints-changed", CB:signal_mountpoints_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"mountpoints-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   // Emitted when the unix mounts have changed.
   extern (C) alias static void function (UnixMountMonitor* this_, void* user_data=null) signal_mounts_changed;
   ulong signal_connect(string name:"mounts-changed", CB:signal_mounts_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"mounts-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct UnixMountMonitorClass {
}


// Defines a Unix mount point (e.g. <filename>/dev</filename>).
// This corresponds roughly to a fstab entry.
struct UnixMountPoint {

   // Compares two unix mount points.
   // 
   // or less than @mount2, respectively.
   // RETURNS: 1, 0 or -1 if @mount1 is greater than, equal to,
   // <mount2>: a #GUnixMount.
   int compare(UnixMountPoint* mount2) {
      return g_unix_mount_point_compare(&this, mount2);
   }
   // Frees a unix mount point.
   void free() {
      g_unix_mount_point_free(&this);
   }

   // Gets the device path for a unix mount point.
   // RETURNS: a string containing the device path.
   char* get_device_path() {
      return g_unix_mount_point_get_device_path(&this);
   }

   // Gets the file system type for the mount point.
   // RETURNS: a string containing the file system type.
   char* get_fs_type() {
      return g_unix_mount_point_get_fs_type(&this);
   }

   // Gets the mount path for a unix mount point.
   // RETURNS: a string containing the mount path.
   char* get_mount_path() {
      return g_unix_mount_point_get_mount_path(&this);
   }

   // Guesses whether a Unix mount point can be ejected.
   // RETURNS: %TRUE if @mount_point is deemed to be ejectable.
   int guess_can_eject() {
      return g_unix_mount_point_guess_can_eject(&this);
   }

   // Guesses the icon of a Unix mount point.
   // RETURNS: a #GIcon
   Icon* /*new*/ guess_icon() {
      return g_unix_mount_point_guess_icon(&this);
   }

   // Guesses the name of a Unix mount point.
   // The result is a translated string.
   // 
   // be freed with g_free()
   // RETURNS: A newly allocated string that must
   char* /*new*/ guess_name() {
      return g_unix_mount_point_guess_name(&this);
   }

   // Checks if a unix mount point is a loopback device.
   // RETURNS: %TRUE if the mount point is a loopback. %FALSE otherwise.
   int is_loopback() {
      return g_unix_mount_point_is_loopback(&this);
   }

   // Checks if a unix mount point is read only.
   // RETURNS: %TRUE if a mount point is read only.
   int is_readonly() {
      return g_unix_mount_point_is_readonly(&this);
   }

   // Checks if a unix mount point is mountable by the user.
   // RETURNS: %TRUE if the mount point is user mountable.
   int is_user_mountable() {
      return g_unix_mount_point_is_user_mountable(&this);
   }
}


// #GUnixOutputStream implements #GOutputStream for writing to a
// UNIX file descriptor, including asynchronous operations. The file
// descriptor must be selectable, so it doesn't work with opened files.
// 
// Note that <filename>&lt;gio/gunixoutputstream.h&gt;</filename> belongs
// to the UNIX-specific GIO interfaces, thus you have to use the
// <filename>gio-unix-2.0.pc</filename> pkg-config file when using it.
struct UnixOutputStream /* : OutputStream */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance outputstream;
   OutputStream parent_instance;
   private UnixOutputStreamPrivate* priv;


   // Creates a new #GUnixOutputStream for the given @fd.
   // 
   // If @close_fd, is %TRUE, the file descriptor will be closed when
   // the output stream is destroyed.
   // RETURNS: a new #GOutputStream
   // <fd>: a UNIX file descriptor
   // <close_fd>: %TRUE to close the file descriptor when done
   static UnixOutputStream* /*new*/ new_(int fd, int close_fd) {
      return g_unix_output_stream_new(fd, close_fd);
   }

   // Returns whether the file descriptor of @stream will be
   // closed when the stream is closed.
   // RETURNS: %TRUE if the file descriptor is closed when done
   int get_close_fd() {
      return g_unix_output_stream_get_close_fd(&this);
   }

   // Return the UNIX file descriptor that the stream writes to.
   // RETURNS: The file descriptor of @stream
   int get_fd() {
      return g_unix_output_stream_get_fd(&this);
   }

   // Sets whether the file descriptor of @stream shall be closed
   // when the stream is closed.
   // <close_fd>: %TRUE to close the file descriptor when done
   void set_close_fd(int close_fd) {
      g_unix_output_stream_set_close_fd(&this, close_fd);
   }
}

struct UnixOutputStreamClass {
   OutputStreamClass parent_class;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
}

struct UnixOutputStreamPrivate {
}


// Support for UNIX-domain (also known as local) sockets.
// 
// UNIX domain sockets are generally visible in the filesystem.
// However, some systems support abstract socket names which are not
// visible in the filesystem and not affected by the filesystem
// permissions, visibility, etc. Currently this is only supported
// under Linux. If you attempt to use abstract sockets on other
// systems, function calls may return %G_IO_ERROR_NOT_SUPPORTED
// errors. You can use g_unix_socket_address_abstract_names_supported()
// to see if abstract names are supported.
// 
// Note that <filename>&lt;gio/gunixsocketaddress.h&gt;</filename> belongs to
// the UNIX-specific GIO interfaces, thus you have to use the
// <filename>gio-unix-2.0.pc</filename> pkg-config file when using it.
struct UnixSocketAddress /* : SocketAddress */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance socketaddress;
   SocketAddress parent_instance;
   private UnixSocketAddressPrivate* priv;


   // Creates a new #GUnixSocketAddress for @path.
   // 
   // To create abstract socket addresses, on systems that support that,
   // use g_unix_socket_address_new_abstract().
   // RETURNS: a new #GUnixSocketAddress
   // <path>: the socket path
   static UnixSocketAddress* /*new*/ new_(char* path) {
      return g_unix_socket_address_new(path);
   }

   // Creates a new %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
   // #GUnixSocketAddress for @path.
   // RETURNS: a new #GUnixSocketAddress
   // <path>: the abstract name
   // <path_len>: the length of @path, or -1
   static UnixSocketAddress* /*new*/ new_abstract(char* path, int path_len) {
      return g_unix_socket_address_new_abstract(path, path_len);
   }

   // Creates a new #GUnixSocketAddress of type @type with name @path.
   // 
   // If @type is %G_UNIX_SOCKET_ADDRESS_PATH, this is equivalent to
   // calling g_unix_socket_address_new().
   // 
   // If @path_type is %G_UNIX_SOCKET_ADDRESS_ABSTRACT, then @path_len
   // bytes of @path will be copied to the socket's path, and only those
   // bytes will be considered part of the name. (If @path_len is -1,
   // then @path is assumed to be NUL-terminated.) For example, if @path
   // was "test", then calling g_socket_address_get_native_size() on the
   // returned socket would return 7 (2 bytes of overhead, 1 byte for the
   // abstract-socket indicator byte, and 4 bytes for the name "test").
   // 
   // If @path_type is %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED, then
   // @path_len bytes of @path will be copied to the socket's path, the
   // rest of the path will be padded with 0 bytes, and the entire
   // zero-padded buffer will be considered the name. (As above, if
   // @path_len is -1, then @path is assumed to be NUL-terminated.) In
   // this case, g_socket_address_get_native_size() will always return
   // the full size of a <literal>struct sockaddr_un</literal>, although
   // g_unix_socket_address_get_path_len() will still return just the
   // length of @path.
   // 
   // %G_UNIX_SOCKET_ADDRESS_ABSTRACT is preferred over
   // %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED for new programs. Of course,
   // when connecting to a server created by another process, you must
   // use the appropriate type corresponding to how that process created
   // its listening socket.
   // RETURNS: a new #GUnixSocketAddress
   // <path>: the name
   // <path_len>: the length of @path, or -1
   // <type>: a #GUnixSocketAddressType
   static UnixSocketAddress* /*new*/ new_with_type(char* path, int path_len, UnixSocketAddressType type) {
      return g_unix_socket_address_new_with_type(path, path_len, type);
   }

   // Checks if abstract unix domain socket names are supported.
   // RETURNS: %TRUE if supported, %FALSE otherwise
   static int abstract_names_supported() {
      return g_unix_socket_address_abstract_names_supported();
   }

   // Gets @address's type.
   // RETURNS: a #GUnixSocketAddressType
   UnixSocketAddressType get_address_type() {
      return g_unix_socket_address_get_address_type(&this);
   }

   // Tests if @address is abstract.
   // RETURNS: %TRUE if the address is abstract, %FALSE otherwise
   int get_is_abstract() {
      return g_unix_socket_address_get_is_abstract(&this);
   }

   // Gets @address's path, or for abstract sockets the "name".
   // 
   // Guaranteed to be zero-terminated, but an abstract socket
   // may contain embedded zeros, and thus you should use
   // g_unix_socket_address_get_path_len() to get the true length
   // of this string.
   // RETURNS: the path for @address
   char* get_path() {
      return g_unix_socket_address_get_path(&this);
   }

   // Gets the length of @address's path.
   // 
   // For details, see g_unix_socket_address_get_path().
   // RETURNS: the length of the path
   size_t get_path_len() {
      return g_unix_socket_address_get_path_len(&this);
   }
}

struct UnixSocketAddressClass {
   SocketAddressClass parent_class;
}

struct UnixSocketAddressPrivate {
}


// The type of name used by a #GUnixSocketAddress.
// %G_UNIX_SOCKET_ADDRESS_PATH indicates a traditional unix domain
// socket bound to a filesystem path. %G_UNIX_SOCKET_ADDRESS_ANONYMOUS
// indicates a socket not bound to any name (eg, a client-side socket,
// or a socket created with socketpair()).
// 
// For abstract sockets, there are two incompatible ways of naming
// them; the man pages suggest using the entire <literal>struct
// sockaddr_un</literal> as the name, padding the unused parts of the
// %sun_path field with zeroes; this corresponds to
// %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED. However, many programs
// instead just use a portion of %sun_path, and pass an appropriate
// smaller length to bind() or connect(). This is
// %G_UNIX_SOCKET_ADDRESS_ABSTRACT.
enum UnixSocketAddressType /* Version 2.26 */ {
   INVALID = 0,
   ANONYMOUS = 1,
   PATH = 2,
   ABSTRACT = 3,
   ABSTRACT_PADDED = 4
}
enum VFS_EXTENSION_POINT_NAME = "gio-vfs";
enum VOLUME_IDENTIFIER_KIND_HAL_UDI = "hal-udi";
enum VOLUME_IDENTIFIER_KIND_LABEL = "label";
enum VOLUME_IDENTIFIER_KIND_NFS_MOUNT = "nfs-mount";
enum VOLUME_IDENTIFIER_KIND_UNIX_DEVICE = "unix-device";
enum VOLUME_IDENTIFIER_KIND_UUID = "uuid";
enum VOLUME_MONITOR_EXTENSION_POINT_NAME = "gio-volume-monitor";
// Entry point for using GIO functionality.
struct Vfs /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;


   // Gets the default #GVfs for the system.
   // RETURNS: a #GVfs.
   static Vfs* get_default() {
      return g_vfs_get_default();
   }

   // Gets the local #GVfs for the system.
   // RETURNS: a #GVfs.
   static Vfs* get_local() {
      return g_vfs_get_local();
   }

   // Gets a #GFile for @path.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFile.
   // <path>: a string containing a VFS path.
   File* /*new*/ get_file_for_path(char* path) {
      return g_vfs_get_file_for_path(&this, path);
   }

   // Gets a #GFile for @uri.
   // 
   // This operation never fails, but the returned object
   // might not support any I/O operation if the URI
   // is malformed or if the URI scheme is not supported.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFile.
   // <uri>: a string containing a URI
   File* /*new*/ get_file_for_uri(char* uri) {
      return g_vfs_get_file_for_uri(&this, uri);
   }

   // Gets a list of URI schemes supported by @vfs.
   // 
   // The returned array belongs to GIO and must
   // not be freed or modified.
   // RETURNS: a %NULL-terminated array of strings.
   char** get_supported_uri_schemes() {
      return g_vfs_get_supported_uri_schemes(&this);
   }

   // Checks if the VFS is active.
   // RETURNS: %TRUE if construction of the @vfs was successful and it is now active.
   int is_active() {
      return g_vfs_is_active(&this);
   }

   // This operation never fails, but the returned object might
   // not support any I/O operations if the @parse_name cannot
   // be parsed by the #GVfs module.
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GFile for the given @parse_name.
   // <parse_name>: a string to be parsed by the VFS module.
   File* /*new*/ parse_name(char* parse_name) {
      return g_vfs_parse_name(&this, parse_name);
   }
}

struct VfsClass {
   GObject2.ObjectClass parent_class;
   // RETURNS: %TRUE if construction of the @vfs was successful and it is now active.
   extern (C) int function (Vfs* vfs) is_active;

   // RETURNS: a #GFile.
   // <path>: a string containing a VFS path.
   extern (C) File* /*new*/ function (Vfs* vfs, char* path) get_file_for_path;

   // RETURNS: a #GFile.
   // <uri>: a string containing a URI
   extern (C) File* /*new*/ function (Vfs* vfs, char* uri) get_file_for_uri;
   // RETURNS: a %NULL-terminated array of strings.
   extern (C) char** function (Vfs* vfs) get_supported_uri_schemes;

   // RETURNS: a #GFile for the given @parse_name.
   // <parse_name>: a string to be parsed by the VFS module.
   extern (C) File* /*new*/ function (Vfs* vfs, char* parse_name) parse_name;
   extern (C) void function (Vfs* vfs, char* filename, ulong device, FileAttributeMatcher* attribute_matcher, FileInfo* info, Cancellable* cancellable, void** extra_data, GLib2.DestroyNotify* free_extra_data) local_file_add_info;
   extern (C) void function (Vfs* vfs, FileAttributeInfoList* list) add_writable_namespaces;
   extern (C) int function (Vfs* vfs, char* filename, FileInfo* info, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error=null) local_file_set_attributes;
   extern (C) void function (Vfs* vfs, char* filename) local_file_removed;
   extern (C) void function (Vfs* vfs, char* source, char* dest) local_file_moved;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
   extern (C) void function () _g_reserved6;
   extern (C) void function () _g_reserved7;
}


// The #GVolume interface represents user-visible objects that can be
// mounted. Note, when porting from GnomeVFS, #GVolume is the moral
// equivalent of #GnomeVFSDrive.
// 
// Mounting a #GVolume instance is an asynchronous operation. For more
// information about asynchronous operations, see #GAsyncReady and
// #GSimpleAsyncReady. To mount a #GVolume, first call
// g_volume_mount() with (at least) the #GVolume instance, optionally
// a #GMountOperation object and a #GAsyncReadyCallback.
// 
// Typically, one will only want to pass %NULL for the
// #GMountOperation if automounting all volumes when a desktop session
// starts since it's not desirable to put up a lot of dialogs asking
// for credentials.
// 
// The callback will be fired when the operation has resolved (either
// with success or failure), and a #GAsyncReady structure will be
// passed to the callback.  That callback should then call
// g_volume_mount_finish() with the #GVolume instance and the
// #GAsyncReady data to see if the operation was completed
// successfully.  If an @error is present when g_volume_mount_finish()
// is called, then it will be filled with any error information.
// 
// <para id="volume-identifier">
// It is sometimes necessary to directly access the underlying
// operating system object behind a volume (e.g. for passing a volume
// to an application via the commandline). For this purpose, GIO
// allows to obtain an 'identifier' for the volume. There can be
// different kinds of identifiers, such as Hal UDIs, filesystem labels,
// traditional Unix devices (e.g. <filename>/dev/sda2</filename>),
// uuids. GIO uses predefind strings as names for the different kinds
// of identifiers: #G_VOLUME_IDENTIFIER_KIND_HAL_UDI,
// #G_VOLUME_IDENTIFIER_KIND_LABEL, etc. Use g_volume_get_identifier()
// to obtain an identifier for a volume.
// </para>
// 
// Note that #G_VOLUME_IDENTIFIER_KIND_HAL_UDI will only be available
// when the gvfs hal volume monitor is in use. Other volume monitors
// will generally be able to provide the #G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE
// identifier, which can be used to obtain a hal device by means of
// libhal_manger_find_device_string_match().
struct Volume {

   // Checks if a volume can be ejected.
   // RETURNS: %TRUE if the @volume can be ejected. %FALSE otherwise.
   int can_eject() {
      return g_volume_can_eject(&this);
   }

   // Checks if a volume can be mounted.
   // RETURNS: %TRUE if the @volume can be mounted. %FALSE otherwise.
   int can_mount() {
      return g_volume_can_mount(&this);
   }

   // Ejects a volume. This is an asynchronous operation, and is
   // finished by calling g_volume_eject_finish() with the @volume
   // and #GAsyncResult returned in the @callback.
   // <flags>: flags affecting the unmount if required for eject
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data that gets passed to @callback
   void eject(MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_volume_eject(&this, flags, cancellable, callback, user_data);
   }

   // Finishes ejecting a volume. If any errors occurred during the operation,
   // @error will be set to contain the errors and %FALSE will be returned.
   // RETURNS: %TRUE, %FALSE if operation failed.
   // <result>: a #GAsyncResult.
   int eject_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_volume_eject_finish(&this, result, error);
   }

   // Ejects a volume. This is an asynchronous operation, and is
   // finished by calling g_volume_eject_with_operation_finish() with the @volume
   // and #GAsyncResult data returned in the @callback.
   // <flags>: flags affecting the unmount if required for eject
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   void eject_with_operation(MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_volume_eject_with_operation(&this, flags, mount_operation, cancellable, callback, user_data);
   }

   // Finishes ejecting a volume. If any errors occurred during the operation,
   // @error will be set to contain the errors and %FALSE will be returned.
   // RETURNS: %TRUE if the volume was successfully ejected. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   int eject_with_operation_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_volume_eject_with_operation_finish(&this, result, error);
   }

   // Gets the kinds of <link linkend="volume-identifier">identifiers</link>
   // that @volume has. Use g_volume_get_identifer() to obtain
   // the identifiers themselves.
   // 
   // of strings containing kinds of identifiers. Use g_strfreev() to free.
   // RETURNS: a %NULL-terminated array
   char** /*new*/ enumerate_identifiers() {
      return g_volume_enumerate_identifiers(&this);
   }

   // Gets the activation root for a #GVolume if it is known ahead of
   // mount time. Returns %NULL otherwise. If not %NULL and if @volume
   // is mounted, then the result of g_mount_get_root() on the
   // #GMount object obtained from g_volume_get_mount() will always
   // either be equal or a prefix of what this function returns. In
   // other words, in code
   // 
   // <programlisting>
   // GMount *mount;
   // GFile *mount_root
   // GFile *volume_activation_root;
   // 
   // mount = g_volume_get_mount (volume); /&ast; mounted, so never NULL &ast;/
   // mount_root = g_mount_get_root (mount);
   // volume_activation_root = g_volume_get_activation_root(volume); /&ast; assume not NULL &ast;/
   // </programlisting>
   // 
   // then the expression
   // 
   // <programlisting>
   // (g_file_has_prefix (volume_activation_root, mount_root) ||
   // </programlisting>
   // 
   // will always be %TRUE.
   // 
   // Activation roots are typically used in #GVolumeMonitor
   // implementations to find the underlying mount to shadow, see
   // g_mount_is_shadowed() for more details.
   // 
   // g_object_unref() to free.
   // RETURNS: the activation root of @volume or %NULL. Use
   File* /*new*/ get_activation_root() {
      return g_volume_get_activation_root(&this);
   }

   // Gets the drive for the @volume.
   // 
   // The returned object should be unreffed with g_object_unref()
   // when no longer needed.
   // RETURNS: a #GDrive or %NULL if @volume is not associated with a drive.
   Drive* /*new*/ get_drive() {
      return g_volume_get_drive(&this);
   }

   // Gets the icon for @volume.
   // 
   // The returned object should be unreffed with g_object_unref()
   // when no longer needed.
   // RETURNS: a #GIcon.
   Icon* /*new*/ get_icon() {
      return g_volume_get_icon(&this);
   }

   // Gets the identifier of the given kind for @volume.
   // See the <link linkend="volume-identifier">introduction</link>
   // for more information about volume identifiers.
   // 
   // requested identfier, or %NULL if the #GVolume
   // doesn't have this kind of identifier
   // RETURNS: a newly allocated string containing the
   // <kind>: the kind of identifier to return
   char* /*new*/ get_identifier(char* kind) {
      return g_volume_get_identifier(&this, kind);
   }

   // Gets the mount for the @volume.
   // 
   // The returned object should be unreffed with g_object_unref()
   // when no longer needed.
   // RETURNS: a #GMount or %NULL if @volume isn't mounted.
   Mount* /*new*/ get_mount() {
      return g_volume_get_mount(&this);
   }

   // Gets the name of @volume.
   // 
   // be freed with g_free() when no longer needed.
   // RETURNS: the name for the given @volume. The returned string should
   char* /*new*/ get_name() {
      return g_volume_get_name(&this);
   }

   // Gets the UUID for the @volume. The reference is typically based on
   // the file system UUID for the volume in question and should be
   // considered an opaque string. Returns %NULL if there is no UUID
   // available.
   // 
   // The returned string should be freed with g_free()
   // when no longer needed.
   // RETURNS: the UUID for @volume or %NULL if no UUID can be computed.
   char* /*new*/ get_uuid() {
      return g_volume_get_uuid(&this);
   }

   // Mounts a volume. This is an asynchronous operation, and is
   // finished by calling g_volume_mount_finish() with the @volume
   // and #GAsyncResult returned in the @callback.
   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data that gets passed to @callback
   void mount(MountMountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
      g_volume_mount(&this, flags, mount_operation, cancellable, callback, user_data);
   }

   // Finishes mounting a volume. If any errors occurred during the operation,
   // @error will be set to contain the errors and %FALSE will be returned.
   // 
   // If the mount operation succeeded, g_volume_get_mount() on @volume
   // is guaranteed to return the mount right after calling this
   // function; there's no need to listen for the 'mount-added' signal on
   // #GVolumeMonitor.
   // RETURNS: %TRUE, %FALSE if operation failed.
   // <result>: a #GAsyncResult
   int mount_finish(AsyncResult* result, GLib2.Error** error=null) {
      return g_volume_mount_finish(&this, result, error);
   }

   // Returns whether the volume should be automatically mounted.
   // RETURNS: %TRUE if the volume should be automatically mounted.
   int should_automount() {
      return g_volume_should_automount(&this);
   }
   // Emitted when the volume has been changed.
   extern (C) alias static void function (Volume* this_, void* user_data=null) signal_changed;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"changed", CB:signal_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when the #GVolume have been removed. If
   // the recipient is holding references to the object they should
   // release them so the object can be finalized.
   extern (C) alias static void function (Volume* this_, void* user_data=null) signal_removed;
   ulong signal_connect(string name:"removed", CB:signal_removed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"removed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

// Interface for implementing operations for mountable volumes.
struct VolumeIface {
   GObject2.TypeInterface g_iface;
   extern (C) void function (Volume* volume) changed;
   extern (C) void function (Volume* volume) removed;
   // RETURNS: the name for the given @volume. The returned string should
   extern (C) char* /*new*/ function (Volume* volume) get_name;
   // RETURNS: a #GIcon.
   extern (C) Icon* /*new*/ function (Volume* volume) get_icon;
   // RETURNS: the UUID for @volume or %NULL if no UUID can be computed.
   extern (C) char* /*new*/ function (Volume* volume) get_uuid;
   // RETURNS: a #GDrive or %NULL if @volume is not associated with a drive.
   extern (C) Drive* /*new*/ function (Volume* volume) get_drive;
   // RETURNS: a #GMount or %NULL if @volume isn't mounted.
   extern (C) Mount* /*new*/ function (Volume* volume) get_mount;
   // RETURNS: %TRUE if the @volume can be mounted. %FALSE otherwise.
   extern (C) int function (Volume* volume) can_mount;
   // RETURNS: %TRUE if the @volume can be ejected. %FALSE otherwise.
   extern (C) int function (Volume* volume) can_eject;

   // <flags>: flags affecting the operation
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data that gets passed to @callback
   extern (C) void function (Volume* volume, MountMountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) mount_fn;

   // RETURNS: %TRUE, %FALSE if operation failed.
   // <result>: a #GAsyncResult
   extern (C) int function (Volume* volume, AsyncResult* result, GLib2.Error** error=null) mount_finish;

   // <flags>: flags affecting the unmount if required for eject
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data that gets passed to @callback
   extern (C) void function (Volume* volume, MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) eject;

   // RETURNS: %TRUE, %FALSE if operation failed.
   // <result>: a #GAsyncResult.
   extern (C) int function (Volume* volume, AsyncResult* result, GLib2.Error** error=null) eject_finish;

   // RETURNS: a newly allocated string containing the
   // <kind>: the kind of identifier to return
   extern (C) char* /*new*/ function (Volume* volume, char* kind) get_identifier;
   // RETURNS: a %NULL-terminated array
   extern (C) char** /*new*/ function (Volume* volume) enumerate_identifiers;
   // RETURNS: %TRUE if the volume should be automatically mounted.
   extern (C) int function (Volume* volume) should_automount;
   // RETURNS: the activation root of @volume or %NULL. Use
   extern (C) File* /*new*/ function (Volume* volume) get_activation_root;

   // <flags>: flags affecting the unmount if required for eject
   // <mount_operation>: a #GMountOperation or %NULL to avoid user interaction.
   // <cancellable>: optional #GCancellable object, %NULL to ignore.
   // <callback>: a #GAsyncReadyCallback, or %NULL.
   // <user_data>: user data passed to @callback.
   extern (C) void function (Volume* volume, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) eject_with_operation;

   // RETURNS: %TRUE if the volume was successfully ejected. %FALSE otherwise.
   // <result>: a #GAsyncResult.
   extern (C) int function (Volume* volume, AsyncResult* result, GLib2.Error** error=null) eject_with_operation_finish;
}


// #GVolumeMonitor is for listing the user interesting devices and volumes
// on the computer. In other words, what a file selector or file manager
// would show in a sidebar.
// 
// #GVolumeMonitor is not <link
// linkend="g-main-context-push-thread-default">thread-default-context
// aware</link>, and so should not be used other than from the main
// thread, with no thread-default-context active.
struct VolumeMonitor /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private void* priv;


   // This function should be called by any #GVolumeMonitor
   // implementation when a new #GMount object is created that is not
   // associated with a #GVolume object. It must be called just before
   // emitting the @mount_added signal.
   // 
   // If the return value is not %NULL, the caller must associate the
   // returned #GVolume object with the #GMount. This involves returning
   // it in its g_mount_get_volume() implementation. The caller must
   // also listen for the "removed" signal on the returned object
   // and give up its reference when handling that signal
   // 
   // Similary, if implementing g_volume_monitor_adopt_orphan_mount(),
   // the implementor must take a reference to @mount and return it in
   // its g_volume_get_mount() implemented. Also, the implementor must
   // listen for the "unmounted" signal on @mount and give up its
   // reference upon handling that signal.
   // 
   // There are two main use cases for this function.
   // 
   // One is when implementing a user space file system driver that reads
   // blocks of a block device that is already represented by the native
   // volume monitor (for example a CD Audio file system driver). Such
   // a driver will generate its own #GMount object that needs to be
   // associated with the #GVolume object that represents the volume.
   // 
   // The other is for implementing a #GVolumeMonitor whose sole purpose
   // is to return #GVolume objects representing entries in the users
   // "favorite servers" list or similar.
   // 
   // if no wants to adopt the #GMount.
   // 
   // implementations should instead create shadow mounts with the URI of
   // the mount they intend to adopt. See the proxy volume monitor in
   // gvfs for an example of this. Also see g_mount_is_shadowed(),
   // g_mount_shadow() and g_mount_unshadow() functions.
   // RETURNS: the #GVolume object that is the parent for @mount or %NULL
   // <mount>: a #GMount object to find a parent for
   static Volume* /*new*/ adopt_orphan_mount(Mount* mount) {
      return g_volume_monitor_adopt_orphan_mount(mount);
   }

   // Gets the volume monitor used by gio.
   // 
   // g_object_unref() when done with it.
   // RETURNS: a reference to the #GVolumeMonitor used by gio. Call
   static VolumeMonitor* /*new*/ get() {
      return g_volume_monitor_get();
   }

   // Gets a list of drives connected to the system.
   // 
   // The returned list should be freed with g_list_free(), after
   // its elements have been unreffed with g_object_unref().
   // RETURNS: a #GList of connected #GDrive objects.
   GLib2.List* /*new*/ get_connected_drives() {
      return g_volume_monitor_get_connected_drives(&this);
   }

   // Finds a #GMount object by its UUID (see g_mount_get_uuid())
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GMount or %NULL if no such mount is available.
   // <uuid>: the UUID to look for
   Mount* /*new*/ get_mount_for_uuid(char* uuid) {
      return g_volume_monitor_get_mount_for_uuid(&this, uuid);
   }

   // Gets a list of the mounts on the system.
   // 
   // The returned list should be freed with g_list_free(), after
   // its elements have been unreffed with g_object_unref().
   // RETURNS: a #GList of #GMount objects.
   GLib2.List* /*new*/ get_mounts() {
      return g_volume_monitor_get_mounts(&this);
   }

   // Finds a #GVolume object by its UUID (see g_volume_get_uuid())
   // 
   // Free the returned object with g_object_unref().
   // RETURNS: a #GVolume or %NULL if no such volume is available.
   // <uuid>: the UUID to look for
   Volume* /*new*/ get_volume_for_uuid(char* uuid) {
      return g_volume_monitor_get_volume_for_uuid(&this, uuid);
   }

   // Gets a list of the volumes on the system.
   // 
   // The returned list should be freed with g_list_free(), after
   // its elements have been unreffed with g_object_unref().
   // RETURNS: a #GList of #GVolume objects.
   GLib2.List* /*new*/ get_volumes() {
      return g_volume_monitor_get_volumes(&this);
   }

   // Emitted when a drive changes.
   // <drive>: the drive that changed
   extern (C) alias static void function (VolumeMonitor* this_, Drive* drive, void* user_data=null) signal_drive_changed;

   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return super_.signal_connect!name(cb, data, cf);
   }

   ulong signal_connect(string name:"drive-changed", CB:signal_drive_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"drive-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when a drive is connected to the system.
   // <drive>: a #GDrive that was connected.
   extern (C) alias static void function (VolumeMonitor* this_, Drive* drive, void* user_data=null) signal_drive_connected;
   ulong signal_connect(string name:"drive-connected", CB:signal_drive_connected)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"drive-connected",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when a drive is disconnected from the system.
   // <drive>: a #GDrive that was disconnected.
   extern (C) alias static void function (VolumeMonitor* this_, Drive* drive, void* user_data=null) signal_drive_disconnected;
   ulong signal_connect(string name:"drive-disconnected", CB:signal_drive_disconnected)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"drive-disconnected",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when the eject button is pressed on @drive.
   // <drive>: the drive where the eject button was pressed
   extern (C) alias static void function (VolumeMonitor* this_, Drive* drive, void* user_data=null) signal_drive_eject_button;
   ulong signal_connect(string name:"drive-eject-button", CB:signal_drive_eject_button)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"drive-eject-button",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when the stop button is pressed on @drive.
   // <drive>: the drive where the stop button was pressed
   extern (C) alias static void function (VolumeMonitor* this_, Drive* drive, void* user_data=null) signal_drive_stop_button;
   ulong signal_connect(string name:"drive-stop-button", CB:signal_drive_stop_button)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"drive-stop-button",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when a mount is added.
   // <mount>: a #GMount that was added.
   extern (C) alias static void function (VolumeMonitor* this_, Mount* mount, void* user_data=null) signal_mount_added;
   ulong signal_connect(string name:"mount-added", CB:signal_mount_added)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"mount-added",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when a mount changes.
   // <mount>: a #GMount that changed.
   extern (C) alias static void function (VolumeMonitor* this_, Mount* mount, void* user_data=null) signal_mount_changed;
   ulong signal_connect(string name:"mount-changed", CB:signal_mount_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"mount-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when a mount is about to be removed.
   // <mount>: a #GMount that is being unmounted.
   extern (C) alias static void function (VolumeMonitor* this_, Mount* mount, void* user_data=null) signal_mount_pre_unmount;
   ulong signal_connect(string name:"mount-pre-unmount", CB:signal_mount_pre_unmount)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"mount-pre-unmount",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when a mount is removed.
   // <mount>: a #GMount that was removed.
   extern (C) alias static void function (VolumeMonitor* this_, Mount* mount, void* user_data=null) signal_mount_removed;
   ulong signal_connect(string name:"mount-removed", CB:signal_mount_removed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"mount-removed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when a mountable volume is added to the system.
   // <volume>: a #GVolume that was added.
   extern (C) alias static void function (VolumeMonitor* this_, Volume* volume, void* user_data=null) signal_volume_added;
   ulong signal_connect(string name:"volume-added", CB:signal_volume_added)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"volume-added",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when mountable volume is changed.
   // <volume>: a #GVolume that changed.
   extern (C) alias static void function (VolumeMonitor* this_, Volume* volume, void* user_data=null) signal_volume_changed;
   ulong signal_connect(string name:"volume-changed", CB:signal_volume_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"volume-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when a mountable volume is removed from the system.
   // <volume>: a #GVolume that was removed.
   extern (C) alias static void function (VolumeMonitor* this_, Volume* volume, void* user_data=null) signal_volume_removed;
   ulong signal_connect(string name:"volume-removed", CB:signal_volume_removed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"volume-removed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct VolumeMonitorClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (VolumeMonitor* volume_monitor, Volume* volume) volume_added;
   extern (C) void function (VolumeMonitor* volume_monitor, Volume* volume) volume_removed;
   extern (C) void function (VolumeMonitor* volume_monitor, Volume* volume) volume_changed;
   extern (C) void function (VolumeMonitor* volume_monitor, Mount* mount) mount_added;
   extern (C) void function (VolumeMonitor* volume_monitor, Mount* mount) mount_removed;
   extern (C) void function (VolumeMonitor* volume_monitor, Mount* mount) mount_pre_unmount;
   extern (C) void function (VolumeMonitor* volume_monitor, Mount* mount) mount_changed;
   extern (C) void function (VolumeMonitor* volume_monitor, Drive* drive) drive_connected;
   extern (C) void function (VolumeMonitor* volume_monitor, Drive* drive) drive_disconnected;
   extern (C) void function (VolumeMonitor* volume_monitor, Drive* drive) drive_changed;
   extern (C) int function () is_supported;
   // RETURNS: a #GList of connected #GDrive objects.
   extern (C) GLib2.List* /*new*/ function (VolumeMonitor* volume_monitor) get_connected_drives;
   // RETURNS: a #GList of #GVolume objects.
   extern (C) GLib2.List* /*new*/ function (VolumeMonitor* volume_monitor) get_volumes;
   // RETURNS: a #GList of #GMount objects.
   extern (C) GLib2.List* /*new*/ function (VolumeMonitor* volume_monitor) get_mounts;

   // RETURNS: a #GVolume or %NULL if no such volume is available.
   // <uuid>: the UUID to look for
   extern (C) Volume* /*new*/ function (VolumeMonitor* volume_monitor, char* uuid) get_volume_for_uuid;

   // RETURNS: a #GMount or %NULL if no such mount is available.
   // <uuid>: the UUID to look for
   extern (C) Mount* /*new*/ function (VolumeMonitor* volume_monitor, char* uuid) get_mount_for_uuid;
   // Unintrospectable functionp: adopt_orphan_mount() / ()
   extern (C) Volume* function (Mount* mount, VolumeMonitor* volume_monitor) adopt_orphan_mount;
   extern (C) void function (VolumeMonitor* volume_monitor, Drive* drive) drive_eject_button;
   extern (C) void function (VolumeMonitor* volume_monitor, Drive* drive) drive_stop_button;
   extern (C) void function () _g_reserved1;
   extern (C) void function () _g_reserved2;
   extern (C) void function () _g_reserved3;
   extern (C) void function () _g_reserved4;
   extern (C) void function () _g_reserved5;
   extern (C) void function () _g_reserved6;
}

// Zlib decompression
struct ZlibCompressor /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new #GZlibCompressor.
   // RETURNS: a new #GZlibCompressor
   // <format>: The format to use for the compressed data
   // <level>: compression level (0-9), -1 for default
   static ZlibCompressor* /*new*/ new_(ZlibCompressorFormat format, int level) {
      return g_zlib_compressor_new(format, level);
   }

   // Returns the #GZlibCompressor:file-info property.
   // RETURNS: a #GFileInfo, or %NULL
   FileInfo* get_file_info() {
      return g_zlib_compressor_get_file_info(&this);
   }

   // Sets @file_info in @compressor. If non-%NULL, and @compressor's
   // #GZlibCompressor:format property is %G_ZLIB_COMPRESSOR_FORMAT_GZIP,
   // it will be used to set the file name and modification time in
   // the GZIP header of the compressed data.
   // 
   // Note: it is an error to call this function while a compression is in
   // progress; it may only be called immediately after creation of @compressor,
   // or after resetting it with g_converter_reset().
   // <file_info>: a #GFileInfo
   void set_file_info(FileInfo* file_info=null) {
      g_zlib_compressor_set_file_info(&this, file_info);
   }
}

struct ZlibCompressorClass {
   GObject2.ObjectClass parent_class;
}


// Used to select the type of data format to use for #GZlibDecompressor
// and #GZlibCompressor.
enum ZlibCompressorFormat /* Version 2.24 */ {
   ZLIB = 0,
   GZIP = 1,
   RAW = 2
}
// Zlib decompression
struct ZlibDecompressor /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new #GZlibDecompressor.
   // RETURNS: a new #GZlibDecompressor
   // <format>: The format to use for the compressed data
   static ZlibDecompressor* /*new*/ new_(ZlibCompressorFormat format) {
      return g_zlib_decompressor_new(format);
   }

   // Retrieves the #GFileInfo constructed from the GZIP header data
   // of compressed data processed by @compressor, or %NULL if @decompressor's
   // #GZlibDecompressor:format property is not %G_ZLIB_COMPRESSOR_FORMAT_GZIP,
   // or the header data was not fully processed yet, or it not present in the
   // data stream at all.
   // RETURNS: a #GFileInfo, or %NULL
   FileInfo* get_file_info() {
      return g_zlib_decompressor_get_file_info(&this);
   }
}

struct ZlibDecompressorClass {
   GObject2.ObjectClass parent_class;
}


// Creates a new #GAppInfo from the given information.
// RETURNS: new #GAppInfo for given command.
// <commandline>: the commandline to use
// <application_name>: the application name, or %NULL to use @commandline
// <flags>: flags that can specify details of the created #GAppInfo
static AppInfo* /*new*/ app_info_create_from_commandline(char* commandline, char* application_name, AppInfoCreateFlags flags, GLib2.Error** error=null) {
   return g_app_info_create_from_commandline(commandline, application_name, flags, error);
}


// Gets a list of all of the applications currently registered
// on this system.
// 
// For desktop files, this includes applications that have
// <literal>NoDisplay=true</literal> set or are excluded from
// display by means of <literal>OnlyShowIn</literal> or
// <literal>NotShowIn</literal>. See g_app_info_should_show().
// The returned list does not include applications which have
// the <literal>Hidden</literal> key set.
// RETURNS: a newly allocated #GList of references to #GAppInfo<!---->s.
static GLib2.List* /*new*/ app_info_get_all() {
   return g_app_info_get_all();
}


// Gets a list of all #GAppInfos for a given content type.
// 
// for given @content_type or %NULL on error.
// RETURNS: #GList of #GAppInfos
// <content_type>: the content type to find a #GAppInfo for
static GLib2.List* /*new*/ app_info_get_all_for_type(char* content_type) {
   return g_app_info_get_all_for_type(content_type);
}


// Gets the #GAppInfo that corresponds to a given content type.
// 
// %NULL on error.
// RETURNS: #GAppInfo for given @content_type or
// <content_type>: the content type to find a #GAppInfo for
// <must_support_uris>: if %TRUE, the #GAppInfo is expected to support URIs
static AppInfo* /*new*/ app_info_get_default_for_type(char* content_type, int must_support_uris) {
   return g_app_info_get_default_for_type(content_type, must_support_uris);
}


// Gets the default application for launching applications
// using this URI scheme. A URI scheme is the initial part
// of the URI, up to but not including the ':', e.g. "http",
// "ftp" or "sip".
// RETURNS: #GAppInfo for given @uri_scheme or %NULL on error.
// <uri_scheme>: a string containing a URI scheme.
static AppInfo* /*new*/ app_info_get_default_for_uri_scheme(char* uri_scheme) {
   return g_app_info_get_default_for_uri_scheme(uri_scheme);
}


// Gets a list of fallback #GAppInfos for a given content type, i.e.
// those applications which claim to support the given content type
// by MIME type subclassing and not directly.
// 
// for given @content_type or %NULL on error.
// RETURNS: #GList of #GAppInfos
// <content_type>: the content type to find a #GAppInfo for
static GLib2.List* /*new*/ app_info_get_fallback_for_type(char* content_type) {
   return g_app_info_get_fallback_for_type(content_type);
}


// Gets a list of recommended #GAppInfos for a given content type, i.e.
// those applications which claim to support the given content type exactly,
// and not by MIME type subclassing.
// Note that the first application of the list is the last used one, i.e.
// the last one for which #g_app_info_set_as_last_used_for_type has been
// called.
// 
// for given @content_type or %NULL on error.
// RETURNS: #GList of #GAppInfos
// <content_type>: the content type to find a #GAppInfo for
static GLib2.List* /*new*/ app_info_get_recommended_for_type(char* content_type) {
   return g_app_info_get_recommended_for_type(content_type);
}


// Utility function that launches the default application
// registered to handle the specified uri. Synchronous I/O
// is done on the uri to detect the type of the file if
// required.
// RETURNS: %TRUE on success, %FALSE on error.
// <uri>: the uri to show
// <launch_context>: an optional #GAppLaunchContext.
static int app_info_launch_default_for_uri(char* uri, AppLaunchContext* launch_context, GLib2.Error** error=null) {
   return g_app_info_launch_default_for_uri(uri, launch_context, error);
}


// Removes all changes to the type associations done by
// g_app_info_set_as_default_for_type(),
// g_app_info_set_as_default_for_extension(),
// g_app_info_add_supports_type() or g_app_info_remove_supports_type().
// <content_type>: a content type
static void app_info_reset_type_associations(char* content_type) {
   g_app_info_reset_type_associations(content_type);
}


// Helper function for constructing #GAsyncInitable object. This is
// similar to g_object_newv() but also initializes the object asynchronously.
// 
// When the initialization is finished, @callback will be called. You can
// then call g_async_initable_new_finish() to get the new object and check
// for any errors.
// <object_type>: a #GType supporting #GAsyncInitable.
// <n_parameters>: the number of parameters in @parameters
// <parameters>: the parameters to use to construct the object
// <io_priority>: the <link linkend="io-priority">I/O priority</link> of the operation.
// <cancellable>: optional #GCancellable object, %NULL to ignore.
// <callback>: a #GAsyncReadyCallback to call when the initialization is finished
// <user_data>: the data to pass to callback function
static void async_initable_newv_async(Type object_type, uint n_parameters, GObject2.Parameter* parameters, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
   g_async_initable_newv_async(object_type, n_parameters, parameters, io_priority, cancellable, callback, user_data);
}


// Asynchronously connects to the message bus specified by @bus_type.
// 
// When the operation is finished, @callback will be invoked. You can
// then call g_bus_get_finish() to get the result of the operation.
// 
// This is a asynchronous failable function. See g_bus_get_sync() for
// the synchronous version.
// <bus_type>: A #GBusType.
// <cancellable>: A #GCancellable or %NULL.
// <callback>: A #GAsyncReadyCallback to call when the request is satisfied.
// <user_data>: The data to pass to @callback.
static void bus_get(BusType bus_type, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
   g_bus_get(bus_type, cancellable, callback, user_data);
}


// Finishes an operation started with g_bus_get().
// 
// The returned object is a singleton, that is, shared with other
// callers of g_bus_get() and g_bus_get_sync() for @bus_type. In the
// event that you need a private message bus connection, use
// g_dbus_address_get_for_bus_sync() and
// g_dbus_connection_new_for_address().
// 
// Note that the returned #GDBusConnection object will (usually) have
// the #GDBusConnection:exit-on-close property set to %TRUE.
// RETURNS: A #GDBusConnection or %NULL if @error is set. Free with g_object_unref().
// <res>: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_bus_get().
static DBusConnection* /*new*/ bus_get_finish(AsyncResult* res, GLib2.Error** error=null) {
   return g_bus_get_finish(res, error);
}


// Synchronously connects to the message bus specified by @bus_type.
// Note that the returned object may shared with other callers,
// e.g. if two separate parts of a process calls this function with
// the same @bus_type, they will share the same object.
// 
// This is a synchronous failable function. See g_bus_get() and
// g_bus_get_finish() for the asynchronous version.
// 
// The returned object is a singleton, that is, shared with other
// callers of g_bus_get() and g_bus_get_sync() for @bus_type. In the
// event that you need a private message bus connection, use
// g_dbus_address_get_for_bus_sync() and
// g_dbus_connection_new_for_address().
// 
// Note that the returned #GDBusConnection object will (usually) have
// the #GDBusConnection:exit-on-close property set to %TRUE.
// RETURNS: A #GDBusConnection or %NULL if @error is set. Free with g_object_unref().
// <bus_type>: A #GBusType.
// <cancellable>: A #GCancellable or %NULL.
static DBusConnection* /*new*/ bus_get_sync(BusType bus_type, Cancellable* cancellable, GLib2.Error** error=null) {
   return g_bus_get_sync(bus_type, cancellable, error);
}


// Unintrospectable function: bus_own_name() / g_bus_own_name()
// Starts acquiring @name on the bus specified by @bus_type and calls
// @name_acquired_handler and @name_lost_handler when the name is
// acquired respectively lost. Callbacks will be invoked in the <link
// linkend="g-main-context-push-thread-default">thread-default main
// loop</link> of the thread you are calling this function from.
// 
// You are guaranteed that one of the @name_acquired_handler and @name_lost_handler
// callbacks will be invoked after calling this function - there are three
// possible cases:
// <itemizedlist>
// <listitem><para>
// @name_lost_handler with a %NULL connection (if a connection to the bus can't be made).
// </para></listitem>
// <listitem><para>
// @bus_acquired_handler then @name_lost_handler (if the name can't be obtained)
// </para></listitem>
// <listitem><para>
// @bus_acquired_handler then @name_acquired_handler (if the name was obtained).
// </para></listitem>
// </itemizedlist>
// When you are done owning the name, just call g_bus_unown_name()
// with the owner id this function returns.
// 
// If the name is acquired or lost (for example another application
// could acquire the name if you allow replacement or the application
// currently owning the name exits), the handlers are also invoked. If the
// #GDBusConnection that is used for attempting to own the name
// closes, then @name_lost_handler is invoked since it is no
// longer possible for other processes to access the process.
// 
// You cannot use g_bus_own_name() several times for the same name (unless
// interleaved with calls to g_bus_unown_name()) - only the first call
// will work.
// 
// Another guarantee is that invocations of @name_acquired_handler
// and @name_lost_handler are guaranteed to alternate; that
// is, if @name_acquired_handler is invoked then you are
// guaranteed that the next time one of the handlers is invoked, it
// will be @name_lost_handler. The reverse is also true.
// 
// If you plan on exporting objects (using e.g.
// g_dbus_connection_register_object()), note that it is generally too late
// to export the objects in @name_acquired_handler. Instead, you can do this
// in @bus_acquired_handler since you are guaranteed that this will run
// before @name is requested from the bus.
// 
// This behavior makes it very simple to write applications that wants
// to own names and export objects, see <xref linkend="gdbus-owning-names"/>.
// Simply register objects to be exported in @bus_acquired_handler and
// unregister the objects (if any) in @name_lost_handler.
// 
// g_bus_unown_name() to stop owning the name.
// RETURNS: An identifier (never 0) that an be used with
// <bus_type>: The type of bus to own a name on.
// <name>: The well-known name to own.
// <flags>: A set of flags from the #GBusNameOwnerFlags enumeration.
// <bus_acquired_handler>: Handler to invoke when connected to the bus of type @bus_type or %NULL.
// <name_acquired_handler>: Handler to invoke when @name is acquired or %NULL.
// <name_lost_handler>: Handler to invoke when @name is lost or %NULL.
// <user_data>: User data to pass to handlers.
// <user_data_free_func>: Function for freeing @user_data or %NULL.
static uint bus_own_name(BusType bus_type, char* name, BusNameOwnerFlags flags, BusAcquiredCallback bus_acquired_handler, BusNameAcquiredCallback name_acquired_handler, BusNameLostCallback name_lost_handler, void* user_data, GLib2.DestroyNotify user_data_free_func) {
   return g_bus_own_name(bus_type, name, flags, bus_acquired_handler, name_acquired_handler, name_lost_handler, user_data, user_data_free_func);
}


// Unintrospectable function: bus_own_name_on_connection() / g_bus_own_name_on_connection()
// Like g_bus_own_name() but takes a #GDBusConnection instead of a
// #GBusType.
// 
// g_bus_unown_name() to stop owning the name.
// RETURNS: An identifier (never 0) that an be used with
// <connection>: A #GDBusConnection.
// <name>: The well-known name to own.
// <flags>: A set of flags from the #GBusNameOwnerFlags enumeration.
// <name_acquired_handler>: Handler to invoke when @name is acquired or %NULL.
// <name_lost_handler>: Handler to invoke when @name is lost or %NULL.
// <user_data>: User data to pass to handlers.
// <user_data_free_func>: Function for freeing @user_data or %NULL.
static uint bus_own_name_on_connection(DBusConnection* connection, char* name, BusNameOwnerFlags flags, BusNameAcquiredCallback name_acquired_handler, BusNameLostCallback name_lost_handler, void* user_data, GLib2.DestroyNotify user_data_free_func) {
   return g_bus_own_name_on_connection(connection, name, flags, name_acquired_handler, name_lost_handler, user_data, user_data_free_func);
}


// Version of g_bus_own_name_on_connection() using closures instead of callbacks for
// easier binding in other languages.
// 
// g_bus_unown_name() to stop owning the name.
// RETURNS: An identifier (never 0) that an be used with
// <connection>: A #GDBusConnection.
// <name>: The well-known name to own.
// <flags>: A set of flags from the #GBusNameOwnerFlags enumeration.
// <name_acquired_closure>: #GClosure to invoke when @name is acquired or %NULL.
// <name_lost_closure>: #GClosure to invoke when @name is lost or %NULL.
static uint bus_own_name_on_connection_with_closures(DBusConnection* connection, char* name, BusNameOwnerFlags flags, GObject2.Closure* name_acquired_closure=null, GObject2.Closure* name_lost_closure=null) {
   return g_bus_own_name_on_connection_with_closures(connection, name, flags, name_acquired_closure, name_lost_closure);
}


// Version of g_bus_own_name() using closures instead of callbacks for
// easier binding in other languages.
// 
// g_bus_unown_name() to stop owning the name.
// RETURNS: An identifier (never 0) that an be used with
// <bus_type>: The type of bus to own a name on.
// <name>: The well-known name to own.
// <flags>: A set of flags from the #GBusNameOwnerFlags enumeration.
// <bus_acquired_closure>: #GClosure to invoke when connected to the bus of type @bus_type or %NULL.
// <name_acquired_closure>: #GClosure to invoke when @name is acquired or %NULL.
// <name_lost_closure>: #GClosure to invoke when @name is lost or %NULL.
static uint bus_own_name_with_closures(BusType bus_type, char* name, BusNameOwnerFlags flags, GObject2.Closure* bus_acquired_closure=null, GObject2.Closure* name_acquired_closure=null, GObject2.Closure* name_lost_closure=null) {
   return g_bus_own_name_with_closures(bus_type, name, flags, bus_acquired_closure, name_acquired_closure, name_lost_closure);
}


// Stops owning a name.
// <owner_id>: An identifier obtained from g_bus_own_name()
static void bus_unown_name(uint owner_id) {
   g_bus_unown_name(owner_id);
}


// Stops watching a name.
// <watcher_id>: An identifier obtained from g_bus_watch_name()
static void bus_unwatch_name(uint watcher_id) {
   g_bus_unwatch_name(watcher_id);
}


// Unintrospectable function: bus_watch_name() / g_bus_watch_name()
// Starts watching @name on the bus specified by @bus_type and calls
// @name_appeared_handler and @name_vanished_handler when the name is
// known to have a owner respectively known to lose its
// owner. Callbacks will be invoked in the <link
// linkend="g-main-context-push-thread-default">thread-default main
// loop</link> of the thread you are calling this function from.
// 
// You are guaranteed that one of the handlers will be invoked after
// calling this function. When you are done watching the name, just
// call g_bus_unwatch_name() with the watcher id this function
// returns.
// 
// If the name vanishes or appears (for example the application owning
// the name could restart), the handlers are also invoked. If the
// #GDBusConnection that is used for watching the name disconnects, then
// @name_vanished_handler is invoked since it is no longer
// possible to access the name.
// 
// Another guarantee is that invocations of @name_appeared_handler
// and @name_vanished_handler are guaranteed to alternate; that
// is, if @name_appeared_handler is invoked then you are
// guaranteed that the next time one of the handlers is invoked, it
// will be @name_vanished_handler. The reverse is also true.
// 
// This behavior makes it very simple to write applications that wants
// to take action when a certain name exists, see <xref
// linkend="gdbus-watching-names"/>. Basically, the application
// should create object proxies in @name_appeared_handler and destroy
// them again (if any) in @name_vanished_handler.
// 
// g_bus_unwatch_name() to stop watching the name.
// RETURNS: An identifier (never 0) that an be used with
// <bus_type>: The type of bus to watch a name on.
// <name>: The name (well-known or unique) to watch.
// <flags>: Flags from the #GBusNameWatcherFlags enumeration.
// <name_appeared_handler>: Handler to invoke when @name is known to exist or %NULL.
// <name_vanished_handler>: Handler to invoke when @name is known to not exist or %NULL.
// <user_data>: User data to pass to handlers.
// <user_data_free_func>: Function for freeing @user_data or %NULL.
static uint bus_watch_name(BusType bus_type, char* name, BusNameWatcherFlags flags, BusNameAppearedCallback name_appeared_handler, BusNameVanishedCallback name_vanished_handler, void* user_data, GLib2.DestroyNotify user_data_free_func) {
   return g_bus_watch_name(bus_type, name, flags, name_appeared_handler, name_vanished_handler, user_data, user_data_free_func);
}


// Unintrospectable function: bus_watch_name_on_connection() / g_bus_watch_name_on_connection()
// Like g_bus_watch_name() but takes a #GDBusConnection instead of a
// #GBusType.
// 
// g_bus_unwatch_name() to stop watching the name.
// RETURNS: An identifier (never 0) that an be used with
// <connection>: A #GDBusConnection.
// <name>: The name (well-known or unique) to watch.
// <flags>: Flags from the #GBusNameWatcherFlags enumeration.
// <name_appeared_handler>: Handler to invoke when @name is known to exist or %NULL.
// <name_vanished_handler>: Handler to invoke when @name is known to not exist or %NULL.
// <user_data>: User data to pass to handlers.
// <user_data_free_func>: Function for freeing @user_data or %NULL.
static uint bus_watch_name_on_connection(DBusConnection* connection, char* name, BusNameWatcherFlags flags, BusNameAppearedCallback name_appeared_handler, BusNameVanishedCallback name_vanished_handler, void* user_data, GLib2.DestroyNotify user_data_free_func) {
   return g_bus_watch_name_on_connection(connection, name, flags, name_appeared_handler, name_vanished_handler, user_data, user_data_free_func);
}


// Version of g_bus_watch_name_on_connection() using closures instead of callbacks for
// easier binding in other languages.
// 
// g_bus_unwatch_name() to stop watching the name.
// RETURNS: An identifier (never 0) that an be used with
// <connection>: A #GDBusConnection.
// <name>: The name (well-known or unique) to watch.
// <flags>: Flags from the #GBusNameWatcherFlags enumeration.
// <name_appeared_closure>: #GClosure to invoke when @name is known to exist or %NULL.
// <name_vanished_closure>: #GClosure to invoke when @name is known to not exist or %NULL.
static uint bus_watch_name_on_connection_with_closures(DBusConnection* connection, char* name, BusNameWatcherFlags flags, GObject2.Closure* name_appeared_closure=null, GObject2.Closure* name_vanished_closure=null) {
   return g_bus_watch_name_on_connection_with_closures(connection, name, flags, name_appeared_closure, name_vanished_closure);
}


// Version of g_bus_watch_name() using closures instead of callbacks for
// easier binding in other languages.
// 
// g_bus_unwatch_name() to stop watching the name.
// RETURNS: An identifier (never 0) that an be used with
// <bus_type>: The type of bus to watch a name on.
// <name>: The name (well-known or unique) to watch.
// <flags>: Flags from the #GBusNameWatcherFlags enumeration.
// <name_appeared_closure>: #GClosure to invoke when @name is known to exist or %NULL.
// <name_vanished_closure>: #GClosure to invoke when @name is known to not exist or %NULL.
static uint bus_watch_name_with_closures(BusType bus_type, char* name, BusNameWatcherFlags flags, GObject2.Closure* name_appeared_closure=null, GObject2.Closure* name_vanished_closure=null) {
   return g_bus_watch_name_with_closures(bus_type, name, flags, name_appeared_closure, name_vanished_closure);
}


// Checks if a content type can be executable. Note that for instance
// things like text files can be executables (i.e. scripts and batch files).
// 
// can be executable, %FALSE otherwise.
// RETURNS: %TRUE if the file type corresponds to a type that
// <type>: a content type string
static int content_type_can_be_executable(char* type) {
   return g_content_type_can_be_executable(type);
}


// Compares two content types for equality.
// 
// %FALSE otherwise.
// RETURNS: %TRUE if the two strings are identical or equivalent,
// <type1>: a content type string
// <type2>: a content type string
static int content_type_equals(char* type1, char* type2) {
   return g_content_type_equals(type1, type2);
}


// Tries to find a content type based on the mime type name.
// 
// or %NULL. Free with g_free()
// RETURNS: Newly allocated string with content type
// <mime_type>: a mime type string
static char* /*new*/ content_type_from_mime_type(char* mime_type) {
   return g_content_type_from_mime_type(mime_type);
}


// Gets the human readable description of the content type.
// 
// returned string with g_free()
// RETURNS: a short description of the content type @type. Free the
// <type>: a content type string
static char* /*new*/ content_type_get_description(char* type) {
   return g_content_type_get_description(type);
}


// Gets the icon for a content type.
// 
// object with g_object_unref()
// RETURNS: #GIcon corresponding to the content type. Free the returned
// <type>: a content type string
static Icon* /*new*/ content_type_get_icon(char* type) {
   return g_content_type_get_icon(type);
}


// Gets the mime type for the content type, if one is registered.
// 
// or %NULL if unknown.
// RETURNS: the registered mime type for the given @type,
// <type>: a content type string
static char* /*new*/ content_type_get_mime_type(char* type) {
   return g_content_type_get_mime_type(type);
}


// Guesses the content type based on example data. If the function is
// uncertain, @result_uncertain will be set to %TRUE. Either @filename
// or @data may be %NULL, in which case the guess will be based solely
// on the other argument.
// 
// given data. Free with g_free()
// RETURNS: a string indicating a guessed content type for the
// <filename>: a string, or %NULL
// <data>: a stream of data, or %NULL
// <data_size>: the size of @data
// <result_uncertain>: return location for the certainty of the result, or %NULL
static char* /*new*/ content_type_guess(char* filename, ubyte* data, size_t data_size, /*out*/ int* result_uncertain=null) {
   return g_content_type_guess(filename, data, data_size, result_uncertain);
}


// Tries to guess the type of the tree with root @root, by
// looking at the files it contains. The result is an array
// of content types, with the best guess coming first.
// 
// The types returned all have the form x-content/foo, e.g.
// x-content/audio-cdda (for audio CDs) or x-content/image-dcf
// (for a camera memory card). See the <ulink url="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</ulink>
// specification for more on x-content types.
// 
// This function is useful in the implementation of
// g_mount_guess_content_type().
// 
// array of zero or more content types, or %NULL. Free with g_strfreev()
// RETURNS: an %NULL-terminated
// <root>: the root of the tree to guess a type for
static char** /*new*/ content_type_guess_for_tree(File* root) {
   return g_content_type_guess_for_tree(root);
}


// Determines if @type is a subset of @supertype.
// 
// %FALSE otherwise.
// RETURNS: %TRUE if @type is a kind of @supertype,
// <type>: a content type string
// <supertype>: a content type string
static int content_type_is_a(char* type, char* supertype) {
   return g_content_type_is_a(type, supertype);
}


// Checks if the content type is the generic "unknown" type.
// On UNIX this is the "application/octet-stream" mimetype,
// while on win32 it is "*".
// RETURNS: %TRUE if the type is the unknown type.
// <type>: a content type string
static int content_type_is_unknown(char* type) {
   return g_content_type_is_unknown(type);
}


// Gets a list of strings containing all the registered content types
// known to the system. The list and its data should be freed using
// <programlisting>
// g_list_foreach (list, g_free, NULL);
// g_list_free (list);
// </programlisting>
// RETURNS: #GList of the registered content types
static GLib2.List* /*new*/ content_types_get_registered() {
   return g_content_types_get_registered();
}


// Synchronously looks up the D-Bus address for the well-known message
// bus instance specified by @bus_type. This may involve using various
// platform specific mechanisms.
// RETURNS: A valid D-Bus address string for @bus_type or %NULL if @error is set.
// <bus_type>: A #GBusType.
// <cancellable>: A #GCancellable or %NULL.
static char* /*new*/ dbus_address_get_for_bus_sync(BusType bus_type, Cancellable* cancellable, GLib2.Error** error=null) {
   return g_dbus_address_get_for_bus_sync(bus_type, cancellable, error);
}


// Asynchronously connects to an endpoint specified by @address and
// sets up the connection so it is in a state to run the client-side
// of the D-Bus authentication conversation.
// 
// When the operation is finished, @callback will be invoked. You can
// then call g_dbus_address_get_stream_finish() to get the result of
// the operation.
// 
// This is an asynchronous failable function. See
// g_dbus_address_get_stream_sync() for the synchronous version.
// <address>: A valid D-Bus address.
// <cancellable>: A #GCancellable or %NULL.
// <callback>: A #GAsyncReadyCallback to call when the request is satisfied.
// <user_data>: Data to pass to @callback.
static void dbus_address_get_stream(char* address, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data) {
   g_dbus_address_get_stream(address, cancellable, callback, user_data);
}


// Finishes an operation started with g_dbus_address_get_stream().
// RETURNS: A #GIOStream or %NULL if @error is set.
// <res>: A #GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_address_get_stream().
// <out_guid>: %NULL or return location to store the GUID extracted from @address, if any.
static IOStream* /*new*/ dbus_address_get_stream_finish(AsyncResult* res, char** out_guid, GLib2.Error** error=null) {
   return g_dbus_address_get_stream_finish(res, out_guid, error);
}


// Synchronously connects to an endpoint specified by @address and
// sets up the connection so it is in a state to run the client-side
// of the D-Bus authentication conversation.
// 
// This is a synchronous failable function. See
// g_dbus_address_get_stream() for the asynchronous version.
// RETURNS: A #GIOStream or %NULL if @error is set.
// <address>: A valid D-Bus address.
// <out_guid>: %NULL or return location to store the GUID extracted from @address, if any.
// <cancellable>: A #GCancellable or %NULL.
static IOStream* /*new*/ dbus_address_get_stream_sync(char* address, char** out_guid, Cancellable* cancellable, GLib2.Error** error=null) {
   return g_dbus_address_get_stream_sync(address, out_guid, cancellable, error);
}


// Looks up the value of an annotation.
// 
// This cost of this function is O(n) in number of annotations.
// RETURNS: The value or %NULL if not found. Do not free, it is owned by @annotations.
// <annotations>: A %NULL-terminated array of annotations or %NULL.
// <name>: The name of the annotation to look up.
static char* dbus_annotation_info_lookup(DBusAnnotationInfo** annotations, char* name) {
   return g_dbus_annotation_info_lookup(annotations, name);
}


// Creates a D-Bus error name to use for @error. If @error matches
// a registered error (cf. g_dbus_error_register_error()), the corresponding
// D-Bus error name will be returned.
// 
// Otherwise the a name of the form
// <literal>org.gtk.GDBus.UnmappedGError.Quark._ESCAPED_QUARK_NAME.Code_ERROR_CODE</literal>
// will be used. This allows other GDBus applications to map the error
// on the wire back to a #GError using g_dbus_error_new_for_dbus_error().
// 
// This function is typically only used in object mappings to put a
// #GError on the wire. Regular applications should not use it.
// RETURNS: A D-Bus error name (never %NULL). Free with g_free().
// <error>: A #GError.
static char* /*new*/ dbus_error_encode_gerror(GLib2.Error* error) {
   return g_dbus_error_encode_gerror(error);
}


// Gets the D-Bus error name used for @error, if any.
// 
// This function is guaranteed to return a D-Bus error name for all
// #GError<!-- -->s returned from functions handling remote method
// calls (e.g. g_dbus_connection_call_finish()) unless
// g_dbus_error_strip_remote_error() has been used on @error.
// RETURNS: An allocated string or %NULL if the D-Bus error name could not be found. Free with g_free().
// <error>: A #GError.
static char* /*new*/ dbus_error_get_remote_error(GLib2.Error* error) {
   return g_dbus_error_get_remote_error(error);
}


// Checks if @error represents an error received via D-Bus from a remote peer. If so,
// use g_dbus_error_get_remote_error() to get the name of the error.
// 
// %FALSE otherwise.
// RETURNS: %TRUE if @error represents an error from a remote peer,
// <error>: A #GError.
static int dbus_error_is_remote_error(GLib2.Error* error) {
   return g_dbus_error_is_remote_error(error);
}


// Creates a #GError based on the contents of @dbus_error_name and
// @dbus_error_message.
// 
// Errors registered with g_dbus_error_register_error() will be looked
// up using @dbus_error_name and if a match is found, the error domain
// and code is used. Applications can use g_dbus_error_get_remote_error()
// to recover @dbus_error_name.
// 
// If a match against a registered error is not found and the D-Bus
// error name is in a form as returned by g_dbus_error_encode_gerror()
// the error domain and code encoded in the name is used to
// create the #GError. Also, @dbus_error_name is added to the error message
// such that it can be recovered with g_dbus_error_get_remote_error().
// 
// Otherwise, a #GError with the error code %G_IO_ERROR_DBUS_ERROR
// in the #G_IO_ERROR error domain is returned. Also, @dbus_error_name is
// added to the error message such that it can be recovered with
// g_dbus_error_get_remote_error().
// 
// In all three cases, @dbus_error_name can always be recovered from the
// returned #GError using the g_dbus_error_get_remote_error() function
// (unless g_dbus_error_strip_remote_error() hasn't been used on the returned error).
// 
// This function is typically only used in object mappings to prepare
// #GError instances for applications. Regular applications should not use
// it.
// RETURNS: An allocated #GError. Free with g_error_free().
// <dbus_error_name>: D-Bus error name.
// <dbus_error_message>: D-Bus error message.
static GLib2.Error* /*new*/ dbus_error_new_for_dbus_error(char* dbus_error_name, char* dbus_error_message) {
   return g_dbus_error_new_for_dbus_error(dbus_error_name, dbus_error_message);
}

static GLib2.Quark dbus_error_quark() {
   return g_dbus_error_quark();
}


// Creates an association to map between @dbus_error_name and
// #GError<!-- -->s specified by @error_domain and @error_code.
// 
// This is typically done in the routine that returns the #GQuark for
// an error domain.
// 
// exists.
// RETURNS: %TRUE if the association was created, %FALSE if it already
// <error_domain>: A #GQuark for a error domain.
// <error_code>: An error code.
// <dbus_error_name>: A D-Bus error name.
static int dbus_error_register_error(GLib2.Quark error_domain, int error_code, char* dbus_error_name) {
   return g_dbus_error_register_error(error_domain, error_code, dbus_error_name);
}


// Helper function for associating a #GError error domain with D-Bus error names.
// <error_domain_quark_name>: The error domain name.
// <quark_volatile>: A pointer where to store the #GQuark.
// <entries>: A pointer to @num_entries #GDBusErrorEntry struct items.
// <num_entries>: Number of items to register.
static void dbus_error_register_error_domain(char* error_domain_quark_name, size_t* quark_volatile, DBusErrorEntry* entries, uint num_entries) {
   g_dbus_error_register_error_domain(error_domain_quark_name, quark_volatile, entries, num_entries);
}


// Looks for extra information in the error message used to recover
// the D-Bus error name and strips it if found. If stripped, the
// message field in @error will correspond exactly to what was
// received on the wire.
// 
// This is typically used when presenting errors to the end user.
// RETURNS: %TRUE if information was stripped, %FALSE otherwise.
// <error>: A #GError.
static int dbus_error_strip_remote_error(GLib2.Error* error) {
   return g_dbus_error_strip_remote_error(error);
}


// Destroys an association previously set up with g_dbus_error_register_error().
// RETURNS: %TRUE if the association was destroyed, %FALSE if it wasn't found.
// <error_domain>: A #GQuark for a error domain.
// <error_code>: An error code.
// <dbus_error_name>: A D-Bus error name.
static int dbus_error_unregister_error(GLib2.Quark error_domain, int error_code, char* dbus_error_name) {
   return g_dbus_error_unregister_error(error_domain, error_code, dbus_error_name);
}


// Generate a D-Bus GUID that can be used with
// e.g. g_dbus_connection_new().
// 
// See the D-Bus specification regarding what strings are valid D-Bus
// GUID (for example, D-Bus GUIDs are not RFC-4122 compliant).
// RETURNS: A valid D-Bus GUID. Free with g_free().
static char* /*new*/ dbus_generate_guid() {
   return g_dbus_generate_guid();
}


// Converts a #GValue to a #GVariant of the type indicated by the @type parameter.
// 
// The conversion is using the following rules:
// <table frame='all'>
// <title>#GValue / #GVariant conversion rules</title>
// <tgroup cols='2' align='left' colsep='1' rowsep='1'>
// <thead>
// <row>
// <entry>If the #GType for @gvalue is...</entry>
// <entry>... then @type must be</entry>
// </row>
// </thead>
// <tbody>
// <row>
// <entry>#G_TYPE_STRING</entry>
// <entry><link linkend="G-VARIANT-TYPE-STRING:CAPS">'s'</link>, <link linkend="G-VARIANT-TYPE-OBJECT-PATH:CAPS">'o'</link>, <link linkend="G-VARIANT-TYPE-SIGNATURE:CAPS">'g'</link> or <link linkend="G-VARIANT-TYPE-BYTESTRING:CAPS">'ay'</link></entry>
// </row>
// <row>
// <entry>#G_TYPE_STRV</entry>
// <entry><link linkend="G-VARIANT-TYPE-STRING-ARRAY:CAPS">'as'</link>, <link linkend="G-VARIANT-TYPE-OBJECT-PATH-ARRAY:CAPS">'ao'</link> or <link linkend="G-VARIANT-TYPE-BYTESTRING-ARRAY:CAPS">'aay'</link></entry>
// </row>
// <row>
// <entry>#G_TYPE_BOOLEAN</entry>
// <entry><link linkend="G-VARIANT-TYPE-BOOLEAN:CAPS">'b'</link></entry>
// </row>
// <row>
// <entry>#G_TYPE_UCHAR</entry>
// <entry><link linkend="G-VARIANT-TYPE-BYTE:CAPS">'y'</link></entry>
// </row>
// <row>
// <entry>#G_TYPE_INT</entry>
// <entry><link linkend="G-VARIANT-TYPE-INT32:CAPS">'i'</link> or <link linkend="G-VARIANT-TYPE-INT16:CAPS">'n'</link></entry>
// </row>
// <row>
// <entry>#G_TYPE_UINT</entry>
// <entry><link linkend="G-VARIANT-TYPE-UINT32:CAPS">'u'</link> or <link linkend="G-VARIANT-TYPE-UINT16:CAPS">'q'</link></entry>
// </row>
// <row>
// <entry>#G_TYPE_INT64</entry>
// <entry><link linkend="G-VARIANT-TYPE-INT64:CAPS">'x'</link></entry>
// </row>
// <row>
// <entry>#G_TYPE_UINT64</entry>
// <entry><link linkend="G-VARIANT-TYPE-UINT64:CAPS">'t'</link></entry>
// </row>
// <row>
// <entry>#G_TYPE_DOUBLE</entry>
// <entry><link linkend="G-VARIANT-TYPE-DOUBLE:CAPS">'d'</link></entry>
// </row>
// <row>
// <entry>#G_TYPE_VARIANT</entry>
// <entry>Any #GVariantType</entry>
// </row>
// </tbody>
// </tgroup>
// </table>
// This can fail if e.g. @gvalue is of type #G_TYPE_STRING and @type
// is <link linkend="G-VARIANT-TYPE-INT32:CAPS">'i'</link>. It will
// also fail for any #GType (including e.g. #G_TYPE_OBJECT and
// #G_TYPE_BOXED derived-types) not in the table above.
// 
// Note that if @gvalue is of type #G_TYPE_VARIANT and its value is
// %NULL, the <emphasis>empty</emphasis> #GVariant instance (never
// %NULL) for @type is returned (e.g. 0 for scalar types, the empty
// string for string types, <literal>'/'</literal> for object path
// types, the empty array for any array type and so on).
// 
// See the g_dbus_gvariant_to_gvalue() function for how to convert a
// #GVariant to a #GValue.
// 
// @type holding the data from @gvalue or %NULL in case of
// failure. Free with g_variant_unref().
// RETURNS: A #GVariant (never floating) of #GVariantType
// <gvalue>: A #GValue to convert to a #GVariant.
// <type>: A #GVariantType.
static GLib2.Variant* /*new*/ dbus_gvalue_to_gvariant(GObject2.Value* gvalue, GLib2.VariantType* type) {
   return g_dbus_gvalue_to_gvariant(gvalue, type);
}


// Converts a #GVariant to a #GValue. If @value is floating, it is consumed.
// 
// The rules specified in the g_dbus_gvalue_to_gvariant() function are
// used - this function is essentially its reverse form.
// 
// The conversion never fails - a valid #GValue is always returned in
// @out_gvalue.
// <value>: A #GVariant.
// <out_gvalue>: Return location pointing to a zero-filled (uninitialized) #GValue.
static void dbus_gvariant_to_gvalue(GLib2.Variant* value, GObject2.Value* out_gvalue) {
   g_dbus_gvariant_to_gvalue(value, out_gvalue);
}


// Checks if @string is a D-Bus address.
// 
// This doesn't check if @string is actually supported by #GDBusServer
// or #GDBusConnection - use g_dbus_is_supported_address() to do more
// checks.
// RETURNS: %TRUE if @string is a valid D-Bus address, %FALSE otherwise.
// <string>: A string.
static int dbus_is_address(char* string_) {
   return g_dbus_is_address(string_);
}


// Checks if @string is a D-Bus GUID.
// 
// See the D-Bus specification regarding what strings are valid D-Bus
// GUID (for example, D-Bus GUIDs are not RFC-4122 compliant).
// RETURNS: %TRUE if @string is a guid, %FALSE otherwise.
// <string>: The string to check.
static int dbus_is_guid(char* string_) {
   return g_dbus_is_guid(string_);
}


// Checks if @string is a valid D-Bus interface name.
// RETURNS: %TRUE if valid, %FALSE otherwise.
// <string>: The string to check.
static int dbus_is_interface_name(char* string_) {
   return g_dbus_is_interface_name(string_);
}


// Checks if @string is a valid D-Bus member (e.g. signal or method) name.
// RETURNS: %TRUE if valid, %FALSE otherwise.
// <string>: The string to check.
static int dbus_is_member_name(char* string_) {
   return g_dbus_is_member_name(string_);
}


// Checks if @string is a valid D-Bus bus name (either unique or well-known).
// RETURNS: %TRUE if valid, %FALSE otherwise.
// <string>: The string to check.
static int dbus_is_name(char* string_) {
   return g_dbus_is_name(string_);
}


// Like g_dbus_is_address() but also checks if the library suppors the
// transports in @string and that key/value pairs for each transport
// are valid.
// 
// supported by this library, %FALSE if @error is set.
// RETURNS: %TRUE if @string is a valid D-Bus address that is
// <string>: A string.
static int dbus_is_supported_address(char* string_, GLib2.Error** error=null) {
   return g_dbus_is_supported_address(string_, error);
}


// Checks if @string is a valid D-Bus unique bus name.
// RETURNS: %TRUE if valid, %FALSE otherwise.
// <string>: The string to check.
static int dbus_is_unique_name(char* string_) {
   return g_dbus_is_unique_name(string_);
}


// Creates a hash value for a #GFile.
// 
// This call does no blocking i/o.
// 
// integer that can be used as hash value for the #GFile.
// This function is intended for easily hashing a #GFile to
// add to a #GHashTable or similar data structure.
// RETURNS: 0 if @file is not a valid #GFile, otherwise an
// <file>: #gconstpointer to a #GFile.
static uint file_hash(const(void)* file) {
   return g_file_hash(file);
}


// Creates a #GFile with the given argument from the command line. The value of
// @arg can be either a URI, an absolute path or a relative path resolved
// relative to the current working directory.
// This operation never fails, but the returned object might not support any
// I/O operation if @arg points to a malformed path.
// RETURNS: a new #GFile.
// <arg>: a command line string.
static File* /*new*/ file_new_for_commandline_arg(char* arg) {
   return g_file_new_for_commandline_arg(arg);
}


// Constructs a #GFile for a given path. This operation never
// fails, but the returned object might not support any I/O
// operation if @path is malformed.
// RETURNS: a new #GFile for the given @path.
// <path>: a string containing a relative or absolute path. The string must be encoded in the glib filename encoding.
static File* /*new*/ file_new_for_path(char* path) {
   return g_file_new_for_path(path);
}


// Constructs a #GFile for a given URI. This operation never
// fails, but the returned object might not support any I/O
// operation if @uri is malformed or if the uri type is
// not supported.
// RETURNS: a #GFile for the given @uri.
// <uri>: a UTF8 string containing a URI.
static File* /*new*/ file_new_for_uri(char* uri) {
   return g_file_new_for_uri(uri);
}


// Constructs a #GFile with the given @parse_name (i.e. something given by g_file_get_parse_name()).
// This operation never fails, but the returned object might not support any I/O
// operation if the @parse_name cannot be parsed.
// RETURNS: a new #GFile.
// <parse_name>: a file name or path to be parsed.
static File* /*new*/ file_parse_name(char* parse_name) {
   return g_file_parse_name(parse_name);
}


// Gets a hash for an icon.
// 
// use in a #GHashTable or similar data structure.
// RETURNS: a #guint containing a hash for the @icon, suitable for
// <icon>: #gconstpointer to an icon object.
static uint icon_hash(const(void)* icon) {
   return g_icon_hash(icon);
}


// Generate a #GIcon instance from @str. This function can fail if
// @str is not valid - see g_icon_to_string() for discussion.
// 
// If your application or library provides one or more #GIcon
// implementations you need to ensure that each #GType is registered
// with the type system prior to calling g_icon_new_for_string().
// 
// interface or %NULL if @error is set.
// RETURNS: An object implementing the #GIcon
// <str>: A string obtained via g_icon_to_string().
static Icon* /*new*/ icon_new_for_string(char* str, GLib2.Error** error=null) {
   return g_icon_new_for_string(str, error);
}


// Helper function for constructing #GInitiable object. This is
// similar to g_object_newv() but also initializes the object
// and returns %NULL, setting an error on failure.
// RETURNS: a newly allocated #GObject, or %NULL on error
// <object_type>: a #GType supporting #GInitable.
// <n_parameters>: the number of parameters in @parameters
// <parameters>: the parameters to use to construct the object
// <cancellable>: optional #GCancellable object, %NULL to ignore.
static void* /*new*/ initable_newv(Type object_type, uint n_parameters, GObject2.Parameter* parameters, Cancellable* cancellable, GLib2.Error** error=null) {
   return g_initable_newv(object_type, n_parameters, parameters, cancellable, error);
}


// Converts errno.h error codes into GIO error codes.
// RETURNS: #GIOErrorEnum value for the given errno.h error number.
// <err_no>: Error number as defined in errno.h.
static IOErrorEnum io_error_from_errno(int err_no) {
   return g_io_error_from_errno(err_no);
}


// Gets the GIO Error Quark.
// RETURNS: a #GQuark.
static GLib2.Quark io_error_quark() {
   return g_io_error_quark();
}


// Gets the type associated with @extension.
// RETURNS: the type of @extension
// <extension>: a #GIOExtension
static Type io_extension_get_type(IOExtension* extension) {
   return g_io_extension_get_type(extension);
}


// Registers @type as extension for the extension point with name
// @extension_point_name.
// 
// If @type has already been registered as an extension for this
// extension point, the existing #GIOExtension object is returned.
// RETURNS: a #GIOExtension object for #GType
// <extension_point_name>: the name of the extension point
// <type>: the #GType to register as extension
// <extension_name>: the name for the extension
// <priority>: the priority for the extension
static IOExtension* io_extension_point_implement(char* extension_point_name, Type type, char* extension_name, int priority) {
   return g_io_extension_point_implement(extension_point_name, type, extension_name, priority);
}


// Looks up an existing extension point.
// 
// is no registered extension point with the given name.
// RETURNS: the #GIOExtensionPoint, or %NULL if there
// <name>: the name of the extension point
static IOExtensionPoint* io_extension_point_lookup(char* name) {
   return g_io_extension_point_lookup(name);
}


// Registers an extension point.
// 
// owned by GIO and should not be freed.
// RETURNS: the new #GIOExtensionPoint. This object is
// <name>: The name of the extension point
static IOExtensionPoint* io_extension_point_register(char* name) {
   return g_io_extension_point_register(name);
}


// Loads all the modules in the specified directory.
// 
// If don't require all modules to be initialized (and thus registering
// all gtypes) then you can use g_io_modules_scan_all_in_directory()
// which allows delayed/lazy loading of modules.
// 
// from the directory,
// All the modules are loaded into memory, if you want to
// unload them (enabling on-demand loading) you must call
// g_type_module_unuse() on all the modules. Free the list
// with g_list_free().
// RETURNS: a list of #GIOModules loaded
// <dirname>: pathname for a directory containing modules to load.
static GLib2.List* /*new*/ io_modules_load_all_in_directory(char* dirname) {
   return g_io_modules_load_all_in_directory(dirname);
}


// Loads all the modules in the specified directory.
// 
// If don't require all modules to be initialized (and thus registering
// all gtypes) then you can use g_io_modules_scan_all_in_directory()
// which allows delayed/lazy loading of modules.
// 
// from the directory,
// All the modules are loaded into memory, if you want to
// unload them (enabling on-demand loading) you must call
// g_type_module_unuse() on all the modules. Free the list
// with g_list_free().
// RETURNS: a list of #GIOModules loaded
// <dirname>: pathname for a directory containing modules to load.
// <scope>: a scope to use when scanning the modules.
static GLib2.List* /*new*/ io_modules_load_all_in_directory_with_scope(char* dirname, IOModuleScope* scope_) {
   return g_io_modules_load_all_in_directory_with_scope(dirname, scope_);
}


// Scans all the modules in the specified directory, ensuring that
// any extension point implemented by a module is registered.
// 
// This may not actually load and initialize all the types in each
// module, some modules may be lazily loaded and initialized when
// an extension point it implementes is used with e.g.
// g_io_extension_point_get_extensions() or
// g_io_extension_point_get_extension_by_name().
// 
// If you need to guarantee that all types are loaded in all the modules,
// use g_io_modules_load_all_in_directory().
// <dirname>: pathname for a directory containing modules to scan.
static void io_modules_scan_all_in_directory(char* dirname) {
   g_io_modules_scan_all_in_directory(dirname);
}


// Scans all the modules in the specified directory, ensuring that
// any extension point implemented by a module is registered.
// 
// This may not actually load and initialize all the types in each
// module, some modules may be lazily loaded and initialized when
// an extension point it implementes is used with e.g.
// g_io_extension_point_get_extensions() or
// g_io_extension_point_get_extension_by_name().
// 
// If you need to guarantee that all types are loaded in all the modules,
// use g_io_modules_load_all_in_directory().
// <dirname>: pathname for a directory containing modules to scan.
// <scope>: a scope to use when scanning the modules
static void io_modules_scan_all_in_directory_with_scope(char* dirname, IOModuleScope* scope_) {
   g_io_modules_scan_all_in_directory_with_scope(dirname, scope_);
}


// Cancels all cancellable I/O jobs.
// 
// A job is cancellable if a #GCancellable was passed into
// g_io_scheduler_push_job().
static void io_scheduler_cancel_all_jobs() {
   g_io_scheduler_cancel_all_jobs();
}


// Schedules the I/O job to run.
// 
// @notify will be called on @user_data after @job_func has returned,
// regardless whether the job was cancelled or has run to completion.
// 
// If @cancellable is not %NULL, it can be used to cancel the I/O job
// by calling g_cancellable_cancel() or by calling
// g_io_scheduler_cancel_all_jobs().
// <job_func>: a #GIOSchedulerJobFunc.
// <user_data>: data to pass to @job_func
// <notify>: a #GDestroyNotify for @user_data, or %NULL
// <io_priority>: the <link linkend="gioscheduler">I/O priority</link> of the request.
// <cancellable>: optional #GCancellable object, %NULL to ignore.
static void io_scheduler_push_job(IOSchedulerJobFunc job_func, void* user_data, GLib2.DestroyNotify notify, int io_priority, Cancellable* cancellable=null) {
   g_io_scheduler_push_job(job_func, user_data, notify, io_priority, cancellable);
}


// Unintrospectable function: pollable_source_new() / g_pollable_source_new()
// Utility method for #GPollableInputStream and #GPollableOutputStream
// implementations. Creates a new #GSource that expects a callback of
// type #GPollableSourceFunc. The new source does not actually do
// anything on its own; use g_source_add_child_source() to add other
// sources to it to cause it to trigger.
// RETURNS: the new #GSource.
// <pollable_stream>: the stream associated with the new source
static GLib2.Source* /*new*/ pollable_source_new(GObject2.Object* pollable_stream) {
   return g_pollable_source_new(pollable_stream);
}


// Lookup "gio-proxy" extension point for a proxy implementation that supports
// specified protocol.
// 
// is not supported.
// RETURNS: return a #GProxy or NULL if protocol
// <protocol>: the proxy protocol name (e.g. http, socks, etc)
static Proxy* /*new*/ proxy_get_default_for_protocol(char* protocol) {
   return g_proxy_get_default_for_protocol(protocol);
}


// Gets the default #GProxyResolver for the system.
// RETURNS: the default #GProxyResolver.
static ProxyResolver* proxy_resolver_get_default() {
   return g_proxy_resolver_get_default();
}


// Gets the #GResolver Error Quark.
// RETURNS: a #GQuark.
static GLib2.Quark resolver_error_quark() {
   return g_resolver_error_quark();
}


// Unintrospectable function: simple_async_report_error_in_idle() / g_simple_async_report_error_in_idle()
// Reports an error in an asynchronous function in an idle function by
// directly setting the contents of the #GAsyncResult with the given error
// information.
// <object>: a #GObject, or %NULL.
// <callback>: a #GAsyncReadyCallback.
// <user_data>: user data passed to @callback.
// <domain>: a #GQuark containing the error domain (usually #G_IO_ERROR).
// <code>: a specific error code.
// <format>: a formatted error reporting string.
alias g_simple_async_report_error_in_idle simple_async_report_error_in_idle; // Variadic


// Reports an error in an idle function. Similar to
// g_simple_async_report_error_in_idle(), but takes a #GError rather
// than building a new one.
// <object>: a #GObject, or %NULL
// <callback>: a #GAsyncReadyCallback.
// <user_data>: user data passed to @callback.
// <error>: the #GError to report
static void simple_async_report_gerror_in_idle(GObject2.Object* object, AsyncReadyCallback callback, void* user_data, GLib2.Error* error) {
   g_simple_async_report_gerror_in_idle(object, callback, user_data, error);
}


// Unintrospectable function: simple_async_report_take_gerror_in_idle() / g_simple_async_report_take_gerror_in_idle()
// Reports an error in an idle function. Similar to
// g_simple_async_report_gerror_in_idle(), but takes over the caller's
// ownership of @error, so the caller does not have to free it any more.
// <object>: a #GObject, or %NULL
// <callback>: a #GAsyncReadyCallback.
// <user_data>: user data passed to @callback.
// <error>: the #GError to report
static void simple_async_report_take_gerror_in_idle(GObject2.Object* object, AsyncReadyCallback callback, void* user_data, GLib2.Error* error) {
   g_simple_async_report_take_gerror_in_idle(object, callback, user_data, error);
}


// Unintrospectable function: srv_target_list_sort() / g_srv_target_list_sort()
// Sorts @targets in place according to the algorithm in RFC 2782.
// RETURNS: the head of the sorted list.
// <targets>: a #GList of #GSrvTarget
static GLib2.List* /*new*/ srv_target_list_sort(GLib2.List* targets) {
   return g_srv_target_list_sort(targets);
}


// Gets the default #GTlsBackend for the system.
// RETURNS: a #GTlsBackend
static TlsBackend* tls_backend_get_default() {
   return g_tls_backend_get_default();
}


// Creates a new #GTlsClientConnection wrapping @base_io_stream (which
// must have pollable input and output streams) which is assumed to
// communicate with the server identified by @server_identity.
// RETURNS: the new #GTlsClientConnection, or %NULL on error
// <base_io_stream>: the #GIOStream to wrap
// <server_identity>: the expected identity of the server
static IOStream* /*new*/ tls_client_connection_new(IOStream* base_io_stream, SocketConnectable* server_identity, GLib2.Error** error=null) {
   return g_tls_client_connection_new(base_io_stream, server_identity, error);
}


// Gets the TLS error quark.
// RETURNS: a #GQuark.
static GLib2.Quark tls_error_quark() {
   return g_tls_error_quark();
}


// Creates a new #GTlsFileDatabase which uses anchor certificate authorities
// in @anchors to verify certificate chains.
// 
// The certificates in @anchors must be PEM encoded.
// RETURNS: the new #GTlsFileDatabase, or %NULL on error
// <anchors>: filename of anchor certificate authorities.
static TlsDatabase* /*new*/ tls_file_database_new(char* anchors, GLib2.Error** error=null) {
   return g_tls_file_database_new(anchors, error);
}


// Creates a new #GTlsServerConnection wrapping @base_io_stream (which
// must have pollable input and output streams).
// RETURNS: the new #GTlsServerConnection, or %NULL on error
// <base_io_stream>: the #GIOStream to wrap
// <certificate>: the default server certificate, or %NULL
static IOStream* /*new*/ tls_server_connection_new(IOStream* base_io_stream, TlsCertificate* certificate, GLib2.Error** error=null) {
   return g_tls_server_connection_new(base_io_stream, certificate, error);
}


// Determines if @mount_path is considered an implementation of the
// OS. This is primarily used for hiding mountable and mounted volumes
// that only are used in the OS and has little to no relevance to the
// casual user.
// 
// of the OS.
// RETURNS: %TRUE if @mount_path is considered an implementation detail
// <mount_path>: a mount path, e.g. <filename>/media/disk</filename> or <filename>/usr</filename>
static int unix_is_mount_path_system_internal(char* mount_path) {
   return g_unix_is_mount_path_system_internal(mount_path);
}


// Unintrospectable function: unix_mount_at() / g_unix_mount_at()
// Gets a #GUnixMountEntry for a given mount path. If @time_read
// is set, it will be filled with a unix timestamp for checking
// if the mounts have changed since with g_unix_mounts_changed_since().
// RETURNS: a #GUnixMountEntry.
// <mount_path>: path for a possible unix mount.
// <time_read>: guint64 to contain a timestamp.
static UnixMountEntry* /*new*/ unix_mount_at(char* mount_path, /*out*/ ulong* time_read=null) {
   return g_unix_mount_at(mount_path, time_read);
}


// Compares two unix mounts.
// 
// or less than @mount2, respectively.
// RETURNS: 1, 0 or -1 if @mount1 is greater than, equal to,
// <mount1>: first #GUnixMountEntry to compare.
// <mount2>: second #GUnixMountEntry to compare.
static int unix_mount_compare(UnixMountEntry* mount1, UnixMountEntry* mount2) {
   return g_unix_mount_compare(mount1, mount2);
}


// Frees a unix mount.
// <mount_entry>: a #GUnixMount.
static void unix_mount_free(UnixMountEntry* mount_entry) {
   g_unix_mount_free(mount_entry);
}


// Gets the device path for a unix mount.
// RETURNS: a string containing the device path.
// <mount_entry>: a #GUnixMount.
static char* unix_mount_get_device_path(UnixMountEntry* mount_entry) {
   return g_unix_mount_get_device_path(mount_entry);
}


// Gets the filesystem type for the unix mount.
// RETURNS: a string containing the file system type.
// <mount_entry>: a #GUnixMount.
static char* unix_mount_get_fs_type(UnixMountEntry* mount_entry) {
   return g_unix_mount_get_fs_type(mount_entry);
}


// Gets the mount path for a unix mount.
// RETURNS: the mount path for @mount_entry.
// <mount_entry>: input #GUnixMountEntry to get the mount path for.
static char* unix_mount_get_mount_path(UnixMountEntry* mount_entry) {
   return g_unix_mount_get_mount_path(mount_entry);
}


// Guesses whether a Unix mount can be ejected.
// RETURNS: %TRUE if @mount_entry is deemed to be ejectable.
// <mount_entry>: a #GUnixMountEntry
static int unix_mount_guess_can_eject(UnixMountEntry* mount_entry) {
   return g_unix_mount_guess_can_eject(mount_entry);
}


// Guesses the icon of a Unix mount.
// RETURNS: a #GIcon
// <mount_entry>: a #GUnixMountEntry
static Icon* /*new*/ unix_mount_guess_icon(UnixMountEntry* mount_entry) {
   return g_unix_mount_guess_icon(mount_entry);
}


// Guesses the name of a Unix mount.
// The result is a translated string.
// 
// be freed with g_free()
// RETURNS: A newly allocated string that must
// <mount_entry>: a #GUnixMountEntry
static char* /*new*/ unix_mount_guess_name(UnixMountEntry* mount_entry) {
   return g_unix_mount_guess_name(mount_entry);
}


// Guesses whether a Unix mount should be displayed in the UI.
// RETURNS: %TRUE if @mount_entry is deemed to be displayable.
// <mount_entry>: a #GUnixMountEntry
static int unix_mount_guess_should_display(UnixMountEntry* mount_entry) {
   return g_unix_mount_guess_should_display(mount_entry);
}


// Checks if a unix mount is mounted read only.
// RETURNS: %TRUE if @mount_entry is read only.
// <mount_entry>: a #GUnixMount.
static int unix_mount_is_readonly(UnixMountEntry* mount_entry) {
   return g_unix_mount_is_readonly(mount_entry);
}


// Checks if a unix mount is a system path.
// RETURNS: %TRUE if the unix mount is for a system path.
// <mount_entry>: a #GUnixMount.
static int unix_mount_is_system_internal(UnixMountEntry* mount_entry) {
   return g_unix_mount_is_system_internal(mount_entry);
}


// Checks if the unix mount points have changed since a given unix time.
// RETURNS: %TRUE if the mount points have changed since @time.
// <time>: guint64 to contain a timestamp.
static int unix_mount_points_changed_since(ulong time) {
   return g_unix_mount_points_changed_since(time);
}


// Unintrospectable function: unix_mount_points_get() / g_unix_mount_points_get()
// Gets a #GList of #GUnixMountPoint containing the unix mount points.
// If @time_read is set, it will be filled with the mount timestamp,
// allowing for checking if the mounts have changed with
// g_unix_mount_points_changed_since().
// 
// a #GList of the UNIX mountpoints.
// <time_read>: guint64 to contain a timestamp.
static GLib2.List* /*new*/ unix_mount_points_get(/*out*/ ulong* time_read=null) {
   return g_unix_mount_points_get(time_read);
}


// Checks if the unix mounts have changed since a given unix time.
// RETURNS: %TRUE if the mounts have changed since @time.
// <time>: guint64 to contain a timestamp.
static int unix_mounts_changed_since(ulong time) {
   return g_unix_mounts_changed_since(time);
}


// Unintrospectable function: unix_mounts_get() / g_unix_mounts_get()
// Gets a #GList of #GUnixMountEntry containing the unix mounts.
// If @time_read is set, it will be filled with the mount
// timestamp, allowing for checking if the mounts have changed
// with g_unix_mounts_changed_since().
// 
// a #GList of the UNIX mounts.
// <time_read>: guint64 to contain a timestamp, or %NULL
static GLib2.List* /*new*/ unix_mounts_get(/*out*/ ulong* time_read=null) {
   return g_unix_mounts_get(time_read);
}


// C prototypes:

extern (C) {
void g_action_activate(Action* this_, GLib2.Variant* parameter=null);
void g_action_change_state(Action* this_, GLib2.Variant* value);
int g_action_get_enabled(Action* this_);
char* g_action_get_name(Action* this_);
GLib2.VariantType* g_action_get_parameter_type(Action* this_);
GLib2.Variant* /*new*/ g_action_get_state(Action* this_);
GLib2.Variant* /*new*/ g_action_get_state_hint(Action* this_);
GLib2.VariantType* g_action_get_state_type(Action* this_);
void g_action_group_action_added(ActionGroup* this_, char* action_name);
void g_action_group_action_enabled_changed(ActionGroup* this_, char* action_name, int enabled);
void g_action_group_action_removed(ActionGroup* this_, char* action_name);
void g_action_group_action_state_changed(ActionGroup* this_, char* action_name, GLib2.Variant* state);
void g_action_group_activate_action(ActionGroup* this_, char* action_name, GLib2.Variant* parameter=null);
void g_action_group_change_action_state(ActionGroup* this_, char* action_name, GLib2.Variant* value);
int g_action_group_get_action_enabled(ActionGroup* this_, char* action_name);
GLib2.VariantType* g_action_group_get_action_parameter_type(ActionGroup* this_, char* action_name);
GLib2.Variant* /*new*/ g_action_group_get_action_state(ActionGroup* this_, char* action_name);
GLib2.Variant* /*new*/ g_action_group_get_action_state_hint(ActionGroup* this_, char* action_name);
GLib2.VariantType* /*new*/ g_action_group_get_action_state_type(ActionGroup* this_, char* action_name);
int g_action_group_has_action(ActionGroup* this_, char* action_name);
char** /*new*/ g_action_group_list_actions(ActionGroup* this_);
AppInfo* /*new*/ g_app_info_create_from_commandline(char* commandline, char* application_name, AppInfoCreateFlags flags, GLib2.Error** error);
GLib2.List* /*new*/ g_app_info_get_all();
GLib2.List* /*new*/ g_app_info_get_all_for_type(char* content_type);
AppInfo* /*new*/ g_app_info_get_default_for_type(char* content_type, int must_support_uris);
AppInfo* /*new*/ g_app_info_get_default_for_uri_scheme(char* uri_scheme);
GLib2.List* /*new*/ g_app_info_get_fallback_for_type(char* content_type);
GLib2.List* /*new*/ g_app_info_get_recommended_for_type(char* content_type);
int g_app_info_launch_default_for_uri(char* uri, AppLaunchContext* launch_context, GLib2.Error** error);
void g_app_info_reset_type_associations(char* content_type);
int g_app_info_add_supports_type(AppInfo* this_, char* content_type, GLib2.Error** error);
int g_app_info_can_delete(AppInfo* this_);
int g_app_info_can_remove_supports_type(AppInfo* this_);
int g_app_info_delete(AppInfo* this_);
AppInfo* /*new*/ g_app_info_dup(AppInfo* this_);
int g_app_info_equal(AppInfo* this_, AppInfo* appinfo2);
char* g_app_info_get_commandline(AppInfo* this_);
char* g_app_info_get_description(AppInfo* this_);
char* g_app_info_get_display_name(AppInfo* this_);
char* g_app_info_get_executable(AppInfo* this_);
Icon* g_app_info_get_icon(AppInfo* this_);
char* g_app_info_get_id(AppInfo* this_);
char* g_app_info_get_name(AppInfo* this_);
int g_app_info_launch(AppInfo* this_, GLib2.List* files, AppLaunchContext* launch_context, GLib2.Error** error);
int g_app_info_launch_uris(AppInfo* this_, GLib2.List* uris, AppLaunchContext* launch_context, GLib2.Error** error);
int g_app_info_remove_supports_type(AppInfo* this_, char* content_type, GLib2.Error** error);
int g_app_info_set_as_default_for_extension(AppInfo* this_, char* extension, GLib2.Error** error);
int g_app_info_set_as_default_for_type(AppInfo* this_, char* content_type, GLib2.Error** error);
int g_app_info_set_as_last_used_for_type(AppInfo* this_, char* content_type, GLib2.Error** error);
int g_app_info_should_show(AppInfo* this_);
int g_app_info_supports_files(AppInfo* this_);
int g_app_info_supports_uris(AppInfo* this_);
AppLaunchContext* /*new*/ g_app_launch_context_new();
char* /*new*/ g_app_launch_context_get_display(AppLaunchContext* this_, AppInfo* info, GLib2.List* files);
char* /*new*/ g_app_launch_context_get_startup_notify_id(AppLaunchContext* this_, AppInfo* info, GLib2.List* files);
void g_app_launch_context_launch_failed(AppLaunchContext* this_, char* startup_notify_id);
Application* /*new*/ g_application_new(char* application_id, ApplicationFlags flags);
int g_application_id_is_valid(char* application_id);
void g_application_activate(Application* this_);
char* g_application_get_application_id(Application* this_);
ApplicationFlags g_application_get_flags(Application* this_);
uint g_application_get_inactivity_timeout(Application* this_);
int g_application_get_is_registered(Application* this_);
int g_application_get_is_remote(Application* this_);
void g_application_hold(Application* this_);
void g_application_open(Application* this_, File** files, int n_files, char* hint);
int g_application_register(Application* this_, Cancellable* cancellable, GLib2.Error** error);
void g_application_release(Application* this_);
int g_application_run(Application* this_, int argc, char** argv=null);
void g_application_set_action_group(Application* this_, ActionGroup* action_group=null);
void g_application_set_application_id(Application* this_, char* application_id);
void g_application_set_flags(Application* this_, ApplicationFlags flags);
void g_application_set_inactivity_timeout(Application* this_, uint inactivity_timeout);
char** /*new*/ g_application_command_line_get_arguments(ApplicationCommandLine* this_, /*out*/ int* argc);
char* g_application_command_line_get_cwd(ApplicationCommandLine* this_);
char** g_application_command_line_get_environ(ApplicationCommandLine* this_);
int g_application_command_line_get_exit_status(ApplicationCommandLine* this_);
int g_application_command_line_get_is_remote(ApplicationCommandLine* this_);
GLib2.Variant* /*new*/ g_application_command_line_get_platform_data(ApplicationCommandLine* this_);
char* g_application_command_line_getenv(ApplicationCommandLine* this_, char* name);
void g_application_command_line_print(ApplicationCommandLine* this_, char* format, ...);
void g_application_command_line_printerr(ApplicationCommandLine* this_, char* format, ...);
void g_application_command_line_set_exit_status(ApplicationCommandLine* this_, int exit_status);
void g_async_initable_new_async(Type object_type, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data, char* first_property_name, ...);
void g_async_initable_new_valist_async(Type object_type, char* first_property_name, va_list var_args, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
void g_async_initable_newv_async(Type object_type, uint n_parameters, GObject2.Parameter* parameters, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
void g_async_initable_init_async(AsyncInitable* this_, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_async_initable_init_finish(AsyncInitable* this_, AsyncResult* res, GLib2.Error** error);
GObject2.Object* /*new*/ g_async_initable_new_finish(AsyncInitable* this_, AsyncResult* res, GLib2.Error** error);
GObject2.Object* /*new*/ g_async_result_get_source_object(AsyncResult* this_);
void* /*new*/ g_async_result_get_user_data(AsyncResult* this_);
BufferedInputStream* /*new*/ g_buffered_input_stream_new(InputStream* base_stream);
BufferedInputStream* /*new*/ g_buffered_input_stream_new_sized(InputStream* base_stream, size_t size);
ssize_t g_buffered_input_stream_fill(BufferedInputStream* this_, ssize_t count, Cancellable* cancellable, GLib2.Error** error);
void g_buffered_input_stream_fill_async(BufferedInputStream* this_, ssize_t count, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
ssize_t g_buffered_input_stream_fill_finish(BufferedInputStream* this_, AsyncResult* result, GLib2.Error** error);
size_t g_buffered_input_stream_get_available(BufferedInputStream* this_);
size_t g_buffered_input_stream_get_buffer_size(BufferedInputStream* this_);
size_t g_buffered_input_stream_peek(BufferedInputStream* this_, void* buffer, size_t offset, size_t count);
ubyte* g_buffered_input_stream_peek_buffer(BufferedInputStream* this_, /*out*/ size_t* count);
int g_buffered_input_stream_read_byte(BufferedInputStream* this_, Cancellable* cancellable, GLib2.Error** error);
void g_buffered_input_stream_set_buffer_size(BufferedInputStream* this_, size_t size);
BufferedOutputStream* /*new*/ g_buffered_output_stream_new(OutputStream* base_stream);
BufferedOutputStream* /*new*/ g_buffered_output_stream_new_sized(OutputStream* base_stream, size_t size);
int g_buffered_output_stream_get_auto_grow(BufferedOutputStream* this_);
size_t g_buffered_output_stream_get_buffer_size(BufferedOutputStream* this_);
void g_buffered_output_stream_set_auto_grow(BufferedOutputStream* this_, int auto_grow);
void g_buffered_output_stream_set_buffer_size(BufferedOutputStream* this_, size_t size);
Cancellable* /*new*/ g_cancellable_new();
Cancellable* g_cancellable_get_current();
void g_cancellable_cancel(Cancellable* this_);
c_ulong g_cancellable_connect(Cancellable* this_, GObject2.Callback callback, void* data, GLib2.DestroyNotify data_destroy_func);
void g_cancellable_disconnect(Cancellable* this_, c_ulong handler_id);
int g_cancellable_get_fd(Cancellable* this_);
int g_cancellable_is_cancelled(Cancellable* this_);
int g_cancellable_make_pollfd(Cancellable* this_, GLib2.PollFD* pollfd);
void g_cancellable_pop_current(Cancellable* this_);
void g_cancellable_push_current(Cancellable* this_);
void g_cancellable_release_fd(Cancellable* this_);
void g_cancellable_reset(Cancellable* this_);
int g_cancellable_set_error_if_cancelled(Cancellable* this_, GLib2.Error** error);
GLib2.Source* /*new*/ g_cancellable_source_new(Cancellable* this_);
CharsetConverter* /*new*/ g_charset_converter_new(char* to_charset, char* from_charset, GLib2.Error** error);
uint g_charset_converter_get_num_fallbacks(CharsetConverter* this_);
int g_charset_converter_get_use_fallback(CharsetConverter* this_);
void g_charset_converter_set_use_fallback(CharsetConverter* this_, int use_fallback);
ConverterResult g_converter_convert(Converter* this_, ubyte* inbuf, size_t inbuf_size, void* outbuf, size_t outbuf_size, ConverterFlags flags, /*out*/ size_t* bytes_read, /*out*/ size_t* bytes_written, GLib2.Error** error);
void g_converter_reset(Converter* this_);
ConverterInputStream* /*new*/ g_converter_input_stream_new(InputStream* base_stream, Converter* converter);
Converter* g_converter_input_stream_get_converter(ConverterInputStream* this_);
ConverterOutputStream* /*new*/ g_converter_output_stream_new(OutputStream* base_stream, Converter* converter);
Converter* g_converter_output_stream_get_converter(ConverterOutputStream* this_);
Credentials* /*new*/ g_credentials_new();
void* g_credentials_get_native(Credentials* this_, CredentialsType native_type);
uint g_credentials_get_unix_user(Credentials* this_, GLib2.Error** error);
int g_credentials_is_same_user(Credentials* this_, Credentials* other_credentials, GLib2.Error** error);
void g_credentials_set_native(Credentials* this_, CredentialsType native_type, void* native);
int g_credentials_set_unix_user(Credentials* this_, uint uid, GLib2.Error** error);
char* /*new*/ g_credentials_to_string(Credentials* this_);
DBusAnnotationInfo* /*new*/ g_dbus_annotation_info_ref(DBusAnnotationInfo* this_);
void g_dbus_annotation_info_unref(DBusAnnotationInfo* this_);
char* g_dbus_annotation_info_lookup(DBusAnnotationInfo** annotations, char* name);
DBusArgInfo* /*new*/ g_dbus_arg_info_ref(DBusArgInfo* this_);
void g_dbus_arg_info_unref(DBusArgInfo* this_);
DBusAuthObserver* /*new*/ g_dbus_auth_observer_new();
int g_dbus_auth_observer_authorize_authenticated_peer(DBusAuthObserver* this_, IOStream* stream, Credentials* credentials);
DBusConnection* /*new*/ g_dbus_connection_new_finish(AsyncResult* res, GLib2.Error** error);
DBusConnection* /*new*/ g_dbus_connection_new_for_address_finish(AsyncResult* res, GLib2.Error** error);
DBusConnection* /*new*/ g_dbus_connection_new_for_address_sync(char* address, DBusConnectionFlags flags, DBusAuthObserver* observer, Cancellable* cancellable, GLib2.Error** error);
DBusConnection* /*new*/ g_dbus_connection_new_sync(IOStream* stream, char* guid, DBusConnectionFlags flags, DBusAuthObserver* observer, Cancellable* cancellable, GLib2.Error** error);
void g_dbus_connection_new(IOStream* stream, char* guid, DBusConnectionFlags flags, DBusAuthObserver* observer, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
void g_dbus_connection_new_for_address(char* address, DBusConnectionFlags flags, DBusAuthObserver* observer, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
uint g_dbus_connection_add_filter(DBusConnection* this_, DBusMessageFilterFunction filter_function, void* user_data, GLib2.DestroyNotify user_data_free_func);
void g_dbus_connection_call(DBusConnection* this_, char* bus_name, char* object_path, char* interface_name, char* method_name, GLib2.Variant* parameters, GLib2.VariantType* reply_type, DBusCallFlags flags, int timeout_msec, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
GLib2.Variant* /*new*/ g_dbus_connection_call_finish(DBusConnection* this_, AsyncResult* res, GLib2.Error** error);
GLib2.Variant* /*new*/ g_dbus_connection_call_sync(DBusConnection* this_, char* bus_name, char* object_path, char* interface_name, char* method_name, GLib2.Variant* parameters, GLib2.VariantType* reply_type, DBusCallFlags flags, int timeout_msec, Cancellable* cancellable, GLib2.Error** error);
void g_dbus_connection_call_with_unix_fd_list(DBusConnection* this_, char* bus_name, char* object_path, char* interface_name, char* method_name, GLib2.Variant* parameters, GLib2.VariantType* reply_type, DBusCallFlags flags, int timeout_msec, UnixFDList* fd_list, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
GLib2.Variant* /*new*/ g_dbus_connection_call_with_unix_fd_list_finish(DBusConnection* this_, /*out*/ UnixFDList** out_fd_list, AsyncResult* res, GLib2.Error** error);
GLib2.Variant* /*new*/ g_dbus_connection_call_with_unix_fd_list_sync(DBusConnection* this_, char* bus_name, char* object_path, char* interface_name, char* method_name, GLib2.Variant* parameters, GLib2.VariantType* reply_type, DBusCallFlags flags, int timeout_msec, UnixFDList* fd_list, /*out*/ UnixFDList** out_fd_list, Cancellable* cancellable, GLib2.Error** error);
void g_dbus_connection_close(DBusConnection* this_, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_dbus_connection_close_finish(DBusConnection* this_, AsyncResult* res, GLib2.Error** error);
int g_dbus_connection_close_sync(DBusConnection* this_, Cancellable* cancellable, GLib2.Error** error);
int g_dbus_connection_emit_signal(DBusConnection* this_, char* destination_bus_name, char* object_path, char* interface_name, char* signal_name, GLib2.Variant* parameters, GLib2.Error** error);
void g_dbus_connection_flush(DBusConnection* this_, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_dbus_connection_flush_finish(DBusConnection* this_, AsyncResult* res, GLib2.Error** error);
int g_dbus_connection_flush_sync(DBusConnection* this_, Cancellable* cancellable, GLib2.Error** error);
DBusCapabilityFlags g_dbus_connection_get_capabilities(DBusConnection* this_);
int g_dbus_connection_get_exit_on_close(DBusConnection* this_);
char* g_dbus_connection_get_guid(DBusConnection* this_);
Credentials* g_dbus_connection_get_peer_credentials(DBusConnection* this_);
IOStream* g_dbus_connection_get_stream(DBusConnection* this_);
char* g_dbus_connection_get_unique_name(DBusConnection* this_);
int g_dbus_connection_is_closed(DBusConnection* this_);
uint g_dbus_connection_register_object(DBusConnection* this_, char* object_path, DBusInterfaceInfo* interface_info, DBusInterfaceVTable* vtable, void* user_data, GLib2.DestroyNotify user_data_free_func, GLib2.Error** error);
uint g_dbus_connection_register_subtree(DBusConnection* this_, char* object_path, DBusSubtreeVTable* vtable, DBusSubtreeFlags flags, void* user_data, GLib2.DestroyNotify user_data_free_func, GLib2.Error** error);
void g_dbus_connection_remove_filter(DBusConnection* this_, uint filter_id);
int g_dbus_connection_send_message(DBusConnection* this_, DBusMessage* message, DBusSendMessageFlags flags, /*out*/ uint* out_serial, GLib2.Error** error);
void g_dbus_connection_send_message_with_reply(DBusConnection* this_, DBusMessage* message, DBusSendMessageFlags flags, int timeout_msec, /*out*/ uint* out_serial, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
DBusMessage* /*new*/ g_dbus_connection_send_message_with_reply_finish(DBusConnection* this_, AsyncResult* res, GLib2.Error** error);
DBusMessage* /*new*/ g_dbus_connection_send_message_with_reply_sync(DBusConnection* this_, DBusMessage* message, DBusSendMessageFlags flags, int timeout_msec, /*out*/ uint* out_serial, Cancellable* cancellable, GLib2.Error** error);
void g_dbus_connection_set_exit_on_close(DBusConnection* this_, int exit_on_close);
uint g_dbus_connection_signal_subscribe(DBusConnection* this_, char* sender, char* interface_name, char* member, char* object_path, char* arg0, DBusSignalFlags flags, DBusSignalCallback callback, void* user_data, GLib2.DestroyNotify user_data_free_func=null);
void g_dbus_connection_signal_unsubscribe(DBusConnection* this_, uint subscription_id);
void g_dbus_connection_start_message_processing(DBusConnection* this_);
int g_dbus_connection_unregister_object(DBusConnection* this_, uint registration_id);
int g_dbus_connection_unregister_subtree(DBusConnection* this_, uint registration_id);
DBusInterfaceInfo* g_dbus_interface_get_info(DBusInterface* this_);
DBusObject* g_dbus_interface_get_object(DBusInterface* this_);
void g_dbus_interface_set_object(DBusInterface* this_, DBusObject* object);
void g_dbus_interface_info_cache_build(DBusInterfaceInfo* this_);
void g_dbus_interface_info_cache_release(DBusInterfaceInfo* this_);
void g_dbus_interface_info_generate_xml(DBusInterfaceInfo* this_, uint indent, /*out*/ GLib2.String* string_builder);
DBusMethodInfo* g_dbus_interface_info_lookup_method(DBusInterfaceInfo* this_, char* name);
DBusPropertyInfo* g_dbus_interface_info_lookup_property(DBusInterfaceInfo* this_, char* name);
DBusSignalInfo* g_dbus_interface_info_lookup_signal(DBusInterfaceInfo* this_, char* name);
DBusInterfaceInfo* /*new*/ g_dbus_interface_info_ref(DBusInterfaceInfo* this_);
void g_dbus_interface_info_unref(DBusInterfaceInfo* this_);
int g_dbus_interface_skeleton_export(DBusInterfaceSkeleton* this_, DBusConnection* connection, char* object_path, GLib2.Error** error);
void g_dbus_interface_skeleton_flush(DBusInterfaceSkeleton* this_);
DBusConnection* g_dbus_interface_skeleton_get_connection(DBusInterfaceSkeleton* this_);
DBusInterfaceSkeletonFlags g_dbus_interface_skeleton_get_flags(DBusInterfaceSkeleton* this_);
DBusInterfaceInfo* g_dbus_interface_skeleton_get_info(DBusInterfaceSkeleton* this_);
char* g_dbus_interface_skeleton_get_object_path(DBusInterfaceSkeleton* this_);
GLib2.Variant* /*new*/ g_dbus_interface_skeleton_get_properties(DBusInterfaceSkeleton* this_);
DBusInterfaceVTable* g_dbus_interface_skeleton_get_vtable(DBusInterfaceSkeleton* this_);
void g_dbus_interface_skeleton_set_flags(DBusInterfaceSkeleton* this_, DBusInterfaceSkeletonFlags flags);
void g_dbus_interface_skeleton_unexport(DBusInterfaceSkeleton* this_);
DBusMessage* /*new*/ g_dbus_message_new();
DBusMessage* /*new*/ g_dbus_message_new_from_blob(ubyte* blob, size_t blob_len, DBusCapabilityFlags capabilities, GLib2.Error** error);
DBusMessage* /*new*/ g_dbus_message_new_method_call(char* name, char* path, char* interface_, char* method);
DBusMessage* /*new*/ g_dbus_message_new_signal(char* path, char* interface_, char* signal);
ssize_t g_dbus_message_bytes_needed(ubyte* blob, size_t blob_len, GLib2.Error** error);
DBusMessage* /*new*/ g_dbus_message_copy(DBusMessage* this_, GLib2.Error** error);
char* g_dbus_message_get_arg0(DBusMessage* this_);
GLib2.Variant* /*new*/ g_dbus_message_get_body(DBusMessage* this_);
DBusMessageByteOrder g_dbus_message_get_byte_order(DBusMessage* this_);
char* g_dbus_message_get_destination(DBusMessage* this_);
char* g_dbus_message_get_error_name(DBusMessage* this_);
DBusMessageFlags g_dbus_message_get_flags(DBusMessage* this_);
GLib2.Variant* /*new*/ g_dbus_message_get_header(DBusMessage* this_, DBusMessageHeaderField header_field);
ubyte* g_dbus_message_get_header_fields(DBusMessage* this_);
char* g_dbus_message_get_interface(DBusMessage* this_);
int g_dbus_message_get_locked(DBusMessage* this_);
char* g_dbus_message_get_member(DBusMessage* this_);
DBusMessageType g_dbus_message_get_message_type(DBusMessage* this_);
uint g_dbus_message_get_num_unix_fds(DBusMessage* this_);
char* g_dbus_message_get_path(DBusMessage* this_);
uint g_dbus_message_get_reply_serial(DBusMessage* this_);
char* g_dbus_message_get_sender(DBusMessage* this_);
uint g_dbus_message_get_serial(DBusMessage* this_);
char* g_dbus_message_get_signature(DBusMessage* this_);
UnixFDList* g_dbus_message_get_unix_fd_list(DBusMessage* this_);
void g_dbus_message_lock(DBusMessage* this_);
DBusMessage* /*new*/ g_dbus_message_new_method_error(DBusMessage* this_, char* error_name, char* error_message_format, ...);
DBusMessage* /*new*/ g_dbus_message_new_method_error_literal(DBusMessage* this_, char* error_name, char* error_message);
DBusMessage* /*new*/ g_dbus_message_new_method_error_valist(DBusMessage* this_, char* error_name, char* error_message_format, va_list var_args);
DBusMessage* /*new*/ g_dbus_message_new_method_reply(DBusMessage* this_);
char* /*new*/ g_dbus_message_print(DBusMessage* this_, uint indent);
void g_dbus_message_set_body(DBusMessage* this_, GLib2.Variant* body_);
void g_dbus_message_set_byte_order(DBusMessage* this_, DBusMessageByteOrder byte_order);
void g_dbus_message_set_destination(DBusMessage* this_, char* value);
void g_dbus_message_set_error_name(DBusMessage* this_, char* value);
void g_dbus_message_set_flags(DBusMessage* this_, DBusMessageFlags flags);
void g_dbus_message_set_header(DBusMessage* this_, DBusMessageHeaderField header_field, GLib2.Variant* value);
void g_dbus_message_set_interface(DBusMessage* this_, char* value);
void g_dbus_message_set_member(DBusMessage* this_, char* value);
void g_dbus_message_set_message_type(DBusMessage* this_, DBusMessageType type);
void g_dbus_message_set_num_unix_fds(DBusMessage* this_, uint value);
void g_dbus_message_set_path(DBusMessage* this_, char* value);
void g_dbus_message_set_reply_serial(DBusMessage* this_, uint value);
void g_dbus_message_set_sender(DBusMessage* this_, char* value);
void g_dbus_message_set_serial(DBusMessage* this_, uint serial);
void g_dbus_message_set_signature(DBusMessage* this_, char* value);
void g_dbus_message_set_unix_fd_list(DBusMessage* this_, UnixFDList* fd_list=null);
ubyte* g_dbus_message_to_blob(DBusMessage* this_, size_t* out_size, DBusCapabilityFlags capabilities, GLib2.Error** error);
int g_dbus_message_to_gerror(DBusMessage* this_, GLib2.Error** error);
DBusMethodInfo* /*new*/ g_dbus_method_info_ref(DBusMethodInfo* this_);
void g_dbus_method_info_unref(DBusMethodInfo* this_);
DBusConnection* g_dbus_method_invocation_get_connection(DBusMethodInvocation* this_);
char* g_dbus_method_invocation_get_interface_name(DBusMethodInvocation* this_);
DBusMessage* g_dbus_method_invocation_get_message(DBusMethodInvocation* this_);
DBusMethodInfo* g_dbus_method_invocation_get_method_info(DBusMethodInvocation* this_);
char* g_dbus_method_invocation_get_method_name(DBusMethodInvocation* this_);
char* g_dbus_method_invocation_get_object_path(DBusMethodInvocation* this_);
GLib2.Variant* g_dbus_method_invocation_get_parameters(DBusMethodInvocation* this_);
char* g_dbus_method_invocation_get_sender(DBusMethodInvocation* this_);
void* g_dbus_method_invocation_get_user_data(DBusMethodInvocation* this_);
void g_dbus_method_invocation_return_dbus_error(DBusMethodInvocation* this_, char* error_name, char* error_message);
void g_dbus_method_invocation_return_error(DBusMethodInvocation* this_, GLib2.Quark domain, int code, char* format, ...);
void g_dbus_method_invocation_return_error_literal(DBusMethodInvocation* this_, GLib2.Quark domain, int code, char* message);
void g_dbus_method_invocation_return_error_valist(DBusMethodInvocation* this_, GLib2.Quark domain, int code, char* format, va_list var_args);
void g_dbus_method_invocation_return_gerror(DBusMethodInvocation* this_, GLib2.Error* error);
void g_dbus_method_invocation_return_value(DBusMethodInvocation* this_, GLib2.Variant* parameters=null);
void g_dbus_method_invocation_return_value_with_unix_fd_list(DBusMethodInvocation* this_, GLib2.Variant* parameters=null, UnixFDList* fd_list=null);
void g_dbus_method_invocation_take_error(DBusMethodInvocation* this_, GLib2.Error* error);
DBusNodeInfo* /*new*/ g_dbus_node_info_new_for_xml(char* xml_data, GLib2.Error** error);
void g_dbus_node_info_generate_xml(DBusNodeInfo* this_, uint indent, /*out*/ GLib2.String* string_builder);
DBusInterfaceInfo* g_dbus_node_info_lookup_interface(DBusNodeInfo* this_, char* name);
DBusNodeInfo* /*new*/ g_dbus_node_info_ref(DBusNodeInfo* this_);
void g_dbus_node_info_unref(DBusNodeInfo* this_);
DBusInterface* /*new*/ g_dbus_object_get_interface(DBusObject* this_, char* interface_name);
GLib2.List* /*new*/ g_dbus_object_get_interfaces(DBusObject* this_);
char* g_dbus_object_get_object_path(DBusObject* this_);
DBusInterface* /*new*/ g_dbus_object_manager_get_interface(DBusObjectManager* this_, char* object_path, char* interface_name);
DBusObject* /*new*/ g_dbus_object_manager_get_object(DBusObjectManager* this_, char* object_path);
char* g_dbus_object_manager_get_object_path(DBusObjectManager* this_);
GLib2.List* /*new*/ g_dbus_object_manager_get_objects(DBusObjectManager* this_);
DBusObjectManagerClient* /*new*/ g_dbus_object_manager_client_new_finish(AsyncResult* res, GLib2.Error** error);
DBusObjectManagerClient* /*new*/ g_dbus_object_manager_client_new_for_bus_finish(AsyncResult* res, GLib2.Error** error);
DBusObjectManagerClient* /*new*/ g_dbus_object_manager_client_new_for_bus_sync(BusType bus_type, DBusObjectManagerClientFlags flags, char* name, char* object_path, DBusProxyTypeFunc get_proxy_type_func, void* get_proxy_type_user_data, GLib2.DestroyNotify get_proxy_type_destroy_notify, Cancellable* cancellable, GLib2.Error** error);
DBusObjectManagerClient* /*new*/ g_dbus_object_manager_client_new_sync(DBusConnection* connection, DBusObjectManagerClientFlags flags, char* name, char* object_path, DBusProxyTypeFunc get_proxy_type_func, void* get_proxy_type_user_data, GLib2.DestroyNotify get_proxy_type_destroy_notify, Cancellable* cancellable, GLib2.Error** error);
void g_dbus_object_manager_client_new(DBusConnection* connection, DBusObjectManagerClientFlags flags, char* name, char* object_path, DBusProxyTypeFunc get_proxy_type_func, void* get_proxy_type_user_data, GLib2.DestroyNotify get_proxy_type_destroy_notify, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
void g_dbus_object_manager_client_new_for_bus(BusType bus_type, DBusObjectManagerClientFlags flags, char* name, char* object_path, DBusProxyTypeFunc get_proxy_type_func, void* get_proxy_type_user_data, GLib2.DestroyNotify get_proxy_type_destroy_notify, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
DBusConnection* g_dbus_object_manager_client_get_connection(DBusObjectManagerClient* this_);
DBusObjectManagerClientFlags g_dbus_object_manager_client_get_flags(DBusObjectManagerClient* this_);
char* g_dbus_object_manager_client_get_name(DBusObjectManagerClient* this_);
char* /*new*/ g_dbus_object_manager_client_get_name_owner(DBusObjectManagerClient* this_);
DBusObjectManagerServer* /*new*/ g_dbus_object_manager_server_new(char* object_path);
void g_dbus_object_manager_server_export(DBusObjectManagerServer* this_, DBusObjectSkeleton* object);
void g_dbus_object_manager_server_export_uniquely(DBusObjectManagerServer* this_, DBusObjectSkeleton* object);
DBusConnection* /*new*/ g_dbus_object_manager_server_get_connection(DBusObjectManagerServer* this_);
void g_dbus_object_manager_server_set_connection(DBusObjectManagerServer* this_, DBusConnection* connection=null);
int g_dbus_object_manager_server_unexport(DBusObjectManagerServer* this_, char* object_path);
DBusObjectProxy* /*new*/ g_dbus_object_proxy_new(DBusConnection* connection, char* object_path);
DBusConnection* g_dbus_object_proxy_get_connection(DBusObjectProxy* this_);
DBusObjectSkeleton* /*new*/ g_dbus_object_skeleton_new(char* object_path);
void g_dbus_object_skeleton_add_interface(DBusObjectSkeleton* this_, DBusInterfaceSkeleton* interface_);
void g_dbus_object_skeleton_flush(DBusObjectSkeleton* this_);
void g_dbus_object_skeleton_remove_interface(DBusObjectSkeleton* this_, DBusInterfaceSkeleton* interface_);
void g_dbus_object_skeleton_remove_interface_by_name(DBusObjectSkeleton* this_, char* interface_name);
void g_dbus_object_skeleton_set_object_path(DBusObjectSkeleton* this_, char* object_path);
DBusPropertyInfo* /*new*/ g_dbus_property_info_ref(DBusPropertyInfo* this_);
void g_dbus_property_info_unref(DBusPropertyInfo* this_);
DBusProxy* /*new*/ g_dbus_proxy_new_finish(AsyncResult* res, GLib2.Error** error);
DBusProxy* /*new*/ g_dbus_proxy_new_for_bus_finish(AsyncResult* res, GLib2.Error** error);
DBusProxy* /*new*/ g_dbus_proxy_new_for_bus_sync(BusType bus_type, DBusProxyFlags flags, DBusInterfaceInfo* info, char* name, char* object_path, char* interface_name, Cancellable* cancellable, GLib2.Error** error);
DBusProxy* /*new*/ g_dbus_proxy_new_sync(DBusConnection* connection, DBusProxyFlags flags, DBusInterfaceInfo* info, char* name, char* object_path, char* interface_name, Cancellable* cancellable, GLib2.Error** error);
void g_dbus_proxy_new(DBusConnection* connection, DBusProxyFlags flags, DBusInterfaceInfo* info, char* name, char* object_path, char* interface_name, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
void g_dbus_proxy_new_for_bus(BusType bus_type, DBusProxyFlags flags, DBusInterfaceInfo* info, char* name, char* object_path, char* interface_name, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
void g_dbus_proxy_call(DBusProxy* this_, char* method_name, GLib2.Variant* parameters, DBusCallFlags flags, int timeout_msec, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
GLib2.Variant* /*new*/ g_dbus_proxy_call_finish(DBusProxy* this_, AsyncResult* res, GLib2.Error** error);
GLib2.Variant* /*new*/ g_dbus_proxy_call_sync(DBusProxy* this_, char* method_name, GLib2.Variant* parameters, DBusCallFlags flags, int timeout_msec, Cancellable* cancellable, GLib2.Error** error);
void g_dbus_proxy_call_with_unix_fd_list(DBusProxy* this_, char* method_name, GLib2.Variant* parameters, DBusCallFlags flags, int timeout_msec, UnixFDList* fd_list, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
GLib2.Variant* /*new*/ g_dbus_proxy_call_with_unix_fd_list_finish(DBusProxy* this_, /*out*/ UnixFDList** out_fd_list, AsyncResult* res, GLib2.Error** error);
GLib2.Variant* /*new*/ g_dbus_proxy_call_with_unix_fd_list_sync(DBusProxy* this_, char* method_name, GLib2.Variant* parameters, DBusCallFlags flags, int timeout_msec, UnixFDList* fd_list, /*out*/ UnixFDList** out_fd_list, Cancellable* cancellable, GLib2.Error** error);
GLib2.Variant* /*new*/ g_dbus_proxy_get_cached_property(DBusProxy* this_, char* property_name);
char** /*new*/ g_dbus_proxy_get_cached_property_names(DBusProxy* this_);
DBusConnection* g_dbus_proxy_get_connection(DBusProxy* this_);
int g_dbus_proxy_get_default_timeout(DBusProxy* this_);
DBusProxyFlags g_dbus_proxy_get_flags(DBusProxy* this_);
DBusInterfaceInfo* /*new*/ g_dbus_proxy_get_interface_info(DBusProxy* this_);
char* g_dbus_proxy_get_interface_name(DBusProxy* this_);
char* g_dbus_proxy_get_name(DBusProxy* this_);
char* /*new*/ g_dbus_proxy_get_name_owner(DBusProxy* this_);
char* g_dbus_proxy_get_object_path(DBusProxy* this_);
void g_dbus_proxy_set_cached_property(DBusProxy* this_, char* property_name, GLib2.Variant* value=null);
void g_dbus_proxy_set_default_timeout(DBusProxy* this_, int timeout_msec);
void g_dbus_proxy_set_interface_info(DBusProxy* this_, DBusInterfaceInfo* info=null);
DBusServer* /*new*/ g_dbus_server_new_sync(char* address, DBusServerFlags flags, char* guid, DBusAuthObserver* observer, Cancellable* cancellable, GLib2.Error** error);
char* g_dbus_server_get_client_address(DBusServer* this_);
DBusServerFlags g_dbus_server_get_flags(DBusServer* this_);
char* g_dbus_server_get_guid(DBusServer* this_);
int g_dbus_server_is_active(DBusServer* this_);
void g_dbus_server_start(DBusServer* this_);
void g_dbus_server_stop(DBusServer* this_);
DBusSignalInfo* /*new*/ g_dbus_signal_info_ref(DBusSignalInfo* this_);
void g_dbus_signal_info_unref(DBusSignalInfo* this_);
DataInputStream* /*new*/ g_data_input_stream_new(InputStream* base_stream);
DataStreamByteOrder g_data_input_stream_get_byte_order(DataInputStream* this_);
DataStreamNewlineType g_data_input_stream_get_newline_type(DataInputStream* this_);
ubyte g_data_input_stream_read_byte(DataInputStream* this_, Cancellable* cancellable, GLib2.Error** error);
short g_data_input_stream_read_int16(DataInputStream* this_, Cancellable* cancellable, GLib2.Error** error);
int g_data_input_stream_read_int32(DataInputStream* this_, Cancellable* cancellable, GLib2.Error** error);
long g_data_input_stream_read_int64(DataInputStream* this_, Cancellable* cancellable, GLib2.Error** error);
ubyte* /*new*/ g_data_input_stream_read_line(DataInputStream* this_, /*out*/ size_t* length, Cancellable* cancellable, GLib2.Error** error);
void g_data_input_stream_read_line_async(DataInputStream* this_, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
ubyte* /*new*/ g_data_input_stream_read_line_finish(DataInputStream* this_, AsyncResult* result, /*out*/ size_t* length, GLib2.Error** error);
char* /*new*/ g_data_input_stream_read_line_finish_utf8(DataInputStream* this_, AsyncResult* result, /*out*/ size_t* length, GLib2.Error** error);
char* /*new*/ g_data_input_stream_read_line_utf8(DataInputStream* this_, /*out*/ size_t* length, Cancellable* cancellable, GLib2.Error** error);
ushort g_data_input_stream_read_uint16(DataInputStream* this_, Cancellable* cancellable, GLib2.Error** error);
uint g_data_input_stream_read_uint32(DataInputStream* this_, Cancellable* cancellable, GLib2.Error** error);
ulong g_data_input_stream_read_uint64(DataInputStream* this_, Cancellable* cancellable, GLib2.Error** error);
char* /*new*/ g_data_input_stream_read_until(DataInputStream* this_, char* stop_chars, /*out*/ size_t* length, Cancellable* cancellable, GLib2.Error** error);
void g_data_input_stream_read_until_async(DataInputStream* this_, char* stop_chars, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
char* /*new*/ g_data_input_stream_read_until_finish(DataInputStream* this_, AsyncResult* result, /*out*/ size_t* length, GLib2.Error** error);
char* /*new*/ g_data_input_stream_read_upto(DataInputStream* this_, char* stop_chars, ssize_t stop_chars_len, /*out*/ size_t* length, Cancellable* cancellable, GLib2.Error** error);
void g_data_input_stream_read_upto_async(DataInputStream* this_, char* stop_chars, ssize_t stop_chars_len, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
char* /*new*/ g_data_input_stream_read_upto_finish(DataInputStream* this_, AsyncResult* result, /*out*/ size_t* length, GLib2.Error** error);
void g_data_input_stream_set_byte_order(DataInputStream* this_, DataStreamByteOrder order);
void g_data_input_stream_set_newline_type(DataInputStream* this_, DataStreamNewlineType type);
DataOutputStream* /*new*/ g_data_output_stream_new(OutputStream* base_stream);
DataStreamByteOrder g_data_output_stream_get_byte_order(DataOutputStream* this_);
int g_data_output_stream_put_byte(DataOutputStream* this_, ubyte data, Cancellable* cancellable, GLib2.Error** error);
int g_data_output_stream_put_int16(DataOutputStream* this_, short data, Cancellable* cancellable, GLib2.Error** error);
int g_data_output_stream_put_int32(DataOutputStream* this_, int data, Cancellable* cancellable, GLib2.Error** error);
int g_data_output_stream_put_int64(DataOutputStream* this_, long data, Cancellable* cancellable, GLib2.Error** error);
int g_data_output_stream_put_string(DataOutputStream* this_, char* str, Cancellable* cancellable, GLib2.Error** error);
int g_data_output_stream_put_uint16(DataOutputStream* this_, ushort data, Cancellable* cancellable, GLib2.Error** error);
int g_data_output_stream_put_uint32(DataOutputStream* this_, uint data, Cancellable* cancellable, GLib2.Error** error);
int g_data_output_stream_put_uint64(DataOutputStream* this_, ulong data, Cancellable* cancellable, GLib2.Error** error);
void g_data_output_stream_set_byte_order(DataOutputStream* this_, DataStreamByteOrder order);
DesktopAppInfo* /*new*/ g_desktop_app_info_new(char* desktop_id);
DesktopAppInfo* /*new*/ g_desktop_app_info_new_from_filename(char* filename);
DesktopAppInfo* /*new*/ g_desktop_app_info_new_from_keyfile(GLib2.KeyFile* key_file);
void g_desktop_app_info_set_desktop_env(char* desktop_env);
char* g_desktop_app_info_get_categories(DesktopAppInfo* this_);
char* g_desktop_app_info_get_filename(DesktopAppInfo* this_);
char* g_desktop_app_info_get_generic_name(DesktopAppInfo* this_);
int g_desktop_app_info_get_is_hidden(DesktopAppInfo* this_);
int g_desktop_app_info_get_nodisplay(DesktopAppInfo* this_);
int g_desktop_app_info_get_show_in(DesktopAppInfo* this_, char* desktop_env);
int g_desktop_app_info_launch_uris_as_manager(DesktopAppInfo* this_, GLib2.List* uris, AppLaunchContext* launch_context, GLib2.SpawnFlags spawn_flags, GLib2.SpawnChildSetupFunc user_setup, void* user_setup_data, DesktopAppLaunchCallback pid_callback, void* pid_callback_data, GLib2.Error** error);
AppInfo* /*new*/ g_desktop_app_info_lookup_get_default_for_uri_scheme(DesktopAppInfoLookup* this_, char* uri_scheme);
int g_drive_can_eject(Drive* this_);
int g_drive_can_poll_for_media(Drive* this_);
int g_drive_can_start(Drive* this_);
int g_drive_can_start_degraded(Drive* this_);
int g_drive_can_stop(Drive* this_);
void g_drive_eject(Drive* this_, MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_drive_eject_finish(Drive* this_, AsyncResult* result, GLib2.Error** error);
void g_drive_eject_with_operation(Drive* this_, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_drive_eject_with_operation_finish(Drive* this_, AsyncResult* result, GLib2.Error** error);
char** /*new*/ g_drive_enumerate_identifiers(Drive* this_);
Icon* /*new*/ g_drive_get_icon(Drive* this_);
char* /*new*/ g_drive_get_identifier(Drive* this_, char* kind);
char* /*new*/ g_drive_get_name(Drive* this_);
DriveStartStopType g_drive_get_start_stop_type(Drive* this_);
GLib2.List* /*new*/ g_drive_get_volumes(Drive* this_);
int g_drive_has_media(Drive* this_);
int g_drive_has_volumes(Drive* this_);
int g_drive_is_media_check_automatic(Drive* this_);
int g_drive_is_media_removable(Drive* this_);
void g_drive_poll_for_media(Drive* this_, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_drive_poll_for_media_finish(Drive* this_, AsyncResult* result, GLib2.Error** error);
void g_drive_start(Drive* this_, DriveStartFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_drive_start_finish(Drive* this_, AsyncResult* result, GLib2.Error** error);
void g_drive_stop(Drive* this_, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_drive_stop_finish(Drive* this_, AsyncResult* result, GLib2.Error** error);
Emblem* /*new*/ g_emblem_new(Icon* icon);
Emblem* /*new*/ g_emblem_new_with_origin(Icon* icon, EmblemOrigin origin);
Icon* g_emblem_get_icon(Emblem* this_);
EmblemOrigin g_emblem_get_origin(Emblem* this_);
Icon* /*new*/ g_emblemed_icon_new(Icon* icon, Emblem* emblem=null);
void g_emblemed_icon_add_emblem(EmblemedIcon* this_, Emblem* emblem);
void g_emblemed_icon_clear_emblems(EmblemedIcon* this_);
GLib2.List* g_emblemed_icon_get_emblems(EmblemedIcon* this_);
Icon* g_emblemed_icon_get_icon(EmblemedIcon* this_);
uint g_file_hash(const(void)* file);
File* /*new*/ g_file_new_for_commandline_arg(char* arg);
File* /*new*/ g_file_new_for_path(char* path);
File* /*new*/ g_file_new_for_uri(char* uri);
File* /*new*/ g_file_parse_name(char* parse_name);
FileOutputStream* /*new*/ g_file_append_to(File* this_, FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_file_append_to_async(File* this_, FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
FileOutputStream* /*new*/ g_file_append_to_finish(File* this_, AsyncResult* res, GLib2.Error** error);
int g_file_copy(File* this_, File* destination, FileCopyFlags flags, Cancellable* cancellable, FileProgressCallback progress_callback, void* progress_callback_data, GLib2.Error** error);
void g_file_copy_async(File* this_, File* destination, FileCopyFlags flags, int io_priority, Cancellable* cancellable, FileProgressCallback progress_callback, void* progress_callback_data, AsyncReadyCallback callback, void* user_data);
int g_file_copy_attributes(File* this_, File* destination, FileCopyFlags flags, Cancellable* cancellable, GLib2.Error** error);
int g_file_copy_finish(File* this_, AsyncResult* res, GLib2.Error** error);
FileOutputStream* /*new*/ g_file_create(File* this_, FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_file_create_async(File* this_, FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
FileOutputStream* /*new*/ g_file_create_finish(File* this_, AsyncResult* res, GLib2.Error** error);
FileIOStream* /*new*/ g_file_create_readwrite(File* this_, FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_file_create_readwrite_async(File* this_, FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
FileIOStream* /*new*/ g_file_create_readwrite_finish(File* this_, AsyncResult* res, GLib2.Error** error);
int g_file_delete(File* this_, Cancellable* cancellable, GLib2.Error** error);
File* /*new*/ g_file_dup(File* this_);
void g_file_eject_mountable(File* this_, MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_file_eject_mountable_finish(File* this_, AsyncResult* result, GLib2.Error** error);
void g_file_eject_mountable_with_operation(File* this_, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_file_eject_mountable_with_operation_finish(File* this_, AsyncResult* result, GLib2.Error** error);
FileEnumerator* /*new*/ g_file_enumerate_children(File* this_, char* attributes, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_file_enumerate_children_async(File* this_, char* attributes, FileQueryInfoFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
FileEnumerator* /*new*/ g_file_enumerate_children_finish(File* this_, AsyncResult* res, GLib2.Error** error);
int g_file_equal(File* this_, File* file2);
Mount* /*new*/ g_file_find_enclosing_mount(File* this_, Cancellable* cancellable, GLib2.Error** error);
void g_file_find_enclosing_mount_async(File* this_, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
Mount* /*new*/ g_file_find_enclosing_mount_finish(File* this_, AsyncResult* res, GLib2.Error** error);
char* /*new*/ g_file_get_basename(File* this_);
File* /*new*/ g_file_get_child(File* this_, char* name);
File* /*new*/ g_file_get_child_for_display_name(File* this_, char* display_name, GLib2.Error** error);
File* /*new*/ g_file_get_parent(File* this_);
char* /*new*/ g_file_get_parse_name(File* this_);
char* /*new*/ g_file_get_path(File* this_);
char* /*new*/ g_file_get_relative_path(File* this_, File* descendant);
char* /*new*/ g_file_get_uri(File* this_);
char* /*new*/ g_file_get_uri_scheme(File* this_);
int g_file_has_parent(File* this_, File* parent);
int g_file_has_prefix(File* this_, File* prefix);
int g_file_has_uri_scheme(File* this_, char* uri_scheme);
Icon* /*new*/ g_file_icon_new(File* this_);
int g_file_is_native(File* this_);
int g_file_load_contents(File* this_, Cancellable* cancellable, /*out*/ ubyte** contents, /*out*/ size_t* length, /*out*/ char** etag_out, GLib2.Error** error);
void g_file_load_contents_async(File* this_, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_file_load_contents_finish(File* this_, AsyncResult* res, /*out*/ ubyte** contents, /*out*/ size_t* length, /*out*/ char** etag_out, GLib2.Error** error);
void g_file_load_partial_contents_async(File* this_, Cancellable* cancellable, FileReadMoreCallback read_more_callback, AsyncReadyCallback callback, void* user_data);
int g_file_load_partial_contents_finish(File* this_, AsyncResult* res, /*out*/ ubyte** contents, /*out*/ size_t* length, /*out*/ char** etag_out, GLib2.Error** error);
int g_file_make_directory(File* this_, Cancellable* cancellable, GLib2.Error** error);
int g_file_make_directory_with_parents(File* this_, Cancellable* cancellable, GLib2.Error** error);
int g_file_make_symbolic_link(File* this_, char* symlink_value, Cancellable* cancellable, GLib2.Error** error);
FileMonitor* /*new*/ g_file_monitor(File* this_, FileMonitorFlags flags, Cancellable* cancellable, GLib2.Error** error);
FileMonitor* /*new*/ g_file_monitor_directory(File* this_, FileMonitorFlags flags, Cancellable* cancellable, GLib2.Error** error);
FileMonitor* /*new*/ g_file_monitor_file(File* this_, FileMonitorFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_file_mount_enclosing_volume(File* this_, MountMountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_file_mount_enclosing_volume_finish(File* this_, AsyncResult* result, GLib2.Error** error);
void g_file_mount_mountable(File* this_, MountMountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
File* /*new*/ g_file_mount_mountable_finish(File* this_, AsyncResult* result, GLib2.Error** error);
int g_file_move(File* this_, File* destination, FileCopyFlags flags, Cancellable* cancellable, FileProgressCallback progress_callback, void* progress_callback_data, GLib2.Error** error);
FileIOStream* /*new*/ g_file_open_readwrite(File* this_, Cancellable* cancellable, GLib2.Error** error);
void g_file_open_readwrite_async(File* this_, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
FileIOStream* /*new*/ g_file_open_readwrite_finish(File* this_, AsyncResult* res, GLib2.Error** error);
void g_file_poll_mountable(File* this_, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_file_poll_mountable_finish(File* this_, AsyncResult* result, GLib2.Error** error);
AppInfo* /*new*/ g_file_query_default_handler(File* this_, Cancellable* cancellable, GLib2.Error** error);
int g_file_query_exists(File* this_, Cancellable* cancellable=null);
FileType g_file_query_file_type(File* this_, FileQueryInfoFlags flags, Cancellable* cancellable=null);
FileInfo* /*new*/ g_file_query_filesystem_info(File* this_, char* attributes, Cancellable* cancellable, GLib2.Error** error);
void g_file_query_filesystem_info_async(File* this_, char* attributes, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
FileInfo* /*new*/ g_file_query_filesystem_info_finish(File* this_, AsyncResult* res, GLib2.Error** error);
FileInfo* /*new*/ g_file_query_info(File* this_, char* attributes, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_file_query_info_async(File* this_, char* attributes, FileQueryInfoFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
FileInfo* /*new*/ g_file_query_info_finish(File* this_, AsyncResult* res, GLib2.Error** error);
FileAttributeInfoList* /*new*/ g_file_query_settable_attributes(File* this_, Cancellable* cancellable, GLib2.Error** error);
FileAttributeInfoList* /*new*/ g_file_query_writable_namespaces(File* this_, Cancellable* cancellable, GLib2.Error** error);
FileInputStream* /*new*/ g_file_read(File* this_, Cancellable* cancellable, GLib2.Error** error);
void g_file_read_async(File* this_, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
FileInputStream* /*new*/ g_file_read_finish(File* this_, AsyncResult* res, GLib2.Error** error);
FileOutputStream* /*new*/ g_file_replace(File* this_, char* etag, int make_backup, FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_file_replace_async(File* this_, char* etag, int make_backup, FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_file_replace_contents(File* this_, ubyte* contents, size_t length, char* etag, int make_backup, FileCreateFlags flags, /*out*/ char** new_etag, Cancellable* cancellable, GLib2.Error** error);
void g_file_replace_contents_async(File* this_, ubyte* contents, size_t length, char* etag, int make_backup, FileCreateFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_file_replace_contents_finish(File* this_, AsyncResult* res, /*out*/ char** new_etag, GLib2.Error** error);
FileOutputStream* /*new*/ g_file_replace_finish(File* this_, AsyncResult* res, GLib2.Error** error);
FileIOStream* /*new*/ g_file_replace_readwrite(File* this_, char* etag, int make_backup, FileCreateFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_file_replace_readwrite_async(File* this_, char* etag, int make_backup, FileCreateFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
FileIOStream* /*new*/ g_file_replace_readwrite_finish(File* this_, AsyncResult* res, GLib2.Error** error);
File* /*new*/ g_file_resolve_relative_path(File* this_, char* relative_path);
int g_file_set_attribute(File* this_, char* attribute, FileAttributeType type, void* value_p, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error);
int g_file_set_attribute_byte_string(File* this_, char* attribute, char* value, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error);
int g_file_set_attribute_int32(File* this_, char* attribute, int value, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error);
int g_file_set_attribute_int64(File* this_, char* attribute, long value, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error);
int g_file_set_attribute_string(File* this_, char* attribute, char* value, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error);
int g_file_set_attribute_uint32(File* this_, char* attribute, uint value, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error);
int g_file_set_attribute_uint64(File* this_, char* attribute, ulong value, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_file_set_attributes_async(File* this_, FileInfo* info, FileQueryInfoFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_file_set_attributes_finish(File* this_, AsyncResult* result, /*out*/ FileInfo** info, GLib2.Error** error);
int g_file_set_attributes_from_info(File* this_, FileInfo* info, FileQueryInfoFlags flags, Cancellable* cancellable, GLib2.Error** error);
File* /*new*/ g_file_set_display_name(File* this_, char* display_name, Cancellable* cancellable, GLib2.Error** error);
void g_file_set_display_name_async(File* this_, char* display_name, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
File* /*new*/ g_file_set_display_name_finish(File* this_, AsyncResult* res, GLib2.Error** error);
void g_file_start_mountable(File* this_, DriveStartFlags flags, MountOperation* start_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_file_start_mountable_finish(File* this_, AsyncResult* result, GLib2.Error** error);
void g_file_stop_mountable(File* this_, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_file_stop_mountable_finish(File* this_, AsyncResult* result, GLib2.Error** error);
int g_file_supports_thread_contexts(File* this_);
int g_file_trash(File* this_, Cancellable* cancellable, GLib2.Error** error);
void g_file_unmount_mountable(File* this_, MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_file_unmount_mountable_finish(File* this_, AsyncResult* result, GLib2.Error** error);
void g_file_unmount_mountable_with_operation(File* this_, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_file_unmount_mountable_with_operation_finish(File* this_, AsyncResult* result, GLib2.Error** error);
FileAttributeInfoList* /*new*/ g_file_attribute_info_list_new();
void g_file_attribute_info_list_add(FileAttributeInfoList* this_, char* name, FileAttributeType type, FileAttributeInfoFlags flags);
FileAttributeInfoList* /*new*/ g_file_attribute_info_list_dup(FileAttributeInfoList* this_);
FileAttributeInfo* g_file_attribute_info_list_lookup(FileAttributeInfoList* this_, char* name);
FileAttributeInfoList* /*new*/ g_file_attribute_info_list_ref(FileAttributeInfoList* this_);
void g_file_attribute_info_list_unref(FileAttributeInfoList* this_);
FileAttributeMatcher* /*new*/ g_file_attribute_matcher_new(char* attributes);
int g_file_attribute_matcher_enumerate_namespace(FileAttributeMatcher* this_, char* ns);
char* g_file_attribute_matcher_enumerate_next(FileAttributeMatcher* this_);
int g_file_attribute_matcher_matches(FileAttributeMatcher* this_, char* attribute);
int g_file_attribute_matcher_matches_only(FileAttributeMatcher* this_, char* attribute);
FileAttributeMatcher* /*new*/ g_file_attribute_matcher_ref(FileAttributeMatcher* this_);
void g_file_attribute_matcher_unref(FileAttributeMatcher* this_);
int g_file_descriptor_based_get_fd(FileDescriptorBased* this_);
int g_file_enumerator_close(FileEnumerator* this_, Cancellable* cancellable, GLib2.Error** error);
void g_file_enumerator_close_async(FileEnumerator* this_, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_file_enumerator_close_finish(FileEnumerator* this_, AsyncResult* result, GLib2.Error** error);
File* g_file_enumerator_get_container(FileEnumerator* this_);
int g_file_enumerator_has_pending(FileEnumerator* this_);
int g_file_enumerator_is_closed(FileEnumerator* this_);
FileInfo* /*new*/ g_file_enumerator_next_file(FileEnumerator* this_, Cancellable* cancellable, GLib2.Error** error);
void g_file_enumerator_next_files_async(FileEnumerator* this_, int num_files, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
GLib2.List* /*new*/ g_file_enumerator_next_files_finish(FileEnumerator* this_, AsyncResult* result, GLib2.Error** error);
void g_file_enumerator_set_pending(FileEnumerator* this_, int pending);
char* /*new*/ g_file_io_stream_get_etag(FileIOStream* this_);
FileInfo* /*new*/ g_file_io_stream_query_info(FileIOStream* this_, char* attributes, Cancellable* cancellable, GLib2.Error** error);
void g_file_io_stream_query_info_async(FileIOStream* this_, char* attributes, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
FileInfo* /*new*/ g_file_io_stream_query_info_finish(FileIOStream* this_, AsyncResult* result, GLib2.Error** error);
File* g_file_icon_get_file(FileIcon* this_);
FileInfo* /*new*/ g_file_info_new();
void g_file_info_clear_status(FileInfo* this_);
void g_file_info_copy_into(FileInfo* this_, FileInfo* dest_info);
FileInfo* /*new*/ g_file_info_dup(FileInfo* this_);
char* /*new*/ g_file_info_get_attribute_as_string(FileInfo* this_, char* attribute);
int g_file_info_get_attribute_boolean(FileInfo* this_, char* attribute);
char* g_file_info_get_attribute_byte_string(FileInfo* this_, char* attribute);
int g_file_info_get_attribute_data(FileInfo* this_, char* attribute, /*out*/ FileAttributeType* type=null, /*out*/ void** value_pp=null, /*out*/ FileAttributeStatus* status=null);
int g_file_info_get_attribute_int32(FileInfo* this_, char* attribute);
long g_file_info_get_attribute_int64(FileInfo* this_, char* attribute);
GObject2.Object* g_file_info_get_attribute_object(FileInfo* this_, char* attribute);
FileAttributeStatus g_file_info_get_attribute_status(FileInfo* this_, char* attribute);
char* g_file_info_get_attribute_string(FileInfo* this_, char* attribute);
char** g_file_info_get_attribute_stringv(FileInfo* this_, char* attribute);
FileAttributeType g_file_info_get_attribute_type(FileInfo* this_, char* attribute);
uint g_file_info_get_attribute_uint32(FileInfo* this_, char* attribute);
ulong g_file_info_get_attribute_uint64(FileInfo* this_, char* attribute);
char* g_file_info_get_content_type(FileInfo* this_);
char* g_file_info_get_display_name(FileInfo* this_);
char* g_file_info_get_edit_name(FileInfo* this_);
char* g_file_info_get_etag(FileInfo* this_);
FileType g_file_info_get_file_type(FileInfo* this_);
Icon* g_file_info_get_icon(FileInfo* this_);
int g_file_info_get_is_backup(FileInfo* this_);
int g_file_info_get_is_hidden(FileInfo* this_);
int g_file_info_get_is_symlink(FileInfo* this_);
void g_file_info_get_modification_time(FileInfo* this_, GLib2.TimeVal* result);
char* g_file_info_get_name(FileInfo* this_);
long g_file_info_get_size(FileInfo* this_);
int g_file_info_get_sort_order(FileInfo* this_);
char* g_file_info_get_symlink_target(FileInfo* this_);
int g_file_info_has_attribute(FileInfo* this_, char* attribute);
int g_file_info_has_namespace(FileInfo* this_, char* name_space);
char** /*new*/ g_file_info_list_attributes(FileInfo* this_, char* name_space);
void g_file_info_remove_attribute(FileInfo* this_, char* attribute);
void g_file_info_set_attribute(FileInfo* this_, char* attribute, FileAttributeType type, void* value_p);
void g_file_info_set_attribute_boolean(FileInfo* this_, char* attribute, int attr_value);
void g_file_info_set_attribute_byte_string(FileInfo* this_, char* attribute, char* attr_value);
void g_file_info_set_attribute_int32(FileInfo* this_, char* attribute, int attr_value);
void g_file_info_set_attribute_int64(FileInfo* this_, char* attribute, long attr_value);
void g_file_info_set_attribute_mask(FileInfo* this_, FileAttributeMatcher* mask);
void g_file_info_set_attribute_object(FileInfo* this_, char* attribute, GObject2.Object* attr_value);
int g_file_info_set_attribute_status(FileInfo* this_, char* attribute, FileAttributeStatus status);
void g_file_info_set_attribute_string(FileInfo* this_, char* attribute, char* attr_value);
void g_file_info_set_attribute_stringv(FileInfo* this_, char* attribute, char** attr_value);
void g_file_info_set_attribute_uint32(FileInfo* this_, char* attribute, uint attr_value);
void g_file_info_set_attribute_uint64(FileInfo* this_, char* attribute, ulong attr_value);
void g_file_info_set_content_type(FileInfo* this_, char* content_type);
void g_file_info_set_display_name(FileInfo* this_, char* display_name);
void g_file_info_set_edit_name(FileInfo* this_, char* edit_name);
void g_file_info_set_file_type(FileInfo* this_, FileType type);
void g_file_info_set_icon(FileInfo* this_, Icon* icon);
void g_file_info_set_is_hidden(FileInfo* this_, int is_hidden);
void g_file_info_set_is_symlink(FileInfo* this_, int is_symlink);
void g_file_info_set_modification_time(FileInfo* this_, GLib2.TimeVal* mtime);
void g_file_info_set_name(FileInfo* this_, char* name);
void g_file_info_set_size(FileInfo* this_, long size);
void g_file_info_set_sort_order(FileInfo* this_, int sort_order);
void g_file_info_set_symlink_target(FileInfo* this_, char* symlink_target);
void g_file_info_unset_attribute_mask(FileInfo* this_);
FileInfo* /*new*/ g_file_input_stream_query_info(FileInputStream* this_, char* attributes, Cancellable* cancellable, GLib2.Error** error);
void g_file_input_stream_query_info_async(FileInputStream* this_, char* attributes, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
FileInfo* /*new*/ g_file_input_stream_query_info_finish(FileInputStream* this_, AsyncResult* result, GLib2.Error** error);
int g_file_monitor_cancel(FileMonitor* this_);
void g_file_monitor_emit_event(FileMonitor* this_, File* child, File* other_file, FileMonitorEvent event_type);
int g_file_monitor_is_cancelled(FileMonitor* this_);
void g_file_monitor_set_rate_limit(FileMonitor* this_, int limit_msecs);
char* /*new*/ g_file_output_stream_get_etag(FileOutputStream* this_);
FileInfo* /*new*/ g_file_output_stream_query_info(FileOutputStream* this_, char* attributes, Cancellable* cancellable, GLib2.Error** error);
void g_file_output_stream_query_info_async(FileOutputStream* this_, char* attributes, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
FileInfo* /*new*/ g_file_output_stream_query_info_finish(FileOutputStream* this_, AsyncResult* result, GLib2.Error** error);
FilenameCompleter* /*new*/ g_filename_completer_new();
char* /*new*/ g_filename_completer_get_completion_suffix(FilenameCompleter* this_, char* initial_text);
char** /*new*/ g_filename_completer_get_completions(FilenameCompleter* this_, char* initial_text);
void g_filename_completer_set_dirs_only(FilenameCompleter* this_, int dirs_only);
InputStream* g_filter_input_stream_get_base_stream(FilterInputStream* this_);
int g_filter_input_stream_get_close_base_stream(FilterInputStream* this_);
void g_filter_input_stream_set_close_base_stream(FilterInputStream* this_, int close_base);
OutputStream* g_filter_output_stream_get_base_stream(FilterOutputStream* this_);
int g_filter_output_stream_get_close_base_stream(FilterOutputStream* this_);
void g_filter_output_stream_set_close_base_stream(FilterOutputStream* this_, int close_base);
char* g_io_extension_get_name(IOExtension* this_);
int g_io_extension_get_priority(IOExtension* this_);
GObject2.TypeClass* /*new*/ g_io_extension_ref_class(IOExtension* this_);
IOExtension* g_io_extension_point_get_extension_by_name(IOExtensionPoint* this_, char* name);
GLib2.List* g_io_extension_point_get_extensions(IOExtensionPoint* this_);
Type g_io_extension_point_get_required_type(IOExtensionPoint* this_);
void g_io_extension_point_set_required_type(IOExtensionPoint* this_, Type type);
IOExtension* g_io_extension_point_implement(char* extension_point_name, Type type, char* extension_name, int priority);
IOExtensionPoint* g_io_extension_point_lookup(char* name);
IOExtensionPoint* g_io_extension_point_register(char* name);
IOModule* /*new*/ g_io_module_new(char* filename);
char** /*new*/ g_io_module_query();
void g_io_module_load(IOModule* this_);
void g_io_module_unload(IOModule* this_);
void g_io_module_scope_block(IOModuleScope* this_, char* basename);
void g_io_module_scope_free(IOModuleScope* this_);
IOModuleScope* /*new*/ g_io_module_scope_new(IOModuleScopeFlags flags);
int g_io_scheduler_job_send_to_mainloop(IOSchedulerJob* this_, GLib2.SourceFunc func, void* user_data, GLib2.DestroyNotify notify);
void g_io_scheduler_job_send_to_mainloop_async(IOSchedulerJob* this_, GLib2.SourceFunc func, void* user_data, GLib2.DestroyNotify notify);
int g_io_stream_splice_finish(AsyncResult* result, GLib2.Error** error);
void g_io_stream_clear_pending(IOStream* this_);
int g_io_stream_close(IOStream* this_, Cancellable* cancellable, GLib2.Error** error);
void g_io_stream_close_async(IOStream* this_, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_io_stream_close_finish(IOStream* this_, AsyncResult* result, GLib2.Error** error);
InputStream* g_io_stream_get_input_stream(IOStream* this_);
OutputStream* g_io_stream_get_output_stream(IOStream* this_);
int g_io_stream_has_pending(IOStream* this_);
int g_io_stream_is_closed(IOStream* this_);
int g_io_stream_set_pending(IOStream* this_, GLib2.Error** error);
void g_io_stream_splice_async(IOStream* this_, IOStream* stream2, IOStreamSpliceFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
uint g_icon_hash(const(void)* icon);
Icon* /*new*/ g_icon_new_for_string(char* str, GLib2.Error** error);
int g_icon_equal(Icon* this_, Icon* icon2);
char* /*new*/ g_icon_to_string(Icon* this_);
InetAddress* /*new*/ g_inet_address_new_any(SocketFamily family);
InetAddress* /*new*/ g_inet_address_new_from_bytes(ubyte* bytes, SocketFamily family);
InetAddress* /*new*/ g_inet_address_new_from_string(char* string_);
InetAddress* /*new*/ g_inet_address_new_loopback(SocketFamily family);
int g_inet_address_equal(InetAddress* this_, InetAddress* other_address);
SocketFamily g_inet_address_get_family(InetAddress* this_);
int g_inet_address_get_is_any(InetAddress* this_);
int g_inet_address_get_is_link_local(InetAddress* this_);
int g_inet_address_get_is_loopback(InetAddress* this_);
int g_inet_address_get_is_mc_global(InetAddress* this_);
int g_inet_address_get_is_mc_link_local(InetAddress* this_);
int g_inet_address_get_is_mc_node_local(InetAddress* this_);
int g_inet_address_get_is_mc_org_local(InetAddress* this_);
int g_inet_address_get_is_mc_site_local(InetAddress* this_);
int g_inet_address_get_is_multicast(InetAddress* this_);
int g_inet_address_get_is_site_local(InetAddress* this_);
size_t g_inet_address_get_native_size(InetAddress* this_);
ubyte* g_inet_address_to_bytes(InetAddress* this_);
char* /*new*/ g_inet_address_to_string(InetAddress* this_);
InetSocketAddress* /*new*/ g_inet_socket_address_new(InetAddress* address, ushort port);
InetAddress* g_inet_socket_address_get_address(InetSocketAddress* this_);
ushort g_inet_socket_address_get_port(InetSocketAddress* this_);
void* /*new*/ g_initable_new(Type object_type, Cancellable* cancellable, GLib2.Error** error, char* first_property_name, ...);
GObject2.Object* /*new*/ g_initable_new_valist(Type object_type, char* first_property_name, va_list var_args, Cancellable* cancellable, GLib2.Error** error);
void* /*new*/ g_initable_newv(Type object_type, uint n_parameters, GObject2.Parameter* parameters, Cancellable* cancellable, GLib2.Error** error);
int g_initable_init(Initable* this_, Cancellable* cancellable, GLib2.Error** error);
void g_input_stream_clear_pending(InputStream* this_);
int g_input_stream_close(InputStream* this_, Cancellable* cancellable, GLib2.Error** error);
void g_input_stream_close_async(InputStream* this_, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_input_stream_close_finish(InputStream* this_, AsyncResult* result, GLib2.Error** error);
int g_input_stream_has_pending(InputStream* this_);
int g_input_stream_is_closed(InputStream* this_);
ssize_t g_input_stream_read(InputStream* this_, void* buffer, size_t count, Cancellable* cancellable, GLib2.Error** error);
int g_input_stream_read_all(InputStream* this_, void* buffer, size_t count, /*out*/ size_t* bytes_read, Cancellable* cancellable, GLib2.Error** error);
void g_input_stream_read_async(InputStream* this_, void* buffer, size_t count, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
ssize_t g_input_stream_read_finish(InputStream* this_, AsyncResult* result, GLib2.Error** error);
int g_input_stream_set_pending(InputStream* this_, GLib2.Error** error);
ssize_t g_input_stream_skip(InputStream* this_, size_t count, Cancellable* cancellable, GLib2.Error** error);
void g_input_stream_skip_async(InputStream* this_, size_t count, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
ssize_t g_input_stream_skip_finish(InputStream* this_, AsyncResult* result, GLib2.Error** error);
InputStream* /*new*/ g_loadable_icon_load(LoadableIcon* this_, int size, /*out*/ char** type, Cancellable* cancellable, GLib2.Error** error);
void g_loadable_icon_load_async(LoadableIcon* this_, int size, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
InputStream* /*new*/ g_loadable_icon_load_finish(LoadableIcon* this_, AsyncResult* res, char** type, GLib2.Error** error);
MemoryInputStream* /*new*/ g_memory_input_stream_new();
MemoryInputStream* /*new*/ g_memory_input_stream_new_from_data(ubyte* data, ssize_t len, GLib2.DestroyNotify destroy=null);
void g_memory_input_stream_add_data(MemoryInputStream* this_, ubyte* data, ssize_t len, GLib2.DestroyNotify destroy=null);
MemoryOutputStream* /*new*/ g_memory_output_stream_new(void* data, size_t size, ReallocFunc realloc_function, GLib2.DestroyNotify destroy_function);
void* g_memory_output_stream_get_data(MemoryOutputStream* this_);
size_t g_memory_output_stream_get_data_size(MemoryOutputStream* this_);
size_t g_memory_output_stream_get_size(MemoryOutputStream* this_);
void* /*new*/ g_memory_output_stream_steal_data(MemoryOutputStream* this_);
int g_mount_can_eject(Mount* this_);
int g_mount_can_unmount(Mount* this_);
void g_mount_eject(Mount* this_, MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_mount_eject_finish(Mount* this_, AsyncResult* result, GLib2.Error** error);
void g_mount_eject_with_operation(Mount* this_, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_mount_eject_with_operation_finish(Mount* this_, AsyncResult* result, GLib2.Error** error);
File* /*new*/ g_mount_get_default_location(Mount* this_);
Drive* /*new*/ g_mount_get_drive(Mount* this_);
Icon* /*new*/ g_mount_get_icon(Mount* this_);
char* /*new*/ g_mount_get_name(Mount* this_);
File* /*new*/ g_mount_get_root(Mount* this_);
char* /*new*/ g_mount_get_uuid(Mount* this_);
Volume* /*new*/ g_mount_get_volume(Mount* this_);
void g_mount_guess_content_type(Mount* this_, int force_rescan, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
char** /*new*/ g_mount_guess_content_type_finish(Mount* this_, AsyncResult* result, GLib2.Error** error);
char** /*new*/ g_mount_guess_content_type_sync(Mount* this_, int force_rescan, Cancellable* cancellable, GLib2.Error** error);
int g_mount_is_shadowed(Mount* this_);
void g_mount_remount(Mount* this_, MountMountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_mount_remount_finish(Mount* this_, AsyncResult* result, GLib2.Error** error);
void g_mount_shadow(Mount* this_);
void g_mount_unmount(Mount* this_, MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_mount_unmount_finish(Mount* this_, AsyncResult* result, GLib2.Error** error);
void g_mount_unmount_with_operation(Mount* this_, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_mount_unmount_with_operation_finish(Mount* this_, AsyncResult* result, GLib2.Error** error);
void g_mount_unshadow(Mount* this_);
MountOperation* /*new*/ g_mount_operation_new();
int g_mount_operation_get_anonymous(MountOperation* this_);
int g_mount_operation_get_choice(MountOperation* this_);
char* g_mount_operation_get_domain(MountOperation* this_);
char* g_mount_operation_get_password(MountOperation* this_);
PasswordSave g_mount_operation_get_password_save(MountOperation* this_);
char* g_mount_operation_get_username(MountOperation* this_);
void g_mount_operation_reply(MountOperation* this_, MountOperationResult result);
void g_mount_operation_set_anonymous(MountOperation* this_, int anonymous);
void g_mount_operation_set_choice(MountOperation* this_, int choice);
void g_mount_operation_set_domain(MountOperation* this_, char* domain);
void g_mount_operation_set_password(MountOperation* this_, char* password);
void g_mount_operation_set_password_save(MountOperation* this_, PasswordSave save);
void g_mount_operation_set_username(MountOperation* this_, char* username);
SocketConnectable* /*new*/ g_network_address_new(char* hostname, ushort port);
SocketConnectable* /*new*/ g_network_address_parse(char* host_and_port, ushort default_port, GLib2.Error** error);
SocketConnectable* /*new*/ g_network_address_parse_uri(char* uri, ushort default_port, GLib2.Error** error);
char* g_network_address_get_hostname(NetworkAddress* this_);
ushort g_network_address_get_port(NetworkAddress* this_);
char* g_network_address_get_scheme(NetworkAddress* this_);
SocketConnectable* /*new*/ g_network_service_new(char* service, char* protocol, char* domain);
char* g_network_service_get_domain(NetworkService* this_);
char* g_network_service_get_protocol(NetworkService* this_);
char* g_network_service_get_scheme(NetworkService* this_);
char* g_network_service_get_service(NetworkService* this_);
void g_network_service_set_scheme(NetworkService* this_, char* scheme);
void g_output_stream_clear_pending(OutputStream* this_);
int g_output_stream_close(OutputStream* this_, Cancellable* cancellable, GLib2.Error** error);
void g_output_stream_close_async(OutputStream* this_, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_output_stream_close_finish(OutputStream* this_, AsyncResult* result, GLib2.Error** error);
int g_output_stream_flush(OutputStream* this_, Cancellable* cancellable, GLib2.Error** error);
void g_output_stream_flush_async(OutputStream* this_, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_output_stream_flush_finish(OutputStream* this_, AsyncResult* result, GLib2.Error** error);
int g_output_stream_has_pending(OutputStream* this_);
int g_output_stream_is_closed(OutputStream* this_);
int g_output_stream_is_closing(OutputStream* this_);
int g_output_stream_set_pending(OutputStream* this_, GLib2.Error** error);
ssize_t g_output_stream_splice(OutputStream* this_, InputStream* source, OutputStreamSpliceFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_output_stream_splice_async(OutputStream* this_, InputStream* source, OutputStreamSpliceFlags flags, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
ssize_t g_output_stream_splice_finish(OutputStream* this_, AsyncResult* result, GLib2.Error** error);
ssize_t g_output_stream_write(OutputStream* this_, ubyte* buffer, size_t count, Cancellable* cancellable, GLib2.Error** error);
int g_output_stream_write_all(OutputStream* this_, ubyte* buffer, size_t count, /*out*/ size_t* bytes_written, Cancellable* cancellable, GLib2.Error** error);
void g_output_stream_write_async(OutputStream* this_, ubyte* buffer, size_t count, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
ssize_t g_output_stream_write_finish(OutputStream* this_, AsyncResult* result, GLib2.Error** error);
int g_permission_acquire(Permission* this_, Cancellable* cancellable, GLib2.Error** error);
void g_permission_acquire_async(Permission* this_, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_permission_acquire_finish(Permission* this_, AsyncResult* result, GLib2.Error** error);
int g_permission_get_allowed(Permission* this_);
int g_permission_get_can_acquire(Permission* this_);
int g_permission_get_can_release(Permission* this_);
void g_permission_impl_update(Permission* this_, int allowed, int can_acquire, int can_release);
int g_permission_release(Permission* this_, Cancellable* cancellable, GLib2.Error** error);
void g_permission_release_async(Permission* this_, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_permission_release_finish(Permission* this_, AsyncResult* result, GLib2.Error** error);
int g_pollable_input_stream_can_poll(PollableInputStream* this_);
GLib2.Source* /*new*/ g_pollable_input_stream_create_source(PollableInputStream* this_, Cancellable* cancellable=null);
int g_pollable_input_stream_is_readable(PollableInputStream* this_);
ssize_t g_pollable_input_stream_read_nonblocking(PollableInputStream* this_, void* buffer, size_t size, Cancellable* cancellable, GLib2.Error** error);
int g_pollable_output_stream_can_poll(PollableOutputStream* this_);
GLib2.Source* /*new*/ g_pollable_output_stream_create_source(PollableOutputStream* this_, Cancellable* cancellable=null);
int g_pollable_output_stream_is_writable(PollableOutputStream* this_);
ssize_t g_pollable_output_stream_write_nonblocking(PollableOutputStream* this_, ubyte* buffer, size_t size, Cancellable* cancellable, GLib2.Error** error);
Proxy* /*new*/ g_proxy_get_default_for_protocol(char* protocol);
IOStream* /*new*/ g_proxy_connect(Proxy* this_, IOStream* connection, ProxyAddress* proxy_address, Cancellable* cancellable, GLib2.Error** error);
void g_proxy_connect_async(Proxy* this_, IOStream* connection, ProxyAddress* proxy_address, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
IOStream* /*new*/ g_proxy_connect_finish(Proxy* this_, AsyncResult* result, GLib2.Error** error);
int g_proxy_supports_hostname(Proxy* this_);
ProxyAddress* /*new*/ g_proxy_address_new(InetAddress* inetaddr, ushort port, char* protocol, char* dest_hostname, ushort dest_port, char* username=null, char* password=null);
char* g_proxy_address_get_destination_hostname(ProxyAddress* this_);
ushort g_proxy_address_get_destination_port(ProxyAddress* this_);
char* g_proxy_address_get_password(ProxyAddress* this_);
char* g_proxy_address_get_protocol(ProxyAddress* this_);
char* g_proxy_address_get_username(ProxyAddress* this_);
ProxyResolver* g_proxy_resolver_get_default();
int g_proxy_resolver_is_supported(ProxyResolver* this_);
char** /*new*/ g_proxy_resolver_lookup(ProxyResolver* this_, char* uri, Cancellable* cancellable, GLib2.Error** error);
void g_proxy_resolver_lookup_async(ProxyResolver* this_, char* uri, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
char** /*new*/ g_proxy_resolver_lookup_finish(ProxyResolver* this_, AsyncResult* result, GLib2.Error** error);
void g_resolver_free_addresses(GLib2.List* addresses);
void g_resolver_free_targets(GLib2.List* targets);
Resolver* /*new*/ g_resolver_get_default();
char* /*new*/ g_resolver_lookup_by_address(Resolver* this_, InetAddress* address, Cancellable* cancellable, GLib2.Error** error);
void g_resolver_lookup_by_address_async(Resolver* this_, InetAddress* address, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
char* /*new*/ g_resolver_lookup_by_address_finish(Resolver* this_, AsyncResult* result, GLib2.Error** error);
GLib2.List* /*new*/ g_resolver_lookup_by_name(Resolver* this_, char* hostname, Cancellable* cancellable, GLib2.Error** error);
void g_resolver_lookup_by_name_async(Resolver* this_, char* hostname, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
GLib2.List* /*new*/ g_resolver_lookup_by_name_finish(Resolver* this_, AsyncResult* result, GLib2.Error** error);
GLib2.List* /*new*/ g_resolver_lookup_service(Resolver* this_, char* service, char* protocol, char* domain, Cancellable* cancellable, GLib2.Error** error);
void g_resolver_lookup_service_async(Resolver* this_, char* service, char* protocol, char* domain, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
GLib2.List* /*new*/ g_resolver_lookup_service_finish(Resolver* this_, AsyncResult* result, GLib2.Error** error);
void g_resolver_set_default(Resolver* this_);
int g_seekable_can_seek(Seekable* this_);
int g_seekable_can_truncate(Seekable* this_);
int g_seekable_seek(Seekable* this_, long offset, GLib2.SeekType type, Cancellable* cancellable, GLib2.Error** error);
long g_seekable_tell(Seekable* this_);
int g_seekable_truncate(Seekable* this_, long offset, Cancellable* cancellable, GLib2.Error** error);
Settings* /*new*/ g_settings_new(char* schema);
Settings* /*new*/ g_settings_new_with_backend(char* schema, SettingsBackend* backend);
Settings* /*new*/ g_settings_new_with_backend_and_path(char* schema, SettingsBackend* backend, char* path);
Settings* /*new*/ g_settings_new_with_path(char* schema, char* path);
char** g_settings_list_relocatable_schemas();
char** g_settings_list_schemas();
void g_settings_sync();
void g_settings_unbind(void* object, char* property);
void g_settings_apply(Settings* this_);
void g_settings_bind(Settings* this_, char* key, GObject2.Object* object, char* property, SettingsBindFlags flags);
void g_settings_bind_with_mapping(Settings* this_, char* key, GObject2.Object* object, char* property, SettingsBindFlags flags, SettingsBindGetMapping get_mapping, SettingsBindSetMapping set_mapping, void* user_data, GLib2.DestroyNotify destroy);
void g_settings_bind_writable(Settings* this_, char* key, GObject2.Object* object, char* property, int inverted);
void g_settings_delay(Settings* this_);
void g_settings_get(Settings* this_, char* key, char* format, ...);
int g_settings_get_boolean(Settings* this_, char* key);
Settings* /*new*/ g_settings_get_child(Settings* this_, char* name);
double g_settings_get_double(Settings* this_, char* key);
int g_settings_get_enum(Settings* this_, char* key);
uint g_settings_get_flags(Settings* this_, char* key);
int g_settings_get_has_unapplied(Settings* this_);
int g_settings_get_int(Settings* this_, char* key);
void* /*new*/ g_settings_get_mapped(Settings* this_, char* key, SettingsGetMapping mapping, void* user_data);
GLib2.Variant* /*new*/ g_settings_get_range(Settings* this_, char* key);
char* /*new*/ g_settings_get_string(Settings* this_, char* key);
char** /*new*/ g_settings_get_strv(Settings* this_, char* key);
uint g_settings_get_uint(Settings* this_, char* key);
GLib2.Variant* /*new*/ g_settings_get_value(Settings* this_, char* key);
int g_settings_is_writable(Settings* this_, char* name);
char** /*new*/ g_settings_list_children(Settings* this_);
char** /*new*/ g_settings_list_keys(Settings* this_);
int g_settings_range_check(Settings* this_, char* key, GLib2.Variant* value);
void g_settings_reset(Settings* this_, char* key);
void g_settings_revert(Settings* this_);
int g_settings_set(Settings* this_, char* key, char* format, ...);
int g_settings_set_boolean(Settings* this_, char* key, int value);
int g_settings_set_double(Settings* this_, char* key, double value);
int g_settings_set_enum(Settings* this_, char* key, int value);
int g_settings_set_flags(Settings* this_, char* key, uint value);
int g_settings_set_int(Settings* this_, char* key, int value);
int g_settings_set_string(Settings* this_, char* key, char* value);
int g_settings_set_strv(Settings* this_, char* key, char** value=null);
int g_settings_set_uint(Settings* this_, char* key, uint value);
int g_settings_set_value(Settings* this_, char* key, GLib2.Variant* value);
SimpleAction* /*new*/ g_simple_action_new(char* name, GLib2.VariantType* parameter_type=null);
SimpleAction* /*new*/ g_simple_action_new_stateful(char* name, GLib2.VariantType* parameter_type, GLib2.Variant* state);
void g_simple_action_set_enabled(SimpleAction* this_, int enabled);
void g_simple_action_set_state(SimpleAction* this_, GLib2.Variant* value);
SimpleActionGroup* /*new*/ g_simple_action_group_new();
void g_simple_action_group_add_entries(SimpleActionGroup* this_, ActionEntry* entries, int n_entries, void* user_data);
void g_simple_action_group_insert(SimpleActionGroup* this_, Action* action);
Action* g_simple_action_group_lookup(SimpleActionGroup* this_, char* action_name);
void g_simple_action_group_remove(SimpleActionGroup* this_, char* action_name);
SimpleAsyncResult* /*new*/ g_simple_async_result_new(GObject2.Object* source_object, AsyncReadyCallback callback, void* user_data, void* source_tag);
SimpleAsyncResult* /*new*/ g_simple_async_result_new_error(GObject2.Object* source_object, AsyncReadyCallback callback, void* user_data, GLib2.Quark domain, int code, char* format, ...);
SimpleAsyncResult* /*new*/ g_simple_async_result_new_from_error(GObject2.Object* source_object, AsyncReadyCallback callback, void* user_data, GLib2.Error* error);
SimpleAsyncResult* /*new*/ g_simple_async_result_new_take_error(GObject2.Object* source_object, AsyncReadyCallback callback, void* user_data, GLib2.Error* error);
int g_simple_async_result_is_valid(AsyncResult* result, GObject2.Object* source, void* source_tag);
void g_simple_async_result_complete(SimpleAsyncResult* this_);
void g_simple_async_result_complete_in_idle(SimpleAsyncResult* this_);
int g_simple_async_result_get_op_res_gboolean(SimpleAsyncResult* this_);
void* g_simple_async_result_get_op_res_gpointer(SimpleAsyncResult* this_);
ssize_t g_simple_async_result_get_op_res_gssize(SimpleAsyncResult* this_);
void* g_simple_async_result_get_source_tag(SimpleAsyncResult* this_);
int g_simple_async_result_propagate_error(SimpleAsyncResult* this_, GLib2.Error** error);
void g_simple_async_result_run_in_thread(SimpleAsyncResult* this_, SimpleAsyncThreadFunc func, int io_priority, Cancellable* cancellable=null);
void g_simple_async_result_set_error(SimpleAsyncResult* this_, GLib2.Quark domain, int code, char* format, ...);
void g_simple_async_result_set_error_va(SimpleAsyncResult* this_, GLib2.Quark domain, int code, char* format, va_list args);
void g_simple_async_result_set_from_error(SimpleAsyncResult* this_, GLib2.Error* error);
void g_simple_async_result_set_handle_cancellation(SimpleAsyncResult* this_, int handle_cancellation);
void g_simple_async_result_set_op_res_gboolean(SimpleAsyncResult* this_, int op_res);
void g_simple_async_result_set_op_res_gpointer(SimpleAsyncResult* this_, void* op_res, GLib2.DestroyNotify destroy_op_res);
void g_simple_async_result_set_op_res_gssize(SimpleAsyncResult* this_, ssize_t op_res);
void g_simple_async_result_take_error(SimpleAsyncResult* this_, GLib2.Error* error);
SimplePermission* /*new*/ g_simple_permission_new(int allowed);
Socket* /*new*/ g_socket_new(SocketFamily family, SocketType type, SocketProtocol protocol, GLib2.Error** error);
Socket* /*new*/ g_socket_new_from_fd(int fd, GLib2.Error** error);
Socket* /*new*/ g_socket_accept(Socket* this_, Cancellable* cancellable, GLib2.Error** error);
int g_socket_bind(Socket* this_, SocketAddress* address, int allow_reuse, GLib2.Error** error);
int g_socket_check_connect_result(Socket* this_, GLib2.Error** error);
int g_socket_close(Socket* this_, GLib2.Error** error);
GLib2.IOCondition g_socket_condition_check(Socket* this_, GLib2.IOCondition condition);
int g_socket_condition_wait(Socket* this_, GLib2.IOCondition condition, Cancellable* cancellable, GLib2.Error** error);
int g_socket_connect(Socket* this_, SocketAddress* address, Cancellable* cancellable, GLib2.Error** error);
SocketConnection* /*new*/ g_socket_connection_factory_create_connection(Socket* this_);
GLib2.Source* /*new*/ g_socket_create_source(Socket* this_, GLib2.IOCondition condition, Cancellable* cancellable=null);
int g_socket_get_blocking(Socket* this_);
Credentials* /*new*/ g_socket_get_credentials(Socket* this_, GLib2.Error** error);
SocketFamily g_socket_get_family(Socket* this_);
int g_socket_get_fd(Socket* this_);
int g_socket_get_keepalive(Socket* this_);
int g_socket_get_listen_backlog(Socket* this_);
SocketAddress* /*new*/ g_socket_get_local_address(Socket* this_, GLib2.Error** error);
SocketProtocol g_socket_get_protocol(Socket* this_);
SocketAddress* /*new*/ g_socket_get_remote_address(Socket* this_, GLib2.Error** error);
SocketType g_socket_get_socket_type(Socket* this_);
uint g_socket_get_timeout(Socket* this_);
int g_socket_is_closed(Socket* this_);
int g_socket_is_connected(Socket* this_);
int g_socket_listen(Socket* this_, GLib2.Error** error);
ssize_t g_socket_receive(Socket* this_, char* buffer, size_t size, Cancellable* cancellable, GLib2.Error** error);
ssize_t g_socket_receive_from(Socket* this_, SocketAddress** address, char* buffer, size_t size, Cancellable* cancellable, GLib2.Error** error);
ssize_t g_socket_receive_message(Socket* this_, SocketAddress** address, InputVector* vectors, int num_vectors, SocketControlMessage*** messages, int* num_messages, int* flags, Cancellable* cancellable, GLib2.Error** error);
ssize_t g_socket_receive_with_blocking(Socket* this_, char* buffer, size_t size, int blocking, Cancellable* cancellable, GLib2.Error** error);
ssize_t g_socket_send(Socket* this_, char* buffer, size_t size, Cancellable* cancellable, GLib2.Error** error);
ssize_t g_socket_send_message(Socket* this_, SocketAddress* address, OutputVector* vectors, int num_vectors, SocketControlMessage** messages, int num_messages, int flags, Cancellable* cancellable, GLib2.Error** error);
ssize_t g_socket_send_to(Socket* this_, SocketAddress* address, char* buffer, size_t size, Cancellable* cancellable, GLib2.Error** error);
ssize_t g_socket_send_with_blocking(Socket* this_, char* buffer, size_t size, int blocking, Cancellable* cancellable, GLib2.Error** error);
void g_socket_set_blocking(Socket* this_, int blocking);
void g_socket_set_keepalive(Socket* this_, int keepalive);
void g_socket_set_listen_backlog(Socket* this_, int backlog);
void g_socket_set_timeout(Socket* this_, uint timeout);
int g_socket_shutdown(Socket* this_, int shutdown_read, int shutdown_write, GLib2.Error** error);
int g_socket_speaks_ipv4(Socket* this_);
SocketAddress* /*new*/ g_socket_address_new_from_native(void* native, size_t len);
SocketFamily g_socket_address_get_family(SocketAddress* this_);
ssize_t g_socket_address_get_native_size(SocketAddress* this_);
int g_socket_address_to_native(SocketAddress* this_, void* dest, size_t destlen, GLib2.Error** error);
SocketAddress* /*new*/ g_socket_address_enumerator_next(SocketAddressEnumerator* this_, Cancellable* cancellable, GLib2.Error** error);
void g_socket_address_enumerator_next_async(SocketAddressEnumerator* this_, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
SocketAddress* /*new*/ g_socket_address_enumerator_next_finish(SocketAddressEnumerator* this_, AsyncResult* result, GLib2.Error** error);
SocketClient* /*new*/ g_socket_client_new();
void g_socket_client_add_application_proxy(SocketClient* this_, char* protocol);
SocketConnection* /*new*/ g_socket_client_connect(SocketClient* this_, SocketConnectable* connectable, Cancellable* cancellable, GLib2.Error** error);
void g_socket_client_connect_async(SocketClient* this_, SocketConnectable* connectable, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
SocketConnection* /*new*/ g_socket_client_connect_finish(SocketClient* this_, AsyncResult* result, GLib2.Error** error);
SocketConnection* /*new*/ g_socket_client_connect_to_host(SocketClient* this_, char* host_and_port, ushort default_port, Cancellable* cancellable, GLib2.Error** error);
void g_socket_client_connect_to_host_async(SocketClient* this_, char* host_and_port, ushort default_port, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
SocketConnection* /*new*/ g_socket_client_connect_to_host_finish(SocketClient* this_, AsyncResult* result, GLib2.Error** error);
SocketConnection* /*new*/ g_socket_client_connect_to_service(SocketClient* this_, char* domain, char* service, Cancellable* cancellable, GLib2.Error** error);
void g_socket_client_connect_to_service_async(SocketClient* this_, char* domain, char* service, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
SocketConnection* /*new*/ g_socket_client_connect_to_service_finish(SocketClient* this_, AsyncResult* result, GLib2.Error** error);
SocketConnection* /*new*/ g_socket_client_connect_to_uri(SocketClient* this_, char* uri, ushort default_port, Cancellable* cancellable, GLib2.Error** error);
void g_socket_client_connect_to_uri_async(SocketClient* this_, char* uri, ushort default_port, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
SocketConnection* /*new*/ g_socket_client_connect_to_uri_finish(SocketClient* this_, AsyncResult* result, GLib2.Error** error);
int g_socket_client_get_enable_proxy(SocketClient* this_);
SocketFamily g_socket_client_get_family(SocketClient* this_);
SocketAddress* g_socket_client_get_local_address(SocketClient* this_);
SocketProtocol g_socket_client_get_protocol(SocketClient* this_);
SocketType g_socket_client_get_socket_type(SocketClient* this_);
uint g_socket_client_get_timeout(SocketClient* this_);
int g_socket_client_get_tls(SocketClient* this_);
TlsCertificateFlags g_socket_client_get_tls_validation_flags(SocketClient* this_);
void g_socket_client_set_enable_proxy(SocketClient* this_, int enable);
void g_socket_client_set_family(SocketClient* this_, SocketFamily family);
void g_socket_client_set_local_address(SocketClient* this_, SocketAddress* address);
void g_socket_client_set_protocol(SocketClient* this_, SocketProtocol protocol);
void g_socket_client_set_socket_type(SocketClient* this_, SocketType type);
void g_socket_client_set_timeout(SocketClient* this_, uint timeout);
void g_socket_client_set_tls(SocketClient* this_, int tls);
void g_socket_client_set_tls_validation_flags(SocketClient* this_, TlsCertificateFlags flags);
SocketAddressEnumerator* /*new*/ g_socket_connectable_enumerate(SocketConnectable* this_);
SocketAddressEnumerator* /*new*/ g_socket_connectable_proxy_enumerate(SocketConnectable* this_);
Type g_socket_connection_factory_lookup_type(SocketFamily family, SocketType type, int protocol_id);
void g_socket_connection_factory_register_type(Type g_type, SocketFamily family, SocketType type, int protocol);
SocketAddress* /*new*/ g_socket_connection_get_local_address(SocketConnection* this_, GLib2.Error** error);
SocketAddress* /*new*/ g_socket_connection_get_remote_address(SocketConnection* this_, GLib2.Error** error);
Socket* g_socket_connection_get_socket(SocketConnection* this_);
SocketControlMessage* /*new*/ g_socket_control_message_deserialize(int level, int type, size_t size, void* data);
int g_socket_control_message_get_level(SocketControlMessage* this_);
int g_socket_control_message_get_msg_type(SocketControlMessage* this_);
size_t g_socket_control_message_get_size(SocketControlMessage* this_);
void g_socket_control_message_serialize(SocketControlMessage* this_, void* data);
SocketListener* /*new*/ g_socket_listener_new();
SocketConnection* /*new*/ g_socket_listener_accept(SocketListener* this_, /*out*/ GObject2.Object** source_object, Cancellable* cancellable, GLib2.Error** error);
void g_socket_listener_accept_async(SocketListener* this_, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
SocketConnection* /*new*/ g_socket_listener_accept_finish(SocketListener* this_, AsyncResult* result, /*out*/ GObject2.Object** source_object, GLib2.Error** error);
Socket* /*new*/ g_socket_listener_accept_socket(SocketListener* this_, /*out*/ GObject2.Object** source_object, Cancellable* cancellable, GLib2.Error** error);
void g_socket_listener_accept_socket_async(SocketListener* this_, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
Socket* /*new*/ g_socket_listener_accept_socket_finish(SocketListener* this_, AsyncResult* result, /*out*/ GObject2.Object** source_object, GLib2.Error** error);
int g_socket_listener_add_address(SocketListener* this_, SocketAddress* address, SocketType type, SocketProtocol protocol, GObject2.Object* source_object, /*out*/ SocketAddress** effective_address, GLib2.Error** error);
ushort g_socket_listener_add_any_inet_port(SocketListener* this_, GObject2.Object* source_object, GLib2.Error** error);
int g_socket_listener_add_inet_port(SocketListener* this_, ushort port, GObject2.Object* source_object, GLib2.Error** error);
int g_socket_listener_add_socket(SocketListener* this_, Socket* socket, GObject2.Object* source_object, GLib2.Error** error);
void g_socket_listener_close(SocketListener* this_);
void g_socket_listener_set_backlog(SocketListener* this_, int listen_backlog);
SocketService* /*new*/ g_socket_service_new();
int g_socket_service_is_active(SocketService* this_);
void g_socket_service_start(SocketService* this_);
void g_socket_service_stop(SocketService* this_);
SrvTarget* /*new*/ g_srv_target_new(char* hostname, ushort port, ushort priority, ushort weight);
SrvTarget* /*new*/ g_srv_target_copy(SrvTarget* this_);
void g_srv_target_free(SrvTarget* this_);
char* g_srv_target_get_hostname(SrvTarget* this_);
ushort g_srv_target_get_port(SrvTarget* this_);
ushort g_srv_target_get_priority(SrvTarget* this_);
ushort g_srv_target_get_weight(SrvTarget* this_);
GLib2.List* /*new*/ g_srv_target_list_sort(GLib2.List* targets);
int g_tcp_connection_get_graceful_disconnect(TcpConnection* this_);
void g_tcp_connection_set_graceful_disconnect(TcpConnection* this_, int graceful_disconnect);
TcpWrapperConnection* /*new*/ g_tcp_wrapper_connection_new(IOStream* base_io_stream, Socket* socket);
IOStream* g_tcp_wrapper_connection_get_base_io_stream(TcpWrapperConnection* this_);
Icon* /*new*/ g_themed_icon_new(char* iconname);
Icon* /*new*/ g_themed_icon_new_from_names(char** iconnames, int len);
Icon* /*new*/ g_themed_icon_new_with_default_fallbacks(char* iconname);
void g_themed_icon_append_name(ThemedIcon* this_, char* iconname);
char** g_themed_icon_get_names(ThemedIcon* this_);
void g_themed_icon_prepend_name(ThemedIcon* this_, char* iconname);
ThreadedSocketService* /*new*/ g_threaded_socket_service_new(int max_threads);
TlsBackend* g_tls_backend_get_default();
Type g_tls_backend_get_certificate_type(TlsBackend* this_);
Type g_tls_backend_get_client_connection_type(TlsBackend* this_);
TlsDatabase* /*new*/ g_tls_backend_get_default_database(TlsBackend* this_);
Type g_tls_backend_get_file_database_type(TlsBackend* this_);
Type g_tls_backend_get_server_connection_type(TlsBackend* this_);
int g_tls_backend_supports_tls(TlsBackend* this_);
TlsCertificate* /*new*/ g_tls_certificate_new_from_file(char* file, GLib2.Error** error);
TlsCertificate* /*new*/ g_tls_certificate_new_from_files(char* cert_file, char* key_file, GLib2.Error** error);
TlsCertificate* /*new*/ g_tls_certificate_new_from_pem(char* data, ssize_t length, GLib2.Error** error);
GLib2.List* /*new*/ g_tls_certificate_list_new_from_file(char* file, GLib2.Error** error);
TlsCertificate* g_tls_certificate_get_issuer(TlsCertificate* this_);
TlsCertificateFlags g_tls_certificate_verify(TlsCertificate* this_, SocketConnectable* identity=null, TlsCertificate* trusted_ca=null);
IOStream* /*new*/ g_tls_client_connection_new(IOStream* base_io_stream, SocketConnectable* server_identity, GLib2.Error** error);
GLib2.List* /*new*/ g_tls_client_connection_get_accepted_cas(TlsClientConnection* this_);
SocketConnectable* g_tls_client_connection_get_server_identity(TlsClientConnection* this_);
int g_tls_client_connection_get_use_ssl3(TlsClientConnection* this_);
TlsCertificateFlags g_tls_client_connection_get_validation_flags(TlsClientConnection* this_);
void g_tls_client_connection_set_server_identity(TlsClientConnection* this_, SocketConnectable* identity);
void g_tls_client_connection_set_use_ssl3(TlsClientConnection* this_, int use_ssl3);
void g_tls_client_connection_set_validation_flags(TlsClientConnection* this_, TlsCertificateFlags flags);
int g_tls_connection_emit_accept_certificate(TlsConnection* this_, TlsCertificate* peer_cert, TlsCertificateFlags errors);
TlsCertificate* g_tls_connection_get_certificate(TlsConnection* this_);
TlsDatabase* g_tls_connection_get_database(TlsConnection* this_);
TlsInteraction* g_tls_connection_get_interaction(TlsConnection* this_);
TlsCertificate* g_tls_connection_get_peer_certificate(TlsConnection* this_);
TlsCertificateFlags g_tls_connection_get_peer_certificate_errors(TlsConnection* this_);
TlsRehandshakeMode g_tls_connection_get_rehandshake_mode(TlsConnection* this_);
int g_tls_connection_get_require_close_notify(TlsConnection* this_);
int g_tls_connection_get_use_system_certdb(TlsConnection* this_);
int g_tls_connection_handshake(TlsConnection* this_, Cancellable* cancellable, GLib2.Error** error);
void g_tls_connection_handshake_async(TlsConnection* this_, int io_priority, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_tls_connection_handshake_finish(TlsConnection* this_, AsyncResult* result, GLib2.Error** error);
void g_tls_connection_set_certificate(TlsConnection* this_, TlsCertificate* certificate);
void g_tls_connection_set_database(TlsConnection* this_, TlsDatabase* database);
void g_tls_connection_set_interaction(TlsConnection* this_, TlsInteraction* interaction=null);
void g_tls_connection_set_rehandshake_mode(TlsConnection* this_, TlsRehandshakeMode mode);
void g_tls_connection_set_require_close_notify(TlsConnection* this_, int require_close_notify);
void g_tls_connection_set_use_system_certdb(TlsConnection* this_, int use_system_certdb);
char* /*new*/ g_tls_database_create_certificate_handle(TlsDatabase* this_, TlsCertificate* certificate);
TlsCertificate* /*new*/ g_tls_database_lookup_certificate_for_handle(TlsDatabase* this_, char* handle, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_tls_database_lookup_certificate_for_handle_async(TlsDatabase* this_, char* handle, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
TlsCertificate* /*new*/ g_tls_database_lookup_certificate_for_handle_finish(TlsDatabase* this_, AsyncResult* result, GLib2.Error** error);
TlsCertificate* /*new*/ g_tls_database_lookup_certificate_issuer(TlsDatabase* this_, TlsCertificate* certificate, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_tls_database_lookup_certificate_issuer_async(TlsDatabase* this_, TlsCertificate* certificate, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
TlsCertificate* /*new*/ g_tls_database_lookup_certificate_issuer_finish(TlsDatabase* this_, AsyncResult* result, GLib2.Error** error);
GLib2.List* /*new*/ g_tls_database_lookup_certificates_issued_by(TlsDatabase* this_, ByteArray* issuer_raw_dn, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_tls_database_lookup_certificates_issued_by_async(TlsDatabase* this_, ByteArray* issuer_raw_dn, TlsInteraction* interaction, TlsDatabaseLookupFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
GLib2.List* /*new*/ g_tls_database_lookup_certificates_issued_by_finish(TlsDatabase* this_, AsyncResult* result, GLib2.Error** error);
TlsCertificateFlags g_tls_database_verify_chain(TlsDatabase* this_, TlsCertificate* chain, char* purpose, SocketConnectable* identity, TlsInteraction* interaction, TlsDatabaseVerifyFlags flags, Cancellable* cancellable, GLib2.Error** error);
void g_tls_database_verify_chain_async(TlsDatabase* this_, TlsCertificate* chain, char* purpose, SocketConnectable* identity, TlsInteraction* interaction, TlsDatabaseVerifyFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
TlsCertificateFlags g_tls_database_verify_chain_finish(TlsDatabase* this_, AsyncResult* result, GLib2.Error** error);
TlsDatabase* /*new*/ g_tls_file_database_new(char* anchors, GLib2.Error** error);
TlsInteractionResult g_tls_interaction_ask_password(TlsInteraction* this_, TlsPassword* password, Cancellable* cancellable, GLib2.Error** error);
void g_tls_interaction_ask_password_async(TlsInteraction* this_, TlsPassword* password, Cancellable* cancellable=null, AsyncReadyCallback callback=null, void* user_data=null);
TlsInteractionResult g_tls_interaction_ask_password_finish(TlsInteraction* this_, AsyncResult* result, GLib2.Error** error);
TlsInteractionResult g_tls_interaction_invoke_ask_password(TlsInteraction* this_, TlsPassword* password, Cancellable* cancellable, GLib2.Error** error);
TlsPassword* /*new*/ g_tls_password_new(TlsPasswordFlags flags, char* description);
char* g_tls_password_get_description(TlsPassword* this_);
TlsPasswordFlags g_tls_password_get_flags(TlsPassword* this_);
ubyte* g_tls_password_get_value(TlsPassword* this_, size_t* length=null);
char* g_tls_password_get_warning(TlsPassword* this_);
void g_tls_password_set_description(TlsPassword* this_, char* description);
void g_tls_password_set_flags(TlsPassword* this_, TlsPasswordFlags flags);
void g_tls_password_set_value(TlsPassword* this_, ubyte* value, ssize_t length);
void g_tls_password_set_value_full(TlsPassword* this_, ubyte* value, ssize_t length, GLib2.DestroyNotify destroy=null);
void g_tls_password_set_warning(TlsPassword* this_, char* warning);
IOStream* /*new*/ g_tls_server_connection_new(IOStream* base_io_stream, TlsCertificate* certificate, GLib2.Error** error);
Credentials* /*new*/ g_unix_connection_receive_credentials(UnixConnection* this_, Cancellable* cancellable, GLib2.Error** error);
int g_unix_connection_receive_fd(UnixConnection* this_, Cancellable* cancellable, GLib2.Error** error);
int g_unix_connection_send_credentials(UnixConnection* this_, Cancellable* cancellable, GLib2.Error** error);
int g_unix_connection_send_fd(UnixConnection* this_, int fd, Cancellable* cancellable, GLib2.Error** error);
UnixCredentialsMessage* /*new*/ g_unix_credentials_message_new();
UnixCredentialsMessage* /*new*/ g_unix_credentials_message_new_with_credentials(Credentials* credentials);
int g_unix_credentials_message_is_supported();
Credentials* g_unix_credentials_message_get_credentials(UnixCredentialsMessage* this_);
UnixFDList* /*new*/ g_unix_fd_list_new();
UnixFDList* /*new*/ g_unix_fd_list_new_from_array(int* fds, int n_fds);
int g_unix_fd_list_append(UnixFDList* this_, int fd, GLib2.Error** error);
int g_unix_fd_list_get(UnixFDList* this_, int index_, GLib2.Error** error);
int g_unix_fd_list_get_length(UnixFDList* this_);
int* g_unix_fd_list_peek_fds(UnixFDList* this_, /*out*/ int* length=null);
int* /*new*/ g_unix_fd_list_steal_fds(UnixFDList* this_, /*out*/ int* length=null);
UnixFDMessage* /*new*/ g_unix_fd_message_new();
UnixFDMessage* /*new*/ g_unix_fd_message_new_with_fd_list(UnixFDList* fd_list);
int g_unix_fd_message_append_fd(UnixFDMessage* this_, int fd, GLib2.Error** error);
UnixFDList* g_unix_fd_message_get_fd_list(UnixFDMessage* this_);
int* /*new*/ g_unix_fd_message_steal_fds(UnixFDMessage* this_, /*out*/ int* length=null);
UnixInputStream* /*new*/ g_unix_input_stream_new(int fd, int close_fd);
int g_unix_input_stream_get_close_fd(UnixInputStream* this_);
int g_unix_input_stream_get_fd(UnixInputStream* this_);
void g_unix_input_stream_set_close_fd(UnixInputStream* this_, int close_fd);
UnixMountMonitor* /*new*/ g_unix_mount_monitor_new();
void g_unix_mount_monitor_set_rate_limit(UnixMountMonitor* this_, int limit_msec);
int g_unix_mount_point_compare(UnixMountPoint* this_, UnixMountPoint* mount2);
void g_unix_mount_point_free(UnixMountPoint* this_);
char* g_unix_mount_point_get_device_path(UnixMountPoint* this_);
char* g_unix_mount_point_get_fs_type(UnixMountPoint* this_);
char* g_unix_mount_point_get_mount_path(UnixMountPoint* this_);
int g_unix_mount_point_guess_can_eject(UnixMountPoint* this_);
Icon* /*new*/ g_unix_mount_point_guess_icon(UnixMountPoint* this_);
char* /*new*/ g_unix_mount_point_guess_name(UnixMountPoint* this_);
int g_unix_mount_point_is_loopback(UnixMountPoint* this_);
int g_unix_mount_point_is_readonly(UnixMountPoint* this_);
int g_unix_mount_point_is_user_mountable(UnixMountPoint* this_);
UnixOutputStream* /*new*/ g_unix_output_stream_new(int fd, int close_fd);
int g_unix_output_stream_get_close_fd(UnixOutputStream* this_);
int g_unix_output_stream_get_fd(UnixOutputStream* this_);
void g_unix_output_stream_set_close_fd(UnixOutputStream* this_, int close_fd);
UnixSocketAddress* /*new*/ g_unix_socket_address_new(char* path);
UnixSocketAddress* /*new*/ g_unix_socket_address_new_abstract(char* path, int path_len);
UnixSocketAddress* /*new*/ g_unix_socket_address_new_with_type(char* path, int path_len, UnixSocketAddressType type);
int g_unix_socket_address_abstract_names_supported();
UnixSocketAddressType g_unix_socket_address_get_address_type(UnixSocketAddress* this_);
int g_unix_socket_address_get_is_abstract(UnixSocketAddress* this_);
char* g_unix_socket_address_get_path(UnixSocketAddress* this_);
size_t g_unix_socket_address_get_path_len(UnixSocketAddress* this_);
Vfs* g_vfs_get_default();
Vfs* g_vfs_get_local();
File* /*new*/ g_vfs_get_file_for_path(Vfs* this_, char* path);
File* /*new*/ g_vfs_get_file_for_uri(Vfs* this_, char* uri);
char** g_vfs_get_supported_uri_schemes(Vfs* this_);
int g_vfs_is_active(Vfs* this_);
File* /*new*/ g_vfs_parse_name(Vfs* this_, char* parse_name);
int g_volume_can_eject(Volume* this_);
int g_volume_can_mount(Volume* this_);
void g_volume_eject(Volume* this_, MountUnmountFlags flags, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_volume_eject_finish(Volume* this_, AsyncResult* result, GLib2.Error** error);
void g_volume_eject_with_operation(Volume* this_, MountUnmountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_volume_eject_with_operation_finish(Volume* this_, AsyncResult* result, GLib2.Error** error);
char** /*new*/ g_volume_enumerate_identifiers(Volume* this_);
File* /*new*/ g_volume_get_activation_root(Volume* this_);
Drive* /*new*/ g_volume_get_drive(Volume* this_);
Icon* /*new*/ g_volume_get_icon(Volume* this_);
char* /*new*/ g_volume_get_identifier(Volume* this_, char* kind);
Mount* /*new*/ g_volume_get_mount(Volume* this_);
char* /*new*/ g_volume_get_name(Volume* this_);
char* /*new*/ g_volume_get_uuid(Volume* this_);
void g_volume_mount(Volume* this_, MountMountFlags flags, MountOperation* mount_operation, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
int g_volume_mount_finish(Volume* this_, AsyncResult* result, GLib2.Error** error);
int g_volume_should_automount(Volume* this_);
Volume* /*new*/ g_volume_monitor_adopt_orphan_mount(Mount* mount);
VolumeMonitor* /*new*/ g_volume_monitor_get();
GLib2.List* /*new*/ g_volume_monitor_get_connected_drives(VolumeMonitor* this_);
Mount* /*new*/ g_volume_monitor_get_mount_for_uuid(VolumeMonitor* this_, char* uuid);
GLib2.List* /*new*/ g_volume_monitor_get_mounts(VolumeMonitor* this_);
Volume* /*new*/ g_volume_monitor_get_volume_for_uuid(VolumeMonitor* this_, char* uuid);
GLib2.List* /*new*/ g_volume_monitor_get_volumes(VolumeMonitor* this_);
ZlibCompressor* /*new*/ g_zlib_compressor_new(ZlibCompressorFormat format, int level);
FileInfo* g_zlib_compressor_get_file_info(ZlibCompressor* this_);
void g_zlib_compressor_set_file_info(ZlibCompressor* this_, FileInfo* file_info=null);
ZlibDecompressor* /*new*/ g_zlib_decompressor_new(ZlibCompressorFormat format);
FileInfo* g_zlib_decompressor_get_file_info(ZlibDecompressor* this_);
void g_bus_get(BusType bus_type, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
DBusConnection* /*new*/ g_bus_get_finish(AsyncResult* res, GLib2.Error** error);
DBusConnection* /*new*/ g_bus_get_sync(BusType bus_type, Cancellable* cancellable, GLib2.Error** error);
uint g_bus_own_name(BusType bus_type, char* name, BusNameOwnerFlags flags, BusAcquiredCallback bus_acquired_handler, BusNameAcquiredCallback name_acquired_handler, BusNameLostCallback name_lost_handler, void* user_data, GLib2.DestroyNotify user_data_free_func);
uint g_bus_own_name_on_connection(DBusConnection* connection, char* name, BusNameOwnerFlags flags, BusNameAcquiredCallback name_acquired_handler, BusNameLostCallback name_lost_handler, void* user_data, GLib2.DestroyNotify user_data_free_func);
uint g_bus_own_name_on_connection_with_closures(DBusConnection* connection, char* name, BusNameOwnerFlags flags, GObject2.Closure* name_acquired_closure=null, GObject2.Closure* name_lost_closure=null);
uint g_bus_own_name_with_closures(BusType bus_type, char* name, BusNameOwnerFlags flags, GObject2.Closure* bus_acquired_closure=null, GObject2.Closure* name_acquired_closure=null, GObject2.Closure* name_lost_closure=null);
void g_bus_unown_name(uint owner_id);
void g_bus_unwatch_name(uint watcher_id);
uint g_bus_watch_name(BusType bus_type, char* name, BusNameWatcherFlags flags, BusNameAppearedCallback name_appeared_handler, BusNameVanishedCallback name_vanished_handler, void* user_data, GLib2.DestroyNotify user_data_free_func);
uint g_bus_watch_name_on_connection(DBusConnection* connection, char* name, BusNameWatcherFlags flags, BusNameAppearedCallback name_appeared_handler, BusNameVanishedCallback name_vanished_handler, void* user_data, GLib2.DestroyNotify user_data_free_func);
uint g_bus_watch_name_on_connection_with_closures(DBusConnection* connection, char* name, BusNameWatcherFlags flags, GObject2.Closure* name_appeared_closure=null, GObject2.Closure* name_vanished_closure=null);
uint g_bus_watch_name_with_closures(BusType bus_type, char* name, BusNameWatcherFlags flags, GObject2.Closure* name_appeared_closure=null, GObject2.Closure* name_vanished_closure=null);
int g_content_type_can_be_executable(char* type);
int g_content_type_equals(char* type1, char* type2);
char* /*new*/ g_content_type_from_mime_type(char* mime_type);
char* /*new*/ g_content_type_get_description(char* type);
Icon* /*new*/ g_content_type_get_icon(char* type);
char* /*new*/ g_content_type_get_mime_type(char* type);
char* /*new*/ g_content_type_guess(char* filename, ubyte* data, size_t data_size, /*out*/ int* result_uncertain=null);
char** /*new*/ g_content_type_guess_for_tree(File* root);
int g_content_type_is_a(char* type, char* supertype);
int g_content_type_is_unknown(char* type);
GLib2.List* /*new*/ g_content_types_get_registered();
char* /*new*/ g_dbus_address_get_for_bus_sync(BusType bus_type, Cancellable* cancellable, GLib2.Error** error);
void g_dbus_address_get_stream(char* address, Cancellable* cancellable, AsyncReadyCallback callback, void* user_data);
IOStream* /*new*/ g_dbus_address_get_stream_finish(AsyncResult* res, char** out_guid, GLib2.Error** error);
IOStream* /*new*/ g_dbus_address_get_stream_sync(char* address, char** out_guid, Cancellable* cancellable, GLib2.Error** error);
char* /*new*/ g_dbus_error_encode_gerror(GLib2.Error* error);
char* /*new*/ g_dbus_error_get_remote_error(GLib2.Error* error);
int g_dbus_error_is_remote_error(GLib2.Error* error);
GLib2.Error* /*new*/ g_dbus_error_new_for_dbus_error(char* dbus_error_name, char* dbus_error_message);
GLib2.Quark g_dbus_error_quark();
int g_dbus_error_register_error(GLib2.Quark error_domain, int error_code, char* dbus_error_name);
void g_dbus_error_register_error_domain(char* error_domain_quark_name, size_t* quark_volatile, DBusErrorEntry* entries, uint num_entries);
int g_dbus_error_strip_remote_error(GLib2.Error* error);
int g_dbus_error_unregister_error(GLib2.Quark error_domain, int error_code, char* dbus_error_name);
char* /*new*/ g_dbus_generate_guid();
GLib2.Variant* /*new*/ g_dbus_gvalue_to_gvariant(GObject2.Value* gvalue, GLib2.VariantType* type);
void g_dbus_gvariant_to_gvalue(GLib2.Variant* value, GObject2.Value* out_gvalue);
int g_dbus_is_address(char* string_);
int g_dbus_is_guid(char* string_);
int g_dbus_is_interface_name(char* string_);
int g_dbus_is_member_name(char* string_);
int g_dbus_is_name(char* string_);
int g_dbus_is_supported_address(char* string_, GLib2.Error** error);
int g_dbus_is_unique_name(char* string_);
IOErrorEnum g_io_error_from_errno(int err_no);
GLib2.Quark g_io_error_quark();
Type g_io_extension_get_type(IOExtension* extension);
GLib2.List* /*new*/ g_io_modules_load_all_in_directory(char* dirname);
GLib2.List* /*new*/ g_io_modules_load_all_in_directory_with_scope(char* dirname, IOModuleScope* scope_);
void g_io_modules_scan_all_in_directory(char* dirname);
void g_io_modules_scan_all_in_directory_with_scope(char* dirname, IOModuleScope* scope_);
void g_io_scheduler_cancel_all_jobs();
void g_io_scheduler_push_job(IOSchedulerJobFunc job_func, void* user_data, GLib2.DestroyNotify notify, int io_priority, Cancellable* cancellable=null);
GLib2.Source* /*new*/ g_pollable_source_new(GObject2.Object* pollable_stream);
GLib2.Quark g_resolver_error_quark();
void g_simple_async_report_error_in_idle(GObject2.Object* object, AsyncReadyCallback callback, void* user_data, GLib2.Quark domain, int code, char* format, ...);
void g_simple_async_report_gerror_in_idle(GObject2.Object* object, AsyncReadyCallback callback, void* user_data, GLib2.Error* error);
void g_simple_async_report_take_gerror_in_idle(GObject2.Object* object, AsyncReadyCallback callback, void* user_data, GLib2.Error* error);
GLib2.Quark g_tls_error_quark();
int g_unix_is_mount_path_system_internal(char* mount_path);
UnixMountEntry* /*new*/ g_unix_mount_at(char* mount_path, /*out*/ ulong* time_read=null);
int g_unix_mount_compare(UnixMountEntry* mount1, UnixMountEntry* mount2);
void g_unix_mount_free(UnixMountEntry* mount_entry);
char* g_unix_mount_get_device_path(UnixMountEntry* mount_entry);
char* g_unix_mount_get_fs_type(UnixMountEntry* mount_entry);
char* g_unix_mount_get_mount_path(UnixMountEntry* mount_entry);
int g_unix_mount_guess_can_eject(UnixMountEntry* mount_entry);
Icon* /*new*/ g_unix_mount_guess_icon(UnixMountEntry* mount_entry);
char* /*new*/ g_unix_mount_guess_name(UnixMountEntry* mount_entry);
int g_unix_mount_guess_should_display(UnixMountEntry* mount_entry);
int g_unix_mount_is_readonly(UnixMountEntry* mount_entry);
int g_unix_mount_is_system_internal(UnixMountEntry* mount_entry);
int g_unix_mount_points_changed_since(ulong time);
GLib2.List* /*new*/ g_unix_mount_points_get(/*out*/ ulong* time_read=null);
int g_unix_mounts_changed_since(ulong time);
GLib2.List* /*new*/ g_unix_mounts_get(/*out*/ ulong* time_read=null);
}