source: appstream-generator/build/girepo/gi/gio.d @ 4841

Last change on this file since 4841 was 4841, checked in by Juanma, 2 years ago

Initial release

File size: 160.8 KB
Line 
1/*
2 * Licensed under the GNU Lesser General Public License Version 3
3 *
4 * This library is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published by
6 * the Free Software Foundation, either version 3 of the license, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18// generated automatically - do not change
19
20
21module gi.gio;
22
23import std.stdio;
24import gi.giotypes;
25
26
27__gshared extern(C)
28{
29
30        // gio.Action
31
32        GType g_action_get_type();
33        int g_action_name_is_valid(const(char)* actionName);
34        int g_action_parse_detailed_name(const(char)* detailedName, char** actionName, GVariant** targetValue, GError** err);
35        char* g_action_print_detailed_name(const(char)* actionName, GVariant* targetValue);
36        void g_action_activate(GAction* action, GVariant* parameter);
37        void g_action_change_state(GAction* action, GVariant* value);
38        int g_action_get_enabled(GAction* action);
39        const(char)* g_action_get_name(GAction* action);
40        GVariantType* g_action_get_parameter_type(GAction* action);
41        GVariant* g_action_get_state(GAction* action);
42        GVariant* g_action_get_state_hint(GAction* action);
43        GVariantType* g_action_get_state_type(GAction* action);
44
45        // gio.ActionGroup
46
47        GType g_action_group_get_type();
48        void g_action_group_action_added(GActionGroup* actionGroup, const(char)* actionName);
49        void g_action_group_action_enabled_changed(GActionGroup* actionGroup, const(char)* actionName, int enabled);
50        void g_action_group_action_removed(GActionGroup* actionGroup, const(char)* actionName);
51        void g_action_group_action_state_changed(GActionGroup* actionGroup, const(char)* actionName, GVariant* state);
52        void g_action_group_activate_action(GActionGroup* actionGroup, const(char)* actionName, GVariant* parameter);
53        void g_action_group_change_action_state(GActionGroup* actionGroup, const(char)* actionName, GVariant* value);
54        int g_action_group_get_action_enabled(GActionGroup* actionGroup, const(char)* actionName);
55        GVariantType* g_action_group_get_action_parameter_type(GActionGroup* actionGroup, const(char)* actionName);
56        GVariant* g_action_group_get_action_state(GActionGroup* actionGroup, const(char)* actionName);
57        GVariant* g_action_group_get_action_state_hint(GActionGroup* actionGroup, const(char)* actionName);
58        GVariantType* g_action_group_get_action_state_type(GActionGroup* actionGroup, const(char)* actionName);
59        int g_action_group_has_action(GActionGroup* actionGroup, const(char)* actionName);
60        char** g_action_group_list_actions(GActionGroup* actionGroup);
61        int g_action_group_query_action(GActionGroup* actionGroup, const(char)* actionName, int* enabled, GVariantType** parameterType, GVariantType** stateType, GVariant** stateHint, GVariant** state);
62
63        // gio.ActionMap
64
65        GType g_action_map_get_type();
66        void g_action_map_add_action(GActionMap* actionMap, GAction* action);
67        void g_action_map_add_action_entries(GActionMap* actionMap, GActionEntry* entries, int nEntries, void* userData);
68        GAction* g_action_map_lookup_action(GActionMap* actionMap, const(char)* actionName);
69        void g_action_map_remove_action(GActionMap* actionMap, const(char)* actionName);
70
71        // gio.AppInfo
72
73        GType g_app_info_get_type();
74        GAppInfo* g_app_info_create_from_commandline(const(char)* commandline, const(char)* applicationName, GAppInfoCreateFlags flags, GError** err);
75        GList* g_app_info_get_all();
76        GList* g_app_info_get_all_for_type(const(char)* contentType);
77        GAppInfo* g_app_info_get_default_for_type(const(char)* contentType, int mustSupportUris);
78        GAppInfo* g_app_info_get_default_for_uri_scheme(const(char)* uriScheme);
79        GList* g_app_info_get_fallback_for_type(const(char)* contentType);
80        GList* g_app_info_get_recommended_for_type(const(char)* contentType);
81        int g_app_info_launch_default_for_uri(const(char)* uri, GAppLaunchContext* launchContext, GError** err);
82        void g_app_info_reset_type_associations(const(char)* contentType);
83        int g_app_info_add_supports_type(GAppInfo* appinfo, const(char)* contentType, GError** err);
84        int g_app_info_can_delete(GAppInfo* appinfo);
85        int g_app_info_can_remove_supports_type(GAppInfo* appinfo);
86        int g_app_info_delete(GAppInfo* appinfo);
87        GAppInfo* g_app_info_dup(GAppInfo* appinfo);
88        int g_app_info_equal(GAppInfo* appinfo1, GAppInfo* appinfo2);
89        const(char)* g_app_info_get_commandline(GAppInfo* appinfo);
90        const(char)* g_app_info_get_description(GAppInfo* appinfo);
91        const(char)* g_app_info_get_display_name(GAppInfo* appinfo);
92        const(char)* g_app_info_get_executable(GAppInfo* appinfo);
93        GIcon* g_app_info_get_icon(GAppInfo* appinfo);
94        const(char)* g_app_info_get_id(GAppInfo* appinfo);
95        const(char)* g_app_info_get_name(GAppInfo* appinfo);
96        char** g_app_info_get_supported_types(GAppInfo* appinfo);
97        int g_app_info_launch(GAppInfo* appinfo, GList* files, GAppLaunchContext* launchContext, GError** err);
98        int g_app_info_launch_uris(GAppInfo* appinfo, GList* uris, GAppLaunchContext* launchContext, GError** err);
99        int g_app_info_remove_supports_type(GAppInfo* appinfo, const(char)* contentType, GError** err);
100        int g_app_info_set_as_default_for_extension(GAppInfo* appinfo, const(char)* extension, GError** err);
101        int g_app_info_set_as_default_for_type(GAppInfo* appinfo, const(char)* contentType, GError** err);
102        int g_app_info_set_as_last_used_for_type(GAppInfo* appinfo, const(char)* contentType, GError** err);
103        int g_app_info_should_show(GAppInfo* appinfo);
104        int g_app_info_supports_files(GAppInfo* appinfo);
105        int g_app_info_supports_uris(GAppInfo* appinfo);
106
107        // gio.AppInfoMonitor
108
109        GType g_app_info_monitor_get_type();
110        GAppInfoMonitor* g_app_info_monitor_get();
111
112        // gio.AppLaunchContext
113
114        GType g_app_launch_context_get_type();
115        GAppLaunchContext* g_app_launch_context_new();
116        char* g_app_launch_context_get_display(GAppLaunchContext* context, GAppInfo* info, GList* files);
117        char** g_app_launch_context_get_environment(GAppLaunchContext* context);
118        char* g_app_launch_context_get_startup_notify_id(GAppLaunchContext* context, GAppInfo* info, GList* files);
119        void g_app_launch_context_launch_failed(GAppLaunchContext* context, const(char)* startupNotifyId);
120        void g_app_launch_context_setenv(GAppLaunchContext* context, const(char)* variable, const(char)* value);
121        void g_app_launch_context_unsetenv(GAppLaunchContext* context, const(char)* variable);
122
123        // gio.Application
124
125        GType g_application_get_type();
126        GApplication* g_application_new(const(char)* applicationId, GApplicationFlags flags);
127        GApplication* g_application_get_default();
128        int g_application_id_is_valid(const(char)* applicationId);
129        void g_application_activate(GApplication* application);
130        void g_application_add_main_option(GApplication* application, const(char)* longName, char shortName, GOptionFlags flags, GOptionArg arg, const(char)* description, const(char)* argDescription);
131        void g_application_add_main_option_entries(GApplication* application, GOptionEntry* entries);
132        void g_application_add_option_group(GApplication* application, GOptionGroup* group);
133        void g_application_bind_busy_property(GApplication* application, void* object, const(char)* property);
134        const(char)* g_application_get_application_id(GApplication* application);
135        GDBusConnection* g_application_get_dbus_connection(GApplication* application);
136        const(char)* g_application_get_dbus_object_path(GApplication* application);
137        GApplicationFlags g_application_get_flags(GApplication* application);
138        uint g_application_get_inactivity_timeout(GApplication* application);
139        int g_application_get_is_busy(GApplication* application);
140        int g_application_get_is_registered(GApplication* application);
141        int g_application_get_is_remote(GApplication* application);
142        const(char)* g_application_get_resource_base_path(GApplication* application);
143        void g_application_hold(GApplication* application);
144        void g_application_mark_busy(GApplication* application);
145        void g_application_open(GApplication* application, GFile** files, int nFiles, const(char)* hint);
146        void g_application_quit(GApplication* application);
147        int g_application_register(GApplication* application, GCancellable* cancellable, GError** err);
148        void g_application_release(GApplication* application);
149        int g_application_run(GApplication* application, int argc, char** argv);
150        void g_application_send_notification(GApplication* application, const(char)* id, GNotification* notification);
151        void g_application_set_action_group(GApplication* application, GActionGroup* actionGroup);
152        void g_application_set_application_id(GApplication* application, const(char)* applicationId);
153        void g_application_set_default(GApplication* application);
154        void g_application_set_flags(GApplication* application, GApplicationFlags flags);
155        void g_application_set_inactivity_timeout(GApplication* application, uint inactivityTimeout);
156        void g_application_set_resource_base_path(GApplication* application, const(char)* resourcePath);
157        void g_application_unbind_busy_property(GApplication* application, void* object, const(char)* property);
158        void g_application_unmark_busy(GApplication* application);
159        void g_application_withdraw_notification(GApplication* application, const(char)* id);
160
161        // gio.ApplicationCommandLine
162
163        GType g_application_command_line_get_type();
164        GFile* g_application_command_line_create_file_for_arg(GApplicationCommandLine* cmdline, const(char)* arg);
165        char** g_application_command_line_get_arguments(GApplicationCommandLine* cmdline, int* argc);
166        const(char)* g_application_command_line_get_cwd(GApplicationCommandLine* cmdline);
167        char** g_application_command_line_get_environ(GApplicationCommandLine* cmdline);
168        int g_application_command_line_get_exit_status(GApplicationCommandLine* cmdline);
169        int g_application_command_line_get_is_remote(GApplicationCommandLine* cmdline);
170        GVariantDict* g_application_command_line_get_options_dict(GApplicationCommandLine* cmdline);
171        GVariant* g_application_command_line_get_platform_data(GApplicationCommandLine* cmdline);
172        GInputStream* g_application_command_line_get_stdin(GApplicationCommandLine* cmdline);
173        const(char)* g_application_command_line_getenv(GApplicationCommandLine* cmdline, const(char)* name);
174        void g_application_command_line_print(GApplicationCommandLine* cmdline, const(char)* format, ... );
175        void g_application_command_line_printerr(GApplicationCommandLine* cmdline, const(char)* format, ... );
176        void g_application_command_line_set_exit_status(GApplicationCommandLine* cmdline, int exitStatus);
177
178        // gio.AsyncInitable
179
180        GType g_async_initable_get_type();
181        void g_async_initable_new_async(GType objectType, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData, const(char)* firstPropertyName, ... );
182        void g_async_initable_new_valist_async(GType objectType, const(char)* firstPropertyName, void* varArgs, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
183        void g_async_initable_newv_async(GType objectType, uint nParameters, GParameter* parameters, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
184        void g_async_initable_init_async(GAsyncInitable* initable, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
185        int g_async_initable_init_finish(GAsyncInitable* initable, GAsyncResult* res, GError** err);
186        GObject* g_async_initable_new_finish(GAsyncInitable* initable, GAsyncResult* res, GError** err);
187
188        // gio.AsyncResult
189
190        GType g_async_result_get_type();
191        GObject* g_async_result_get_source_object(GAsyncResult* res);
192        void* g_async_result_get_user_data(GAsyncResult* res);
193        int g_async_result_is_tagged(GAsyncResult* res, void* sourceTag);
194        int g_async_result_legacy_propagate_error(GAsyncResult* res, GError** err);
195
196        // gio.BufferedInputStream
197
198        GType g_buffered_input_stream_get_type();
199        GInputStream* g_buffered_input_stream_new(GInputStream* baseStream);
200        GInputStream* g_buffered_input_stream_new_sized(GInputStream* baseStream, size_t size);
201        ptrdiff_t g_buffered_input_stream_fill(GBufferedInputStream* stream, ptrdiff_t count, GCancellable* cancellable, GError** err);
202        void g_buffered_input_stream_fill_async(GBufferedInputStream* stream, ptrdiff_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
203        ptrdiff_t g_buffered_input_stream_fill_finish(GBufferedInputStream* stream, GAsyncResult* result, GError** err);
204        size_t g_buffered_input_stream_get_available(GBufferedInputStream* stream);
205        size_t g_buffered_input_stream_get_buffer_size(GBufferedInputStream* stream);
206        size_t g_buffered_input_stream_peek(GBufferedInputStream* stream, void* buffer, size_t offset, size_t count);
207        void* g_buffered_input_stream_peek_buffer(GBufferedInputStream* stream, size_t* count);
208        int g_buffered_input_stream_read_byte(GBufferedInputStream* stream, GCancellable* cancellable, GError** err);
209        void g_buffered_input_stream_set_buffer_size(GBufferedInputStream* stream, size_t size);
210
211        // gio.BufferedOutputStream
212
213        GType g_buffered_output_stream_get_type();
214        GOutputStream* g_buffered_output_stream_new(GOutputStream* baseStream);
215        GOutputStream* g_buffered_output_stream_new_sized(GOutputStream* baseStream, size_t size);
216        int g_buffered_output_stream_get_auto_grow(GBufferedOutputStream* stream);
217        size_t g_buffered_output_stream_get_buffer_size(GBufferedOutputStream* stream);
218        void g_buffered_output_stream_set_auto_grow(GBufferedOutputStream* stream, int autoGrow);
219        void g_buffered_output_stream_set_buffer_size(GBufferedOutputStream* stream, size_t size);
220
221        // gio.BytesIcon
222
223        GType g_bytes_icon_get_type();
224        GIcon* g_bytes_icon_new(GBytes* bytes);
225        GBytes* g_bytes_icon_get_bytes(GBytesIcon* icon);
226
227        // gio.Cancellable
228
229        GType g_cancellable_get_type();
230        GCancellable* g_cancellable_new();
231        GCancellable* g_cancellable_get_current();
232        void g_cancellable_cancel(GCancellable* cancellable);
233        gulong g_cancellable_connect(GCancellable* cancellable, GCallback callback, void* data, GDestroyNotify dataDestroyFunc);
234        void g_cancellable_disconnect(GCancellable* cancellable, gulong handlerId);
235        int g_cancellable_get_fd(GCancellable* cancellable);
236        int g_cancellable_is_cancelled(GCancellable* cancellable);
237        int g_cancellable_make_pollfd(GCancellable* cancellable, GPollFD* pollfd);
238        void g_cancellable_pop_current(GCancellable* cancellable);
239        void g_cancellable_push_current(GCancellable* cancellable);
240        void g_cancellable_release_fd(GCancellable* cancellable);
241        void g_cancellable_reset(GCancellable* cancellable);
242        int g_cancellable_set_error_if_cancelled(GCancellable* cancellable, GError** err);
243        GSource* g_cancellable_source_new(GCancellable* cancellable);
244
245        // gio.CharsetConverter
246
247        GType g_charset_converter_get_type();
248        GCharsetConverter* g_charset_converter_new(const(char)* toCharset, const(char)* fromCharset, GError** err);
249        uint g_charset_converter_get_num_fallbacks(GCharsetConverter* converter);
250        int g_charset_converter_get_use_fallback(GCharsetConverter* converter);
251        void g_charset_converter_set_use_fallback(GCharsetConverter* converter, int useFallback);
252
253        // gio.Converter
254
255        GType g_converter_get_type();
256        GConverterResult g_converter_convert(GConverter* converter, void* inbuf, size_t inbufSize, void* outbuf, size_t outbufSize, GConverterFlags flags, size_t* bytesRead, size_t* bytesWritten, GError** err);
257        void g_converter_reset(GConverter* converter);
258
259        // gio.ConverterInputStream
260
261        GType g_converter_input_stream_get_type();
262        GInputStream* g_converter_input_stream_new(GInputStream* baseStream, GConverter* converter);
263        GConverter* g_converter_input_stream_get_converter(GConverterInputStream* converterStream);
264
265        // gio.ConverterOutputStream
266
267        GType g_converter_output_stream_get_type();
268        GOutputStream* g_converter_output_stream_new(GOutputStream* baseStream, GConverter* converter);
269        GConverter* g_converter_output_stream_get_converter(GConverterOutputStream* converterStream);
270
271        // gio.Credentials
272
273        GType g_credentials_get_type();
274        GCredentials* g_credentials_new();
275        void* g_credentials_get_native(GCredentials* credentials, GCredentialsType nativeType);
276        pid_t g_credentials_get_unix_pid(GCredentials* credentials, GError** err);
277        uid_t g_credentials_get_unix_user(GCredentials* credentials, GError** err);
278        int g_credentials_is_same_user(GCredentials* credentials, GCredentials* otherCredentials, GError** err);
279        void g_credentials_set_native(GCredentials* credentials, GCredentialsType nativeType, void* native);
280        int g_credentials_set_unix_user(GCredentials* credentials, uid_t uid, GError** err);
281        char* g_credentials_to_string(GCredentials* credentials);
282
283        // gio.DBusActionGroup
284
285        GType g_dbus_action_group_get_type();
286        GDBusActionGroup* g_dbus_action_group_get(GDBusConnection* connection, const(char)* busName, const(char)* objectPath);
287
288        // gio.DBusAnnotationInfo
289
290        GType g_dbus_annotation_info_get_type();
291        GDBusAnnotationInfo* g_dbus_annotation_info_ref(GDBusAnnotationInfo* info);
292        void g_dbus_annotation_info_unref(GDBusAnnotationInfo* info);
293        const(char)* g_dbus_annotation_info_lookup(GDBusAnnotationInfo** annotations, const(char)* name);
294
295        // gio.DBusArgInfo
296
297        GType g_dbus_arg_info_get_type();
298        GDBusArgInfo* g_dbus_arg_info_ref(GDBusArgInfo* info);
299        void g_dbus_arg_info_unref(GDBusArgInfo* info);
300
301        // gio.DBusAuthObserver
302
303        GType g_dbus_auth_observer_get_type();
304        GDBusAuthObserver* g_dbus_auth_observer_new();
305        int g_dbus_auth_observer_allow_mechanism(GDBusAuthObserver* observer, const(char)* mechanism);
306        int g_dbus_auth_observer_authorize_authenticated_peer(GDBusAuthObserver* observer, GIOStream* stream, GCredentials* credentials);
307
308        // gio.DBusConnection
309
310        GType g_dbus_connection_get_type();
311        GDBusConnection* g_dbus_connection_new_finish(GAsyncResult* res, GError** err);
312        GDBusConnection* g_dbus_connection_new_for_address_finish(GAsyncResult* res, GError** err);
313        GDBusConnection* g_dbus_connection_new_for_address_sync(const(char)* address, GDBusConnectionFlags flags, GDBusAuthObserver* observer, GCancellable* cancellable, GError** err);
314        GDBusConnection* g_dbus_connection_new_sync(GIOStream* stream, const(char)* guid, GDBusConnectionFlags flags, GDBusAuthObserver* observer, GCancellable* cancellable, GError** err);
315        void g_dbus_connection_new(GIOStream* stream, const(char)* guid, GDBusConnectionFlags flags, GDBusAuthObserver* observer, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
316        void g_dbus_connection_new_for_address(const(char)* address, GDBusConnectionFlags flags, GDBusAuthObserver* observer, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
317        uint g_dbus_connection_add_filter(GDBusConnection* connection, GDBusMessageFilterFunction filterFunction, void* userData, GDestroyNotify userDataFreeFunc);
318        void g_dbus_connection_call(GDBusConnection* connection, const(char)* busName, const(char)* objectPath, const(char)* interfaceName, const(char)* methodName, GVariant* parameters, GVariantType* replyType, GDBusCallFlags flags, int timeoutMsec, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
319        GVariant* g_dbus_connection_call_finish(GDBusConnection* connection, GAsyncResult* res, GError** err);
320        GVariant* g_dbus_connection_call_sync(GDBusConnection* connection, const(char)* busName, const(char)* objectPath, const(char)* interfaceName, const(char)* methodName, GVariant* parameters, GVariantType* replyType, GDBusCallFlags flags, int timeoutMsec, GCancellable* cancellable, GError** err);
321        void g_dbus_connection_call_with_unix_fd_list(GDBusConnection* connection, const(char)* busName, const(char)* objectPath, const(char)* interfaceName, const(char)* methodName, GVariant* parameters, GVariantType* replyType, GDBusCallFlags flags, int timeoutMsec, GUnixFDList* fdList, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
322        GVariant* g_dbus_connection_call_with_unix_fd_list_finish(GDBusConnection* connection, GUnixFDList** outFdList, GAsyncResult* res, GError** err);
323        GVariant* g_dbus_connection_call_with_unix_fd_list_sync(GDBusConnection* connection, const(char)* busName, const(char)* objectPath, const(char)* interfaceName, const(char)* methodName, GVariant* parameters, GVariantType* replyType, GDBusCallFlags flags, int timeoutMsec, GUnixFDList* fdList, GUnixFDList** outFdList, GCancellable* cancellable, GError** err);
324        void g_dbus_connection_close(GDBusConnection* connection, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
325        int g_dbus_connection_close_finish(GDBusConnection* connection, GAsyncResult* res, GError** err);
326        int g_dbus_connection_close_sync(GDBusConnection* connection, GCancellable* cancellable, GError** err);
327        int g_dbus_connection_emit_signal(GDBusConnection* connection, const(char)* destinationBusName, const(char)* objectPath, const(char)* interfaceName, const(char)* signalName, GVariant* parameters, GError** err);
328        uint g_dbus_connection_export_action_group(GDBusConnection* connection, const(char)* objectPath, GActionGroup* actionGroup, GError** err);
329        uint g_dbus_connection_export_menu_model(GDBusConnection* connection, const(char)* objectPath, GMenuModel* menu, GError** err);
330        void g_dbus_connection_flush(GDBusConnection* connection, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
331        int g_dbus_connection_flush_finish(GDBusConnection* connection, GAsyncResult* res, GError** err);
332        int g_dbus_connection_flush_sync(GDBusConnection* connection, GCancellable* cancellable, GError** err);
333        GDBusCapabilityFlags g_dbus_connection_get_capabilities(GDBusConnection* connection);
334        int g_dbus_connection_get_exit_on_close(GDBusConnection* connection);
335        const(char)* g_dbus_connection_get_guid(GDBusConnection* connection);
336        uint g_dbus_connection_get_last_serial(GDBusConnection* connection);
337        GCredentials* g_dbus_connection_get_peer_credentials(GDBusConnection* connection);
338        GIOStream* g_dbus_connection_get_stream(GDBusConnection* connection);
339        const(char)* g_dbus_connection_get_unique_name(GDBusConnection* connection);
340        int g_dbus_connection_is_closed(GDBusConnection* connection);
341        uint g_dbus_connection_register_object(GDBusConnection* connection, const(char)* objectPath, GDBusInterfaceInfo* interfaceInfo, GDBusInterfaceVTable* vtable, void* userData, GDestroyNotify userDataFreeFunc, GError** err);
342        uint g_dbus_connection_register_object_with_closures(GDBusConnection* connection, const(char)* objectPath, GDBusInterfaceInfo* interfaceInfo, GClosure* methodCallClosure, GClosure* getPropertyClosure, GClosure* setPropertyClosure, GError** err);
343        uint g_dbus_connection_register_subtree(GDBusConnection* connection, const(char)* objectPath, GDBusSubtreeVTable* vtable, GDBusSubtreeFlags flags, void* userData, GDestroyNotify userDataFreeFunc, GError** err);
344        void g_dbus_connection_remove_filter(GDBusConnection* connection, uint filterId);
345        int g_dbus_connection_send_message(GDBusConnection* connection, GDBusMessage* message, GDBusSendMessageFlags flags, uint* outSerial, GError** err);
346        void g_dbus_connection_send_message_with_reply(GDBusConnection* connection, GDBusMessage* message, GDBusSendMessageFlags flags, int timeoutMsec, uint* outSerial, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
347        GDBusMessage* g_dbus_connection_send_message_with_reply_finish(GDBusConnection* connection, GAsyncResult* res, GError** err);
348        GDBusMessage* g_dbus_connection_send_message_with_reply_sync(GDBusConnection* connection, GDBusMessage* message, GDBusSendMessageFlags flags, int timeoutMsec, uint* outSerial, GCancellable* cancellable, GError** err);
349        void g_dbus_connection_set_exit_on_close(GDBusConnection* connection, int exitOnClose);
350        uint g_dbus_connection_signal_subscribe(GDBusConnection* connection, const(char)* sender, const(char)* interfaceName, const(char)* member, const(char)* objectPath, const(char)* arg0, GDBusSignalFlags flags, GDBusSignalCallback callback, void* userData, GDestroyNotify userDataFreeFunc);
351        void g_dbus_connection_signal_unsubscribe(GDBusConnection* connection, uint subscriptionId);
352        void g_dbus_connection_start_message_processing(GDBusConnection* connection);
353        void g_dbus_connection_unexport_action_group(GDBusConnection* connection, uint exportId);
354        void g_dbus_connection_unexport_menu_model(GDBusConnection* connection, uint exportId);
355        int g_dbus_connection_unregister_object(GDBusConnection* connection, uint registrationId);
356        int g_dbus_connection_unregister_subtree(GDBusConnection* connection, uint registrationId);
357        void g_bus_get(GBusType busType, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
358        GDBusConnection* g_bus_get_finish(GAsyncResult* res, GError** err);
359        GDBusConnection* g_bus_get_sync(GBusType busType, GCancellable* cancellable, GError** err);
360
361        // gio.DBusInterface
362
363        GType g_dbus_interface_get_type();
364        GDBusObject* g_dbus_interface_dup_object(GDBusInterface* iface);
365        GDBusInterfaceInfo* g_dbus_interface_get_info(GDBusInterface* iface);
366        GDBusObject* g_dbus_interface_get_object(GDBusInterface* iface);
367        void g_dbus_interface_set_object(GDBusInterface* iface, GDBusObject* object);
368
369        // gio.DBusInterfaceInfo
370
371        GType g_dbus_interface_info_get_type();
372        void g_dbus_interface_info_cache_build(GDBusInterfaceInfo* info);
373        void g_dbus_interface_info_cache_release(GDBusInterfaceInfo* info);
374        void g_dbus_interface_info_generate_xml(GDBusInterfaceInfo* info, uint indent, GString* stringBuilder);
375        GDBusMethodInfo* g_dbus_interface_info_lookup_method(GDBusInterfaceInfo* info, const(char)* name);
376        GDBusPropertyInfo* g_dbus_interface_info_lookup_property(GDBusInterfaceInfo* info, const(char)* name);
377        GDBusSignalInfo* g_dbus_interface_info_lookup_signal(GDBusInterfaceInfo* info, const(char)* name);
378        GDBusInterfaceInfo* g_dbus_interface_info_ref(GDBusInterfaceInfo* info);
379        void g_dbus_interface_info_unref(GDBusInterfaceInfo* info);
380
381        // gio.DBusInterfaceSkeleton
382
383        GType g_dbus_interface_skeleton_get_type();
384        int g_dbus_interface_skeleton_export(GDBusInterfaceSkeleton* iface, GDBusConnection* connection, const(char)* objectPath, GError** err);
385        void g_dbus_interface_skeleton_flush(GDBusInterfaceSkeleton* iface);
386        GDBusConnection* g_dbus_interface_skeleton_get_connection(GDBusInterfaceSkeleton* iface);
387        GList* g_dbus_interface_skeleton_get_connections(GDBusInterfaceSkeleton* iface);
388        GDBusInterfaceSkeletonFlags g_dbus_interface_skeleton_get_flags(GDBusInterfaceSkeleton* iface);
389        GDBusInterfaceInfo* g_dbus_interface_skeleton_get_info(GDBusInterfaceSkeleton* iface);
390        const(char)* g_dbus_interface_skeleton_get_object_path(GDBusInterfaceSkeleton* iface);
391        GVariant* g_dbus_interface_skeleton_get_properties(GDBusInterfaceSkeleton* iface);
392        GDBusInterfaceVTable* g_dbus_interface_skeleton_get_vtable(GDBusInterfaceSkeleton* iface);
393        int g_dbus_interface_skeleton_has_connection(GDBusInterfaceSkeleton* iface, GDBusConnection* connection);
394        void g_dbus_interface_skeleton_set_flags(GDBusInterfaceSkeleton* iface, GDBusInterfaceSkeletonFlags flags);
395        void g_dbus_interface_skeleton_unexport(GDBusInterfaceSkeleton* iface);
396        void g_dbus_interface_skeleton_unexport_from_connection(GDBusInterfaceSkeleton* iface, GDBusConnection* connection);
397
398        // gio.DBusMenuModel
399
400        GType g_dbus_menu_model_get_type();
401        GDBusMenuModel* g_dbus_menu_model_get(GDBusConnection* connection, const(char)* busName, const(char)* objectPath);
402
403        // gio.DBusMessage
404
405        GType g_dbus_message_get_type();
406        GDBusMessage* g_dbus_message_new();
407        GDBusMessage* g_dbus_message_new_from_blob(char* blob, size_t blobLen, GDBusCapabilityFlags capabilities, GError** err);
408        GDBusMessage* g_dbus_message_new_method_call(const(char)* name, const(char)* path, const(char)* iface, const(char)* method);
409        GDBusMessage* g_dbus_message_new_signal(const(char)* path, const(char)* iface, const(char)* signal);
410        ptrdiff_t g_dbus_message_bytes_needed(char* blob, size_t blobLen, GError** err);
411        GDBusMessage* g_dbus_message_copy(GDBusMessage* message, GError** err);
412        const(char)* g_dbus_message_get_arg0(GDBusMessage* message);
413        GVariant* g_dbus_message_get_body(GDBusMessage* message);
414        GDBusMessageByteOrder g_dbus_message_get_byte_order(GDBusMessage* message);
415        const(char)* g_dbus_message_get_destination(GDBusMessage* message);
416        const(char)* g_dbus_message_get_error_name(GDBusMessage* message);
417        GDBusMessageFlags g_dbus_message_get_flags(GDBusMessage* message);
418        GVariant* g_dbus_message_get_header(GDBusMessage* message, GDBusMessageHeaderField headerField);
419        char* g_dbus_message_get_header_fields(GDBusMessage* message);
420        const(char)* g_dbus_message_get_interface(GDBusMessage* message);
421        int g_dbus_message_get_locked(GDBusMessage* message);
422        const(char)* g_dbus_message_get_member(GDBusMessage* message);
423        GDBusMessageType g_dbus_message_get_message_type(GDBusMessage* message);
424        uint g_dbus_message_get_num_unix_fds(GDBusMessage* message);
425        const(char)* g_dbus_message_get_path(GDBusMessage* message);
426        uint g_dbus_message_get_reply_serial(GDBusMessage* message);
427        const(char)* g_dbus_message_get_sender(GDBusMessage* message);
428        uint g_dbus_message_get_serial(GDBusMessage* message);
429        const(char)* g_dbus_message_get_signature(GDBusMessage* message);
430        GUnixFDList* g_dbus_message_get_unix_fd_list(GDBusMessage* message);
431        void g_dbus_message_lock(GDBusMessage* message);
432        GDBusMessage* g_dbus_message_new_method_error(GDBusMessage* methodCallMessage, const(char)* errorName, const(char)* errorMessageFormat, ... );
433        GDBusMessage* g_dbus_message_new_method_error_literal(GDBusMessage* methodCallMessage, const(char)* errorName, const(char)* errorMessage);
434        GDBusMessage* g_dbus_message_new_method_error_valist(GDBusMessage* methodCallMessage, const(char)* errorName, const(char)* errorMessageFormat, void* varArgs);
435        GDBusMessage* g_dbus_message_new_method_reply(GDBusMessage* methodCallMessage);
436        char* g_dbus_message_print(GDBusMessage* message, uint indent);
437        void g_dbus_message_set_body(GDBusMessage* message, GVariant* bod);
438        void g_dbus_message_set_byte_order(GDBusMessage* message, GDBusMessageByteOrder byteOrder);
439        void g_dbus_message_set_destination(GDBusMessage* message, const(char)* value);
440        void g_dbus_message_set_error_name(GDBusMessage* message, const(char)* value);
441        void g_dbus_message_set_flags(GDBusMessage* message, GDBusMessageFlags flags);
442        void g_dbus_message_set_header(GDBusMessage* message, GDBusMessageHeaderField headerField, GVariant* value);
443        void g_dbus_message_set_interface(GDBusMessage* message, const(char)* value);
444        void g_dbus_message_set_member(GDBusMessage* message, const(char)* value);
445        void g_dbus_message_set_message_type(GDBusMessage* message, GDBusMessageType type);
446        void g_dbus_message_set_num_unix_fds(GDBusMessage* message, uint value);
447        void g_dbus_message_set_path(GDBusMessage* message, const(char)* value);
448        void g_dbus_message_set_reply_serial(GDBusMessage* message, uint value);
449        void g_dbus_message_set_sender(GDBusMessage* message, const(char)* value);
450        void g_dbus_message_set_serial(GDBusMessage* message, uint serial);
451        void g_dbus_message_set_signature(GDBusMessage* message, const(char)* value);
452        void g_dbus_message_set_unix_fd_list(GDBusMessage* message, GUnixFDList* fdList);
453        char* g_dbus_message_to_blob(GDBusMessage* message, size_t* outSize, GDBusCapabilityFlags capabilities, GError** err);
454        int g_dbus_message_to_gerror(GDBusMessage* message, GError** err);
455
456        // gio.DBusMethodInfo
457
458        GType g_dbus_method_info_get_type();
459        GDBusMethodInfo* g_dbus_method_info_ref(GDBusMethodInfo* info);
460        void g_dbus_method_info_unref(GDBusMethodInfo* info);
461
462        // gio.DBusMethodInvocation
463
464        GType g_dbus_method_invocation_get_type();
465        GDBusConnection* g_dbus_method_invocation_get_connection(GDBusMethodInvocation* invocation);
466        const(char)* g_dbus_method_invocation_get_interface_name(GDBusMethodInvocation* invocation);
467        GDBusMessage* g_dbus_method_invocation_get_message(GDBusMethodInvocation* invocation);
468        GDBusMethodInfo* g_dbus_method_invocation_get_method_info(GDBusMethodInvocation* invocation);
469        const(char)* g_dbus_method_invocation_get_method_name(GDBusMethodInvocation* invocation);
470        const(char)* g_dbus_method_invocation_get_object_path(GDBusMethodInvocation* invocation);
471        GVariant* g_dbus_method_invocation_get_parameters(GDBusMethodInvocation* invocation);
472        GDBusPropertyInfo* g_dbus_method_invocation_get_property_info(GDBusMethodInvocation* invocation);
473        const(char)* g_dbus_method_invocation_get_sender(GDBusMethodInvocation* invocation);
474        void* g_dbus_method_invocation_get_user_data(GDBusMethodInvocation* invocation);
475        void g_dbus_method_invocation_return_dbus_error(GDBusMethodInvocation* invocation, const(char)* errorName, const(char)* errorMessage);
476        void g_dbus_method_invocation_return_error(GDBusMethodInvocation* invocation, GQuark domain, int code, const(char)* format, ... );
477        void g_dbus_method_invocation_return_error_literal(GDBusMethodInvocation* invocation, GQuark domain, int code, const(char)* message);
478        void g_dbus_method_invocation_return_error_valist(GDBusMethodInvocation* invocation, GQuark domain, int code, const(char)* format, void* varArgs);
479        void g_dbus_method_invocation_return_gerror(GDBusMethodInvocation* invocation, GError* error);
480        void g_dbus_method_invocation_return_value(GDBusMethodInvocation* invocation, GVariant* parameters);
481        void g_dbus_method_invocation_return_value_with_unix_fd_list(GDBusMethodInvocation* invocation, GVariant* parameters, GUnixFDList* fdList);
482        void g_dbus_method_invocation_take_error(GDBusMethodInvocation* invocation, GError* error);
483
484        // gio.DBusNodeInfo
485
486        GType g_dbus_node_info_get_type();
487        GDBusNodeInfo* g_dbus_node_info_new_for_xml(const(char)* xmlData, GError** err);
488        void g_dbus_node_info_generate_xml(GDBusNodeInfo* info, uint indent, GString* stringBuilder);
489        GDBusInterfaceInfo* g_dbus_node_info_lookup_interface(GDBusNodeInfo* info, const(char)* name);
490        GDBusNodeInfo* g_dbus_node_info_ref(GDBusNodeInfo* info);
491        void g_dbus_node_info_unref(GDBusNodeInfo* info);
492
493        // gio.DBusObject
494
495        GType g_dbus_object_get_type();
496        GDBusInterface* g_dbus_object_get_interface(GDBusObject* object, const(char)* interfaceName);
497        GList* g_dbus_object_get_interfaces(GDBusObject* object);
498        const(char)* g_dbus_object_get_object_path(GDBusObject* object);
499
500        // gio.DBusObjectManager
501
502        GType g_dbus_object_manager_get_type();
503        GDBusInterface* g_dbus_object_manager_get_interface(GDBusObjectManager* manager, const(char)* objectPath, const(char)* interfaceName);
504        GDBusObject* g_dbus_object_manager_get_object(GDBusObjectManager* manager, const(char)* objectPath);
505        const(char)* g_dbus_object_manager_get_object_path(GDBusObjectManager* manager);
506        GList* g_dbus_object_manager_get_objects(GDBusObjectManager* manager);
507
508        // gio.DBusObjectManagerClient
509
510        GType g_dbus_object_manager_client_get_type();
511        GDBusObjectManager* g_dbus_object_manager_client_new_finish(GAsyncResult* res, GError** err);
512        GDBusObjectManager* g_dbus_object_manager_client_new_for_bus_finish(GAsyncResult* res, GError** err);
513        GDBusObjectManager* g_dbus_object_manager_client_new_for_bus_sync(GBusType busType, GDBusObjectManagerClientFlags flags, const(char)* name, const(char)* objectPath, GDBusProxyTypeFunc getProxyTypeFunc, void* getProxyTypeUserData, GDestroyNotify getProxyTypeDestroyNotify, GCancellable* cancellable, GError** err);
514        GDBusObjectManager* g_dbus_object_manager_client_new_sync(GDBusConnection* connection, GDBusObjectManagerClientFlags flags, const(char)* name, const(char)* objectPath, GDBusProxyTypeFunc getProxyTypeFunc, void* getProxyTypeUserData, GDestroyNotify getProxyTypeDestroyNotify, GCancellable* cancellable, GError** err);
515        void g_dbus_object_manager_client_new(GDBusConnection* connection, GDBusObjectManagerClientFlags flags, const(char)* name, const(char)* objectPath, GDBusProxyTypeFunc getProxyTypeFunc, void* getProxyTypeUserData, GDestroyNotify getProxyTypeDestroyNotify, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
516        void g_dbus_object_manager_client_new_for_bus(GBusType busType, GDBusObjectManagerClientFlags flags, const(char)* name, const(char)* objectPath, GDBusProxyTypeFunc getProxyTypeFunc, void* getProxyTypeUserData, GDestroyNotify getProxyTypeDestroyNotify, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
517        GDBusConnection* g_dbus_object_manager_client_get_connection(GDBusObjectManagerClient* manager);
518        GDBusObjectManagerClientFlags g_dbus_object_manager_client_get_flags(GDBusObjectManagerClient* manager);
519        const(char)* g_dbus_object_manager_client_get_name(GDBusObjectManagerClient* manager);
520        char* g_dbus_object_manager_client_get_name_owner(GDBusObjectManagerClient* manager);
521
522        // gio.DBusObjectManagerServer
523
524        GType g_dbus_object_manager_server_get_type();
525        GDBusObjectManagerServer* g_dbus_object_manager_server_new(const(char)* objectPath);
526        void g_dbus_object_manager_server_export(GDBusObjectManagerServer* manager, GDBusObjectSkeleton* object);
527        void g_dbus_object_manager_server_export_uniquely(GDBusObjectManagerServer* manager, GDBusObjectSkeleton* object);
528        GDBusConnection* g_dbus_object_manager_server_get_connection(GDBusObjectManagerServer* manager);
529        int g_dbus_object_manager_server_is_exported(GDBusObjectManagerServer* manager, GDBusObjectSkeleton* object);
530        void g_dbus_object_manager_server_set_connection(GDBusObjectManagerServer* manager, GDBusConnection* connection);
531        int g_dbus_object_manager_server_unexport(GDBusObjectManagerServer* manager, const(char)* objectPath);
532
533        // gio.DBusObjectProxy
534
535        GType g_dbus_object_proxy_get_type();
536        GDBusObjectProxy* g_dbus_object_proxy_new(GDBusConnection* connection, const(char)* objectPath);
537        GDBusConnection* g_dbus_object_proxy_get_connection(GDBusObjectProxy* proxy);
538
539        // gio.DBusObjectSkeleton
540
541        GType g_dbus_object_skeleton_get_type();
542        GDBusObjectSkeleton* g_dbus_object_skeleton_new(const(char)* objectPath);
543        void g_dbus_object_skeleton_add_interface(GDBusObjectSkeleton* object, GDBusInterfaceSkeleton* iface);
544        void g_dbus_object_skeleton_flush(GDBusObjectSkeleton* object);
545        void g_dbus_object_skeleton_remove_interface(GDBusObjectSkeleton* object, GDBusInterfaceSkeleton* iface);
546        void g_dbus_object_skeleton_remove_interface_by_name(GDBusObjectSkeleton* object, const(char)* interfaceName);
547        void g_dbus_object_skeleton_set_object_path(GDBusObjectSkeleton* object, const(char)* objectPath);
548
549        // gio.DBusPropertyInfo
550
551        GType g_dbus_property_info_get_type();
552        GDBusPropertyInfo* g_dbus_property_info_ref(GDBusPropertyInfo* info);
553        void g_dbus_property_info_unref(GDBusPropertyInfo* info);
554
555        // gio.DBusProxy
556
557        GType g_dbus_proxy_get_type();
558        GDBusProxy* g_dbus_proxy_new_finish(GAsyncResult* res, GError** err);
559        GDBusProxy* g_dbus_proxy_new_for_bus_finish(GAsyncResult* res, GError** err);
560        GDBusProxy* g_dbus_proxy_new_for_bus_sync(GBusType busType, GDBusProxyFlags flags, GDBusInterfaceInfo* info, const(char)* name, const(char)* objectPath, const(char)* interfaceName, GCancellable* cancellable, GError** err);
561        GDBusProxy* g_dbus_proxy_new_sync(GDBusConnection* connection, GDBusProxyFlags flags, GDBusInterfaceInfo* info, const(char)* name, const(char)* objectPath, const(char)* interfaceName, GCancellable* cancellable, GError** err);
562        void g_dbus_proxy_new(GDBusConnection* connection, GDBusProxyFlags flags, GDBusInterfaceInfo* info, const(char)* name, const(char)* objectPath, const(char)* interfaceName, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
563        void g_dbus_proxy_new_for_bus(GBusType busType, GDBusProxyFlags flags, GDBusInterfaceInfo* info, const(char)* name, const(char)* objectPath, const(char)* interfaceName, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
564        void g_dbus_proxy_call(GDBusProxy* proxy, const(char)* methodName, GVariant* parameters, GDBusCallFlags flags, int timeoutMsec, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
565        GVariant* g_dbus_proxy_call_finish(GDBusProxy* proxy, GAsyncResult* res, GError** err);
566        GVariant* g_dbus_proxy_call_sync(GDBusProxy* proxy, const(char)* methodName, GVariant* parameters, GDBusCallFlags flags, int timeoutMsec, GCancellable* cancellable, GError** err);
567        void g_dbus_proxy_call_with_unix_fd_list(GDBusProxy* proxy, const(char)* methodName, GVariant* parameters, GDBusCallFlags flags, int timeoutMsec, GUnixFDList* fdList, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
568        GVariant* g_dbus_proxy_call_with_unix_fd_list_finish(GDBusProxy* proxy, GUnixFDList** outFdList, GAsyncResult* res, GError** err);
569        GVariant* g_dbus_proxy_call_with_unix_fd_list_sync(GDBusProxy* proxy, const(char)* methodName, GVariant* parameters, GDBusCallFlags flags, int timeoutMsec, GUnixFDList* fdList, GUnixFDList** outFdList, GCancellable* cancellable, GError** err);
570        GVariant* g_dbus_proxy_get_cached_property(GDBusProxy* proxy, const(char)* propertyName);
571        char** g_dbus_proxy_get_cached_property_names(GDBusProxy* proxy);
572        GDBusConnection* g_dbus_proxy_get_connection(GDBusProxy* proxy);
573        int g_dbus_proxy_get_default_timeout(GDBusProxy* proxy);
574        GDBusProxyFlags g_dbus_proxy_get_flags(GDBusProxy* proxy);
575        GDBusInterfaceInfo* g_dbus_proxy_get_interface_info(GDBusProxy* proxy);
576        const(char)* g_dbus_proxy_get_interface_name(GDBusProxy* proxy);
577        const(char)* g_dbus_proxy_get_name(GDBusProxy* proxy);
578        char* g_dbus_proxy_get_name_owner(GDBusProxy* proxy);
579        const(char)* g_dbus_proxy_get_object_path(GDBusProxy* proxy);
580        void g_dbus_proxy_set_cached_property(GDBusProxy* proxy, const(char)* propertyName, GVariant* value);
581        void g_dbus_proxy_set_default_timeout(GDBusProxy* proxy, int timeoutMsec);
582        void g_dbus_proxy_set_interface_info(GDBusProxy* proxy, GDBusInterfaceInfo* info);
583
584        // gio.DBusServer
585
586        GType g_dbus_server_get_type();
587        GDBusServer* g_dbus_server_new_sync(const(char)* address, GDBusServerFlags flags, const(char)* guid, GDBusAuthObserver* observer, GCancellable* cancellable, GError** err);
588        const(char)* g_dbus_server_get_client_address(GDBusServer* server);
589        GDBusServerFlags g_dbus_server_get_flags(GDBusServer* server);
590        const(char)* g_dbus_server_get_guid(GDBusServer* server);
591        int g_dbus_server_is_active(GDBusServer* server);
592        void g_dbus_server_start(GDBusServer* server);
593        void g_dbus_server_stop(GDBusServer* server);
594
595        // gio.DBusSignalInfo
596
597        GType g_dbus_signal_info_get_type();
598        GDBusSignalInfo* g_dbus_signal_info_ref(GDBusSignalInfo* info);
599        void g_dbus_signal_info_unref(GDBusSignalInfo* info);
600
601        // gio.DataInputStream
602
603        GType g_data_input_stream_get_type();
604        GDataInputStream* g_data_input_stream_new(GInputStream* baseStream);
605        GDataStreamByteOrder g_data_input_stream_get_byte_order(GDataInputStream* stream);
606        GDataStreamNewlineType g_data_input_stream_get_newline_type(GDataInputStream* stream);
607        char g_data_input_stream_read_byte(GDataInputStream* stream, GCancellable* cancellable, GError** err);
608        short g_data_input_stream_read_int16(GDataInputStream* stream, GCancellable* cancellable, GError** err);
609        int g_data_input_stream_read_int32(GDataInputStream* stream, GCancellable* cancellable, GError** err);
610        long g_data_input_stream_read_int64(GDataInputStream* stream, GCancellable* cancellable, GError** err);
611        char* g_data_input_stream_read_line(GDataInputStream* stream, size_t* length, GCancellable* cancellable, GError** err);
612        void g_data_input_stream_read_line_async(GDataInputStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
613        char* g_data_input_stream_read_line_finish(GDataInputStream* stream, GAsyncResult* result, size_t* length, GError** err);
614        char* g_data_input_stream_read_line_finish_utf8(GDataInputStream* stream, GAsyncResult* result, size_t* length, GError** err);
615        char* g_data_input_stream_read_line_utf8(GDataInputStream* stream, size_t* length, GCancellable* cancellable, GError** err);
616        ushort g_data_input_stream_read_uint16(GDataInputStream* stream, GCancellable* cancellable, GError** err);
617        uint g_data_input_stream_read_uint32(GDataInputStream* stream, GCancellable* cancellable, GError** err);
618        ulong g_data_input_stream_read_uint64(GDataInputStream* stream, GCancellable* cancellable, GError** err);
619        char* g_data_input_stream_read_until(GDataInputStream* stream, const(char)* stopChars, size_t* length, GCancellable* cancellable, GError** err);
620        void g_data_input_stream_read_until_async(GDataInputStream* stream, const(char)* stopChars, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
621        char* g_data_input_stream_read_until_finish(GDataInputStream* stream, GAsyncResult* result, size_t* length, GError** err);
622        char* g_data_input_stream_read_upto(GDataInputStream* stream, const(char)* stopChars, ptrdiff_t stopCharsLen, size_t* length, GCancellable* cancellable, GError** err);
623        void g_data_input_stream_read_upto_async(GDataInputStream* stream, const(char)* stopChars, ptrdiff_t stopCharsLen, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
624        char* g_data_input_stream_read_upto_finish(GDataInputStream* stream, GAsyncResult* result, size_t* length, GError** err);
625        void g_data_input_stream_set_byte_order(GDataInputStream* stream, GDataStreamByteOrder order);
626        void g_data_input_stream_set_newline_type(GDataInputStream* stream, GDataStreamNewlineType type);
627
628        // gio.DataOutputStream
629
630        GType g_data_output_stream_get_type();
631        GDataOutputStream* g_data_output_stream_new(GOutputStream* baseStream);
632        GDataStreamByteOrder g_data_output_stream_get_byte_order(GDataOutputStream* stream);
633        int g_data_output_stream_put_byte(GDataOutputStream* stream, char data, GCancellable* cancellable, GError** err);
634        int g_data_output_stream_put_int16(GDataOutputStream* stream, short data, GCancellable* cancellable, GError** err);
635        int g_data_output_stream_put_int32(GDataOutputStream* stream, int data, GCancellable* cancellable, GError** err);
636        int g_data_output_stream_put_int64(GDataOutputStream* stream, long data, GCancellable* cancellable, GError** err);
637        int g_data_output_stream_put_string(GDataOutputStream* stream, const(char)* str, GCancellable* cancellable, GError** err);
638        int g_data_output_stream_put_uint16(GDataOutputStream* stream, ushort data, GCancellable* cancellable, GError** err);
639        int g_data_output_stream_put_uint32(GDataOutputStream* stream, uint data, GCancellable* cancellable, GError** err);
640        int g_data_output_stream_put_uint64(GDataOutputStream* stream, ulong data, GCancellable* cancellable, GError** err);
641        void g_data_output_stream_set_byte_order(GDataOutputStream* stream, GDataStreamByteOrder order);
642
643        // gio.DatagramBased
644
645        GType g_datagram_based_get_type();
646        GIOCondition g_datagram_based_condition_check(GDatagramBased* datagramBased, GIOCondition condition);
647        int g_datagram_based_condition_wait(GDatagramBased* datagramBased, GIOCondition condition, long timeout, GCancellable* cancellable, GError** err);
648        GSource* g_datagram_based_create_source(GDatagramBased* datagramBased, GIOCondition condition, GCancellable* cancellable);
649        int g_datagram_based_receive_messages(GDatagramBased* datagramBased, GInputMessage* messages, uint numMessages, int flags, long timeout, GCancellable* cancellable, GError** err);
650        int g_datagram_based_send_messages(GDatagramBased* datagramBased, GOutputMessage* messages, uint numMessages, int flags, long timeout, GCancellable* cancellable, GError** err);
651
652        // gio.DesktopAppInfo
653
654        GType g_desktop_app_info_get_type();
655        GDesktopAppInfo* g_desktop_app_info_new(const(char)* desktopId);
656        GDesktopAppInfo* g_desktop_app_info_new_from_filename(const(char)* filename);
657        GDesktopAppInfo* g_desktop_app_info_new_from_keyfile(GKeyFile* keyFile);
658        GList* g_desktop_app_info_get_implementations(const(char)* iface);
659        char*** g_desktop_app_info_search(const(char)* searchString);
660        void g_desktop_app_info_set_desktop_env(const(char)* desktopEnv);
661        char* g_desktop_app_info_get_action_name(GDesktopAppInfo* info, const(char)* actionName);
662        int g_desktop_app_info_get_boolean(GDesktopAppInfo* info, const(char)* key);
663        const(char)* g_desktop_app_info_get_categories(GDesktopAppInfo* info);
664        const(char)* g_desktop_app_info_get_filename(GDesktopAppInfo* info);
665        const(char)* g_desktop_app_info_get_generic_name(GDesktopAppInfo* info);
666        int g_desktop_app_info_get_is_hidden(GDesktopAppInfo* info);
667        char** g_desktop_app_info_get_keywords(GDesktopAppInfo* info);
668        int g_desktop_app_info_get_nodisplay(GDesktopAppInfo* info);
669        int g_desktop_app_info_get_show_in(GDesktopAppInfo* info, const(char)* desktopEnv);
670        const(char)* g_desktop_app_info_get_startup_wm_class(GDesktopAppInfo* info);
671        char* g_desktop_app_info_get_string(GDesktopAppInfo* info, const(char)* key);
672        int g_desktop_app_info_has_key(GDesktopAppInfo* info, const(char)* key);
673        void g_desktop_app_info_launch_action(GDesktopAppInfo* info, const(char)* actionName, GAppLaunchContext* launchContext);
674        int g_desktop_app_info_launch_uris_as_manager(GDesktopAppInfo* appinfo, GList* uris, GAppLaunchContext* launchContext, GSpawnFlags spawnFlags, GSpawnChildSetupFunc userSetup, void* userSetupData, GDesktopAppLaunchCallback pidCallback, void* pidCallbackData, GError** err);
675        char** g_desktop_app_info_list_actions(GDesktopAppInfo* info);
676
677        // gio.DesktopAppInfoLookup
678
679        GType g_desktop_app_info_lookup_get_type();
680        GAppInfo* g_desktop_app_info_lookup_get_default_for_uri_scheme(GDesktopAppInfoLookup* lookup, const(char)* uriScheme);
681
682        // gio.Drive
683
684        GType g_drive_get_type();
685        int g_drive_can_eject(GDrive* drive);
686        int g_drive_can_poll_for_media(GDrive* drive);
687        int g_drive_can_start(GDrive* drive);
688        int g_drive_can_start_degraded(GDrive* drive);
689        int g_drive_can_stop(GDrive* drive);
690        void g_drive_eject(GDrive* drive, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
691        int g_drive_eject_finish(GDrive* drive, GAsyncResult* result, GError** err);
692        void g_drive_eject_with_operation(GDrive* drive, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
693        int g_drive_eject_with_operation_finish(GDrive* drive, GAsyncResult* result, GError** err);
694        char** g_drive_enumerate_identifiers(GDrive* drive);
695        GIcon* g_drive_get_icon(GDrive* drive);
696        char* g_drive_get_identifier(GDrive* drive, const(char)* kind);
697        char* g_drive_get_name(GDrive* drive);
698        const(char)* g_drive_get_sort_key(GDrive* drive);
699        GDriveStartStopType g_drive_get_start_stop_type(GDrive* drive);
700        GIcon* g_drive_get_symbolic_icon(GDrive* drive);
701        GList* g_drive_get_volumes(GDrive* drive);
702        int g_drive_has_media(GDrive* drive);
703        int g_drive_has_volumes(GDrive* drive);
704        int g_drive_is_media_check_automatic(GDrive* drive);
705        int g_drive_is_media_removable(GDrive* drive);
706        void g_drive_poll_for_media(GDrive* drive, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
707        int g_drive_poll_for_media_finish(GDrive* drive, GAsyncResult* result, GError** err);
708        void g_drive_start(GDrive* drive, GDriveStartFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
709        int g_drive_start_finish(GDrive* drive, GAsyncResult* result, GError** err);
710        void g_drive_stop(GDrive* drive, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
711        int g_drive_stop_finish(GDrive* drive, GAsyncResult* result, GError** err);
712
713        // gio.Emblem
714
715        GType g_emblem_get_type();
716        GEmblem* g_emblem_new(GIcon* icon);
717        GEmblem* g_emblem_new_with_origin(GIcon* icon, GEmblemOrigin origin);
718        GIcon* g_emblem_get_icon(GEmblem* emblem);
719        GEmblemOrigin g_emblem_get_origin(GEmblem* emblem);
720
721        // gio.EmblemedIcon
722
723        GType g_emblemed_icon_get_type();
724        GIcon* g_emblemed_icon_new(GIcon* icon, GEmblem* emblem);
725        void g_emblemed_icon_add_emblem(GEmblemedIcon* emblemed, GEmblem* emblem);
726        void g_emblemed_icon_clear_emblems(GEmblemedIcon* emblemed);
727        GList* g_emblemed_icon_get_emblems(GEmblemedIcon* emblemed);
728        GIcon* g_emblemed_icon_get_icon(GEmblemedIcon* emblemed);
729
730        // gio.File
731
732        GType g_file_get_type();
733        GFile* g_file_new_for_commandline_arg(const(char)* arg);
734        GFile* g_file_new_for_commandline_arg_and_cwd(const(char)* arg, const(char)* cwd);
735        GFile* g_file_new_for_path(const(char)* path);
736        GFile* g_file_new_for_uri(const(char)* uri);
737        GFile* g_file_new_tmp(char* tmpl, GFileIOStream** iostream, GError** err);
738        GFile* g_file_parse_name(const(char)* parseName);
739        GFileOutputStream* g_file_append_to(GFile* file, GFileCreateFlags flags, GCancellable* cancellable, GError** err);
740        void g_file_append_to_async(GFile* file, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
741        GFileOutputStream* g_file_append_to_finish(GFile* file, GAsyncResult* res, GError** err);
742        int g_file_copy(GFile* source, GFile* destination, GFileCopyFlags flags, GCancellable* cancellable, GFileProgressCallback progressCallback, void* progressCallbackData, GError** err);
743        void g_file_copy_async(GFile* source, GFile* destination, GFileCopyFlags flags, int ioPriority, GCancellable* cancellable, GFileProgressCallback progressCallback, void* progressCallbackData, GAsyncReadyCallback callback, void* userData);
744        int g_file_copy_attributes(GFile* source, GFile* destination, GFileCopyFlags flags, GCancellable* cancellable, GError** err);
745        int g_file_copy_finish(GFile* file, GAsyncResult* res, GError** err);
746        GFileOutputStream* g_file_create(GFile* file, GFileCreateFlags flags, GCancellable* cancellable, GError** err);
747        void g_file_create_async(GFile* file, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
748        GFileOutputStream* g_file_create_finish(GFile* file, GAsyncResult* res, GError** err);
749        GFileIOStream* g_file_create_readwrite(GFile* file, GFileCreateFlags flags, GCancellable* cancellable, GError** err);
750        void g_file_create_readwrite_async(GFile* file, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
751        GFileIOStream* g_file_create_readwrite_finish(GFile* file, GAsyncResult* res, GError** err);
752        int g_file_delete(GFile* file, GCancellable* cancellable, GError** err);
753        void g_file_delete_async(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
754        int g_file_delete_finish(GFile* file, GAsyncResult* result, GError** err);
755        GFile* g_file_dup(GFile* file);
756        void g_file_eject_mountable(GFile* file, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
757        int g_file_eject_mountable_finish(GFile* file, GAsyncResult* result, GError** err);
758        void g_file_eject_mountable_with_operation(GFile* file, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
759        int g_file_eject_mountable_with_operation_finish(GFile* file, GAsyncResult* result, GError** err);
760        GFileEnumerator* g_file_enumerate_children(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err);
761        void g_file_enumerate_children_async(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
762        GFileEnumerator* g_file_enumerate_children_finish(GFile* file, GAsyncResult* res, GError** err);
763        int g_file_equal(GFile* file1, GFile* file2);
764        GMount* g_file_find_enclosing_mount(GFile* file, GCancellable* cancellable, GError** err);
765        void g_file_find_enclosing_mount_async(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
766        GMount* g_file_find_enclosing_mount_finish(GFile* file, GAsyncResult* res, GError** err);
767        char* g_file_get_basename(GFile* file);
768        GFile* g_file_get_child(GFile* file, const(char)* name);
769        GFile* g_file_get_child_for_display_name(GFile* file, const(char)* displayName, GError** err);
770        GFile* g_file_get_parent(GFile* file);
771        char* g_file_get_parse_name(GFile* file);
772        char* g_file_get_path(GFile* file);
773        char* g_file_get_relative_path(GFile* parent, GFile* descendant);
774        char* g_file_get_uri(GFile* file);
775        char* g_file_get_uri_scheme(GFile* file);
776        int g_file_has_parent(GFile* file, GFile* parent);
777        int g_file_has_prefix(GFile* file, GFile* prefix);
778        int g_file_has_uri_scheme(GFile* file, const(char)* uriScheme);
779        uint g_file_hash(void* file);
780        int g_file_is_native(GFile* file);
781        int g_file_load_contents(GFile* file, GCancellable* cancellable, char** contents, size_t* length, char** etagOut, GError** err);
782        void g_file_load_contents_async(GFile* file, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
783        int g_file_load_contents_finish(GFile* file, GAsyncResult* res, char** contents, size_t* length, char** etagOut, GError** err);
784        void g_file_load_partial_contents_async(GFile* file, GCancellable* cancellable, GFileReadMoreCallback readMoreCallback, GAsyncReadyCallback callback, void* userData);
785        int g_file_load_partial_contents_finish(GFile* file, GAsyncResult* res, char** contents, size_t* length, char** etagOut, GError** err);
786        int g_file_make_directory(GFile* file, GCancellable* cancellable, GError** err);
787        void g_file_make_directory_async(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
788        int g_file_make_directory_finish(GFile* file, GAsyncResult* result, GError** err);
789        int g_file_make_directory_with_parents(GFile* file, GCancellable* cancellable, GError** err);
790        int g_file_make_symbolic_link(GFile* file, const(char)* symlinkValue, GCancellable* cancellable, GError** err);
791        int g_file_measure_disk_usage(GFile* file, GFileMeasureFlags flags, GCancellable* cancellable, GFileMeasureProgressCallback progressCallback, void* progressData, ulong* diskUsage, ulong* numDirs, ulong* numFiles, GError** err);
792        void g_file_measure_disk_usage_async(GFile* file, GFileMeasureFlags flags, int ioPriority, GCancellable* cancellable, GFileMeasureProgressCallback progressCallback, void* progressData, GAsyncReadyCallback callback, void* userData);
793        int g_file_measure_disk_usage_finish(GFile* file, GAsyncResult* result, ulong* diskUsage, ulong* numDirs, ulong* numFiles, GError** err);
794        GFileMonitor* g_file_monitor(GFile* file, GFileMonitorFlags flags, GCancellable* cancellable, GError** err);
795        GFileMonitor* g_file_monitor_directory(GFile* file, GFileMonitorFlags flags, GCancellable* cancellable, GError** err);
796        GFileMonitor* g_file_monitor_file(GFile* file, GFileMonitorFlags flags, GCancellable* cancellable, GError** err);
797        void g_file_mount_enclosing_volume(GFile* location, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
798        int g_file_mount_enclosing_volume_finish(GFile* location, GAsyncResult* result, GError** err);
799        void g_file_mount_mountable(GFile* file, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
800        GFile* g_file_mount_mountable_finish(GFile* file, GAsyncResult* result, GError** err);
801        int g_file_move(GFile* source, GFile* destination, GFileCopyFlags flags, GCancellable* cancellable, GFileProgressCallback progressCallback, void* progressCallbackData, GError** err);
802        GFileIOStream* g_file_open_readwrite(GFile* file, GCancellable* cancellable, GError** err);
803        void g_file_open_readwrite_async(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
804        GFileIOStream* g_file_open_readwrite_finish(GFile* file, GAsyncResult* res, GError** err);
805        void g_file_poll_mountable(GFile* file, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
806        int g_file_poll_mountable_finish(GFile* file, GAsyncResult* result, GError** err);
807        GAppInfo* g_file_query_default_handler(GFile* file, GCancellable* cancellable, GError** err);
808        int g_file_query_exists(GFile* file, GCancellable* cancellable);
809        GFileType g_file_query_file_type(GFile* file, GFileQueryInfoFlags flags, GCancellable* cancellable);
810        GFileInfo* g_file_query_filesystem_info(GFile* file, const(char)* attributes, GCancellable* cancellable, GError** err);
811        void g_file_query_filesystem_info_async(GFile* file, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
812        GFileInfo* g_file_query_filesystem_info_finish(GFile* file, GAsyncResult* res, GError** err);
813        GFileInfo* g_file_query_info(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err);
814        void g_file_query_info_async(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
815        GFileInfo* g_file_query_info_finish(GFile* file, GAsyncResult* res, GError** err);
816        GFileAttributeInfoList* g_file_query_settable_attributes(GFile* file, GCancellable* cancellable, GError** err);
817        GFileAttributeInfoList* g_file_query_writable_namespaces(GFile* file, GCancellable* cancellable, GError** err);
818        GFileInputStream* g_file_read(GFile* file, GCancellable* cancellable, GError** err);
819        void g_file_read_async(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
820        GFileInputStream* g_file_read_finish(GFile* file, GAsyncResult* res, GError** err);
821        GFileOutputStream* g_file_replace(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, GCancellable* cancellable, GError** err);
822        void g_file_replace_async(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
823        int g_file_replace_contents(GFile* file, char* contents, size_t length, const(char)* etag, int makeBackup, GFileCreateFlags flags, char** newEtag, GCancellable* cancellable, GError** err);
824        void g_file_replace_contents_async(GFile* file, char* contents, size_t length, const(char)* etag, int makeBackup, GFileCreateFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
825        void g_file_replace_contents_bytes_async(GFile* file, GBytes* contents, const(char)* etag, int makeBackup, GFileCreateFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
826        int g_file_replace_contents_finish(GFile* file, GAsyncResult* res, char** newEtag, GError** err);
827        GFileOutputStream* g_file_replace_finish(GFile* file, GAsyncResult* res, GError** err);
828        GFileIOStream* g_file_replace_readwrite(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, GCancellable* cancellable, GError** err);
829        void g_file_replace_readwrite_async(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
830        GFileIOStream* g_file_replace_readwrite_finish(GFile* file, GAsyncResult* res, GError** err);
831        GFile* g_file_resolve_relative_path(GFile* file, const(char)* relativePath);
832        int g_file_set_attribute(GFile* file, const(char)* attribute, GFileAttributeType type, void* valueP, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err);
833        int g_file_set_attribute_byte_string(GFile* file, const(char)* attribute, const(char)* value, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err);
834        int g_file_set_attribute_int32(GFile* file, const(char)* attribute, int value, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err);
835        int g_file_set_attribute_int64(GFile* file, const(char)* attribute, long value, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err);
836        int g_file_set_attribute_string(GFile* file, const(char)* attribute, const(char)* value, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err);
837        int g_file_set_attribute_uint32(GFile* file, const(char)* attribute, uint value, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err);
838        int g_file_set_attribute_uint64(GFile* file, const(char)* attribute, ulong value, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err);
839        void g_file_set_attributes_async(GFile* file, GFileInfo* info, GFileQueryInfoFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
840        int g_file_set_attributes_finish(GFile* file, GAsyncResult* result, GFileInfo** info, GError** err);
841        int g_file_set_attributes_from_info(GFile* file, GFileInfo* info, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err);
842        GFile* g_file_set_display_name(GFile* file, const(char)* displayName, GCancellable* cancellable, GError** err);
843        void g_file_set_display_name_async(GFile* file, const(char)* displayName, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
844        GFile* g_file_set_display_name_finish(GFile* file, GAsyncResult* res, GError** err);
845        void g_file_start_mountable(GFile* file, GDriveStartFlags flags, GMountOperation* startOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
846        int g_file_start_mountable_finish(GFile* file, GAsyncResult* result, GError** err);
847        void g_file_stop_mountable(GFile* file, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
848        int g_file_stop_mountable_finish(GFile* file, GAsyncResult* result, GError** err);
849        int g_file_supports_thread_contexts(GFile* file);
850        int g_file_trash(GFile* file, GCancellable* cancellable, GError** err);
851        void g_file_trash_async(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
852        int g_file_trash_finish(GFile* file, GAsyncResult* result, GError** err);
853        void g_file_unmount_mountable(GFile* file, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
854        int g_file_unmount_mountable_finish(GFile* file, GAsyncResult* result, GError** err);
855        void g_file_unmount_mountable_with_operation(GFile* file, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
856        int g_file_unmount_mountable_with_operation_finish(GFile* file, GAsyncResult* result, GError** err);
857
858        // gio.FileAttributeInfoList
859
860        GType g_file_attribute_info_list_get_type();
861        GFileAttributeInfoList* g_file_attribute_info_list_new();
862        void g_file_attribute_info_list_add(GFileAttributeInfoList* list, const(char)* name, GFileAttributeType type, GFileAttributeInfoFlags flags);
863        GFileAttributeInfoList* g_file_attribute_info_list_dup(GFileAttributeInfoList* list);
864        GFileAttributeInfo* g_file_attribute_info_list_lookup(GFileAttributeInfoList* list, const(char)* name);
865        GFileAttributeInfoList* g_file_attribute_info_list_ref(GFileAttributeInfoList* list);
866        void g_file_attribute_info_list_unref(GFileAttributeInfoList* list);
867
868        // gio.FileAttributeMatcher
869
870        GType g_file_attribute_matcher_get_type();
871        GFileAttributeMatcher* g_file_attribute_matcher_new(const(char)* attributes);
872        int g_file_attribute_matcher_enumerate_namespace(GFileAttributeMatcher* matcher, const(char)* ns);
873        const(char)* g_file_attribute_matcher_enumerate_next(GFileAttributeMatcher* matcher);
874        int g_file_attribute_matcher_matches(GFileAttributeMatcher* matcher, const(char)* attribute);
875        int g_file_attribute_matcher_matches_only(GFileAttributeMatcher* matcher, const(char)* attribute);
876        GFileAttributeMatcher* g_file_attribute_matcher_ref(GFileAttributeMatcher* matcher);
877        GFileAttributeMatcher* g_file_attribute_matcher_subtract(GFileAttributeMatcher* matcher, GFileAttributeMatcher* subtract);
878        char* g_file_attribute_matcher_to_string(GFileAttributeMatcher* matcher);
879        void g_file_attribute_matcher_unref(GFileAttributeMatcher* matcher);
880
881        // gio.FileDescriptorBased
882
883        GType g_file_descriptor_based_get_type();
884        int g_file_descriptor_based_get_fd(GFileDescriptorBased* fdBased);
885
886        // gio.FileEnumerator
887
888        GType g_file_enumerator_get_type();
889        int g_file_enumerator_close(GFileEnumerator* enumerator, GCancellable* cancellable, GError** err);
890        void g_file_enumerator_close_async(GFileEnumerator* enumerator, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
891        int g_file_enumerator_close_finish(GFileEnumerator* enumerator, GAsyncResult* result, GError** err);
892        GFile* g_file_enumerator_get_child(GFileEnumerator* enumerator, GFileInfo* info);
893        GFile* g_file_enumerator_get_container(GFileEnumerator* enumerator);
894        int g_file_enumerator_has_pending(GFileEnumerator* enumerator);
895        int g_file_enumerator_is_closed(GFileEnumerator* enumerator);
896        int g_file_enumerator_iterate(GFileEnumerator* direnum, GFileInfo** outInfo, GFile** outChild, GCancellable* cancellable, GError** err);
897        GFileInfo* g_file_enumerator_next_file(GFileEnumerator* enumerator, GCancellable* cancellable, GError** err);
898        void g_file_enumerator_next_files_async(GFileEnumerator* enumerator, int numFiles, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
899        GList* g_file_enumerator_next_files_finish(GFileEnumerator* enumerator, GAsyncResult* result, GError** err);
900        void g_file_enumerator_set_pending(GFileEnumerator* enumerator, int pending);
901
902        // gio.FileIOStream
903
904        GType g_file_io_stream_get_type();
905        char* g_file_io_stream_get_etag(GFileIOStream* stream);
906        GFileInfo* g_file_io_stream_query_info(GFileIOStream* stream, const(char)* attributes, GCancellable* cancellable, GError** err);
907        void g_file_io_stream_query_info_async(GFileIOStream* stream, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
908        GFileInfo* g_file_io_stream_query_info_finish(GFileIOStream* stream, GAsyncResult* result, GError** err);
909
910        // gio.FileIcon
911
912        GType g_file_icon_get_type();
913        GIcon* g_file_icon_new(GFile* file);
914        GFile* g_file_icon_get_file(GFileIcon* icon);
915
916        // gio.FileInfo
917
918        GType g_file_info_get_type();
919        GFileInfo* g_file_info_new();
920        void g_file_info_clear_status(GFileInfo* info);
921        void g_file_info_copy_into(GFileInfo* srcInfo, GFileInfo* destInfo);
922        GFileInfo* g_file_info_dup(GFileInfo* other);
923        char* g_file_info_get_attribute_as_string(GFileInfo* info, const(char)* attribute);
924        int g_file_info_get_attribute_boolean(GFileInfo* info, const(char)* attribute);
925        const(char)* g_file_info_get_attribute_byte_string(GFileInfo* info, const(char)* attribute);
926        int g_file_info_get_attribute_data(GFileInfo* info, const(char)* attribute, GFileAttributeType* type, void** valuePp, GFileAttributeStatus* status);
927        int g_file_info_get_attribute_int32(GFileInfo* info, const(char)* attribute);
928        long g_file_info_get_attribute_int64(GFileInfo* info, const(char)* attribute);
929        GObject* g_file_info_get_attribute_object(GFileInfo* info, const(char)* attribute);
930        GFileAttributeStatus g_file_info_get_attribute_status(GFileInfo* info, const(char)* attribute);
931        const(char)* g_file_info_get_attribute_string(GFileInfo* info, const(char)* attribute);
932        char** g_file_info_get_attribute_stringv(GFileInfo* info, const(char)* attribute);
933        GFileAttributeType g_file_info_get_attribute_type(GFileInfo* info, const(char)* attribute);
934        uint g_file_info_get_attribute_uint32(GFileInfo* info, const(char)* attribute);
935        ulong g_file_info_get_attribute_uint64(GFileInfo* info, const(char)* attribute);
936        const(char)* g_file_info_get_content_type(GFileInfo* info);
937        GDateTime* g_file_info_get_deletion_date(GFileInfo* info);
938        const(char)* g_file_info_get_display_name(GFileInfo* info);
939        const(char)* g_file_info_get_edit_name(GFileInfo* info);
940        const(char)* g_file_info_get_etag(GFileInfo* info);
941        GFileType g_file_info_get_file_type(GFileInfo* info);
942        GIcon* g_file_info_get_icon(GFileInfo* info);
943        int g_file_info_get_is_backup(GFileInfo* info);
944        int g_file_info_get_is_hidden(GFileInfo* info);
945        int g_file_info_get_is_symlink(GFileInfo* info);
946        void g_file_info_get_modification_time(GFileInfo* info, GTimeVal* result);
947        const(char)* g_file_info_get_name(GFileInfo* info);
948        long g_file_info_get_size(GFileInfo* info);
949        int g_file_info_get_sort_order(GFileInfo* info);
950        GIcon* g_file_info_get_symbolic_icon(GFileInfo* info);
951        const(char)* g_file_info_get_symlink_target(GFileInfo* info);
952        int g_file_info_has_attribute(GFileInfo* info, const(char)* attribute);
953        int g_file_info_has_namespace(GFileInfo* info, const(char)* nameSpace);
954        char** g_file_info_list_attributes(GFileInfo* info, const(char)* nameSpace);
955        void g_file_info_remove_attribute(GFileInfo* info, const(char)* attribute);
956        void g_file_info_set_attribute(GFileInfo* info, const(char)* attribute, GFileAttributeType type, void* valueP);
957        void g_file_info_set_attribute_boolean(GFileInfo* info, const(char)* attribute, int attrValue);
958        void g_file_info_set_attribute_byte_string(GFileInfo* info, const(char)* attribute, const(char)* attrValue);
959        void g_file_info_set_attribute_int32(GFileInfo* info, const(char)* attribute, int attrValue);
960        void g_file_info_set_attribute_int64(GFileInfo* info, const(char)* attribute, long attrValue);
961        void g_file_info_set_attribute_mask(GFileInfo* info, GFileAttributeMatcher* mask);
962        void g_file_info_set_attribute_object(GFileInfo* info, const(char)* attribute, GObject* attrValue);
963        int g_file_info_set_attribute_status(GFileInfo* info, const(char)* attribute, GFileAttributeStatus status);
964        void g_file_info_set_attribute_string(GFileInfo* info, const(char)* attribute, const(char)* attrValue);
965        void g_file_info_set_attribute_stringv(GFileInfo* info, const(char)* attribute, char** attrValue);
966        void g_file_info_set_attribute_uint32(GFileInfo* info, const(char)* attribute, uint attrValue);
967        void g_file_info_set_attribute_uint64(GFileInfo* info, const(char)* attribute, ulong attrValue);
968        void g_file_info_set_content_type(GFileInfo* info, const(char)* contentType);
969        void g_file_info_set_display_name(GFileInfo* info, const(char)* displayName);
970        void g_file_info_set_edit_name(GFileInfo* info, const(char)* editName);
971        void g_file_info_set_file_type(GFileInfo* info, GFileType type);
972        void g_file_info_set_icon(GFileInfo* info, GIcon* icon);
973        void g_file_info_set_is_hidden(GFileInfo* info, int isHidden);
974        void g_file_info_set_is_symlink(GFileInfo* info, int isSymlink);
975        void g_file_info_set_modification_time(GFileInfo* info, GTimeVal* mtime);
976        void g_file_info_set_name(GFileInfo* info, const(char)* name);
977        void g_file_info_set_size(GFileInfo* info, long size);
978        void g_file_info_set_sort_order(GFileInfo* info, int sortOrder);
979        void g_file_info_set_symbolic_icon(GFileInfo* info, GIcon* icon);
980        void g_file_info_set_symlink_target(GFileInfo* info, const(char)* symlinkTarget);
981        void g_file_info_unset_attribute_mask(GFileInfo* info);
982
983        // gio.FileInputStream
984
985        GType g_file_input_stream_get_type();
986        GFileInfo* g_file_input_stream_query_info(GFileInputStream* stream, const(char)* attributes, GCancellable* cancellable, GError** err);
987        void g_file_input_stream_query_info_async(GFileInputStream* stream, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
988        GFileInfo* g_file_input_stream_query_info_finish(GFileInputStream* stream, GAsyncResult* result, GError** err);
989
990        // gio.FileMonitor
991
992        GType g_file_monitor_get_type();
993        int g_file_monitor_cancel(GFileMonitor* monitor);
994        void g_file_monitor_emit_event(GFileMonitor* monitor, GFile* child, GFile* otherFile, GFileMonitorEvent eventType);
995        int g_file_monitor_is_cancelled(GFileMonitor* monitor);
996        void g_file_monitor_set_rate_limit(GFileMonitor* monitor, int limitMsecs);
997
998        // gio.FileOutputStream
999
1000        GType g_file_output_stream_get_type();
1001        char* g_file_output_stream_get_etag(GFileOutputStream* stream);
1002        GFileInfo* g_file_output_stream_query_info(GFileOutputStream* stream, const(char)* attributes, GCancellable* cancellable, GError** err);
1003        void g_file_output_stream_query_info_async(GFileOutputStream* stream, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1004        GFileInfo* g_file_output_stream_query_info_finish(GFileOutputStream* stream, GAsyncResult* result, GError** err);
1005
1006        // gio.FilenameCompleter
1007
1008        GType g_filename_completer_get_type();
1009        GFilenameCompleter* g_filename_completer_new();
1010        char* g_filename_completer_get_completion_suffix(GFilenameCompleter* completer, const(char)* initialText);
1011        char** g_filename_completer_get_completions(GFilenameCompleter* completer, const(char)* initialText);
1012        void g_filename_completer_set_dirs_only(GFilenameCompleter* completer, int dirsOnly);
1013
1014        // gio.FilterInputStream
1015
1016        GType g_filter_input_stream_get_type();
1017        GInputStream* g_filter_input_stream_get_base_stream(GFilterInputStream* stream);
1018        int g_filter_input_stream_get_close_base_stream(GFilterInputStream* stream);
1019        void g_filter_input_stream_set_close_base_stream(GFilterInputStream* stream, int closeBase);
1020
1021        // gio.FilterOutputStream
1022
1023        GType g_filter_output_stream_get_type();
1024        GOutputStream* g_filter_output_stream_get_base_stream(GFilterOutputStream* stream);
1025        int g_filter_output_stream_get_close_base_stream(GFilterOutputStream* stream);
1026        void g_filter_output_stream_set_close_base_stream(GFilterOutputStream* stream, int closeBase);
1027
1028        // gio.IOExtension
1029
1030        const(char)* g_io_extension_get_name(GIOExtension* extension);
1031        int g_io_extension_get_priority(GIOExtension* extension);
1032        GType g_io_extension_get_type(GIOExtension* extension);
1033        GTypeClass* g_io_extension_ref_class(GIOExtension* extension);
1034
1035        // gio.IOExtensionPoint
1036
1037        GIOExtension* g_io_extension_point_get_extension_by_name(GIOExtensionPoint* extensionPoint, const(char)* name);
1038        GList* g_io_extension_point_get_extensions(GIOExtensionPoint* extensionPoint);
1039        GType g_io_extension_point_get_required_type(GIOExtensionPoint* extensionPoint);
1040        void g_io_extension_point_set_required_type(GIOExtensionPoint* extensionPoint, GType type);
1041        GIOExtension* g_io_extension_point_implement(const(char)* extensionPointName, GType type, const(char)* extensionName, int priority);
1042        GIOExtensionPoint* g_io_extension_point_lookup(const(char)* name);
1043        GIOExtensionPoint* g_io_extension_point_register(const(char)* name);
1044
1045        // gio.IOModule
1046
1047        GType g_io_module_get_type();
1048        GIOModule* g_io_module_new(const(char)* filename);
1049        GList* g_io_modules_load_all_in_directory(const(char)* dirname);
1050        GList* g_io_modules_load_all_in_directory_with_scope(const(char)* dirname, GIOModuleScope* scop);
1051        void g_io_modules_scan_all_in_directory(const(char)* dirname);
1052        void g_io_modules_scan_all_in_directory_with_scope(const(char)* dirname, GIOModuleScope* scop);
1053
1054        // gio.IOModuleScope
1055
1056        void g_io_module_scope_block(GIOModuleScope* scop, const(char)* basename);
1057        void g_io_module_scope_free(GIOModuleScope* scop);
1058        GIOModuleScope* g_io_module_scope_new(GIOModuleScopeFlags flags);
1059
1060        // gio.IOSchedulerJob
1061
1062        int g_io_scheduler_job_send_to_mainloop(GIOSchedulerJob* job, GSourceFunc func, void* userData, GDestroyNotify notify);
1063        void g_io_scheduler_job_send_to_mainloop_async(GIOSchedulerJob* job, GSourceFunc func, void* userData, GDestroyNotify notify);
1064        void g_io_scheduler_cancel_all_jobs();
1065        void g_io_scheduler_push_job(GIOSchedulerJobFunc jobFunc, void* userData, GDestroyNotify notify, int ioPriority, GCancellable* cancellable);
1066
1067        // gio.IOStream
1068
1069        GType g_io_stream_get_type();
1070        int g_io_stream_splice_finish(GAsyncResult* result, GError** err);
1071        void g_io_stream_clear_pending(GIOStream* stream);
1072        int g_io_stream_close(GIOStream* stream, GCancellable* cancellable, GError** err);
1073        void g_io_stream_close_async(GIOStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1074        int g_io_stream_close_finish(GIOStream* stream, GAsyncResult* result, GError** err);
1075        GInputStream* g_io_stream_get_input_stream(GIOStream* stream);
1076        GOutputStream* g_io_stream_get_output_stream(GIOStream* stream);
1077        int g_io_stream_has_pending(GIOStream* stream);
1078        int g_io_stream_is_closed(GIOStream* stream);
1079        int g_io_stream_set_pending(GIOStream* stream, GError** err);
1080        void g_io_stream_splice_async(GIOStream* stream1, GIOStream* stream2, GIOStreamSpliceFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1081
1082        // gio.Icon
1083
1084        GType g_icon_get_type();
1085        GIcon* g_icon_deserialize(GVariant* value);
1086        uint g_icon_hash(void* icon);
1087        GIcon* g_icon_new_for_string(const(char)* str, GError** err);
1088        int g_icon_equal(GIcon* icon1, GIcon* icon2);
1089        GVariant* g_icon_serialize(GIcon* icon);
1090        char* g_icon_to_string(GIcon* icon);
1091
1092        // gio.InetAddress
1093
1094        GType g_inet_address_get_type();
1095        GInetAddress* g_inet_address_new_any(GSocketFamily family);
1096        GInetAddress* g_inet_address_new_from_bytes(ubyte* bytes, GSocketFamily family);
1097        GInetAddress* g_inet_address_new_from_string(const(char)* str);
1098        GInetAddress* g_inet_address_new_loopback(GSocketFamily family);
1099        int g_inet_address_equal(GInetAddress* address, GInetAddress* otherAddress);
1100        GSocketFamily g_inet_address_get_family(GInetAddress* address);
1101        int g_inet_address_get_is_any(GInetAddress* address);
1102        int g_inet_address_get_is_link_local(GInetAddress* address);
1103        int g_inet_address_get_is_loopback(GInetAddress* address);
1104        int g_inet_address_get_is_mc_global(GInetAddress* address);
1105        int g_inet_address_get_is_mc_link_local(GInetAddress* address);
1106        int g_inet_address_get_is_mc_node_local(GInetAddress* address);
1107        int g_inet_address_get_is_mc_org_local(GInetAddress* address);
1108        int g_inet_address_get_is_mc_site_local(GInetAddress* address);
1109        int g_inet_address_get_is_multicast(GInetAddress* address);
1110        int g_inet_address_get_is_site_local(GInetAddress* address);
1111        size_t g_inet_address_get_native_size(GInetAddress* address);
1112        ubyte* g_inet_address_to_bytes(GInetAddress* address);
1113        char* g_inet_address_to_string(GInetAddress* address);
1114
1115        // gio.InetAddressMask
1116
1117        GType g_inet_address_mask_get_type();
1118        GInetAddressMask* g_inet_address_mask_new(GInetAddress* addr, uint length, GError** err);
1119        GInetAddressMask* g_inet_address_mask_new_from_string(const(char)* maskString, GError** err);
1120        int g_inet_address_mask_equal(GInetAddressMask* mask, GInetAddressMask* mask2);
1121        GInetAddress* g_inet_address_mask_get_address(GInetAddressMask* mask);
1122        GSocketFamily g_inet_address_mask_get_family(GInetAddressMask* mask);
1123        uint g_inet_address_mask_get_length(GInetAddressMask* mask);
1124        int g_inet_address_mask_matches(GInetAddressMask* mask, GInetAddress* address);
1125        char* g_inet_address_mask_to_string(GInetAddressMask* mask);
1126
1127        // gio.InetSocketAddress
1128
1129        GType g_inet_socket_address_get_type();
1130        GSocketAddress* g_inet_socket_address_new(GInetAddress* address, ushort port);
1131        GSocketAddress* g_inet_socket_address_new_from_string(const(char)* address, uint port);
1132        GInetAddress* g_inet_socket_address_get_address(GInetSocketAddress* address);
1133        uint g_inet_socket_address_get_flowinfo(GInetSocketAddress* address);
1134        ushort g_inet_socket_address_get_port(GInetSocketAddress* address);
1135        uint g_inet_socket_address_get_scope_id(GInetSocketAddress* address);
1136
1137        // gio.Initable
1138
1139        GType g_initable_get_type();
1140        void* g_initable_new(GType objectType, GCancellable* cancellable, GError** error, const(char)* firstPropertyName, ... );
1141        GObject* g_initable_new_valist(GType objectType, const(char)* firstPropertyName, void* varArgs, GCancellable* cancellable, GError** err);
1142        void* g_initable_newv(GType objectType, uint nParameters, GParameter* parameters, GCancellable* cancellable, GError** err);
1143        int g_initable_init(GInitable* initable, GCancellable* cancellable, GError** err);
1144
1145        // gio.InputStream
1146
1147        GType g_input_stream_get_type();
1148        void g_input_stream_clear_pending(GInputStream* stream);
1149        int g_input_stream_close(GInputStream* stream, GCancellable* cancellable, GError** err);
1150        void g_input_stream_close_async(GInputStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1151        int g_input_stream_close_finish(GInputStream* stream, GAsyncResult* result, GError** err);
1152        int g_input_stream_has_pending(GInputStream* stream);
1153        int g_input_stream_is_closed(GInputStream* stream);
1154        ptrdiff_t g_input_stream_read(GInputStream* stream, void* buffer, size_t count, GCancellable* cancellable, GError** err);
1155        int g_input_stream_read_all(GInputStream* stream, void* buffer, size_t count, size_t* bytesRead, GCancellable* cancellable, GError** err);
1156        void g_input_stream_read_all_async(GInputStream* stream, void* buffer, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1157        int g_input_stream_read_all_finish(GInputStream* stream, GAsyncResult* result, size_t* bytesRead, GError** err);
1158        void g_input_stream_read_async(GInputStream* stream, void* buffer, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1159        GBytes* g_input_stream_read_bytes(GInputStream* stream, size_t count, GCancellable* cancellable, GError** err);
1160        void g_input_stream_read_bytes_async(GInputStream* stream, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1161        GBytes* g_input_stream_read_bytes_finish(GInputStream* stream, GAsyncResult* result, GError** err);
1162        ptrdiff_t g_input_stream_read_finish(GInputStream* stream, GAsyncResult* result, GError** err);
1163        int g_input_stream_set_pending(GInputStream* stream, GError** err);
1164        ptrdiff_t g_input_stream_skip(GInputStream* stream, size_t count, GCancellable* cancellable, GError** err);
1165        void g_input_stream_skip_async(GInputStream* stream, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1166        ptrdiff_t g_input_stream_skip_finish(GInputStream* stream, GAsyncResult* result, GError** err);
1167
1168        // gio.ListModel
1169
1170        GType g_list_model_get_type();
1171        void* g_list_model_get_item(GListModel* list, uint position);
1172        GType g_list_model_get_item_type(GListModel* list);
1173        uint g_list_model_get_n_items(GListModel* list);
1174        GObject* g_list_model_get_object(GListModel* list, uint position);
1175        void g_list_model_items_changed(GListModel* list, uint position, uint removed, uint added);
1176
1177        // gio.ListStore
1178
1179        GType g_list_store_get_type();
1180        GListStore* g_list_store_new(GType itemType);
1181        void g_list_store_append(GListStore* store, void* item);
1182        void g_list_store_insert(GListStore* store, uint position, void* item);
1183        uint g_list_store_insert_sorted(GListStore* store, void* item, GCompareDataFunc compareFunc, void* userData);
1184        void g_list_store_remove(GListStore* store, uint position);
1185        void g_list_store_remove_all(GListStore* store);
1186        void g_list_store_sort(GListStore* store, GCompareDataFunc compareFunc, void* userData);
1187        void g_list_store_splice(GListStore* store, uint position, uint nRemovals, void** additions, uint nAdditions);
1188
1189        // gio.LoadableIcon
1190
1191        GType g_loadable_icon_get_type();
1192        GInputStream* g_loadable_icon_load(GLoadableIcon* icon, int size, char** type, GCancellable* cancellable, GError** err);
1193        void g_loadable_icon_load_async(GLoadableIcon* icon, int size, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1194        GInputStream* g_loadable_icon_load_finish(GLoadableIcon* icon, GAsyncResult* res, char** type, GError** err);
1195
1196        // gio.MemoryInputStream
1197
1198        GType g_memory_input_stream_get_type();
1199        GInputStream* g_memory_input_stream_new();
1200        GInputStream* g_memory_input_stream_new_from_bytes(GBytes* bytes);
1201        GInputStream* g_memory_input_stream_new_from_data(void* data, ptrdiff_t len, GDestroyNotify destroy);
1202        void g_memory_input_stream_add_bytes(GMemoryInputStream* stream, GBytes* bytes);
1203        void g_memory_input_stream_add_data(GMemoryInputStream* stream, void* data, ptrdiff_t len, GDestroyNotify destroy);
1204
1205        // gio.MemoryOutputStream
1206
1207        GType g_memory_output_stream_get_type();
1208        GOutputStream* g_memory_output_stream_new(void* data, size_t size, GReallocFunc reallocFunction, GDestroyNotify destroyFunction);
1209        GOutputStream* g_memory_output_stream_new_resizable();
1210        void* g_memory_output_stream_get_data(GMemoryOutputStream* ostream);
1211        size_t g_memory_output_stream_get_data_size(GMemoryOutputStream* ostream);
1212        size_t g_memory_output_stream_get_size(GMemoryOutputStream* ostream);
1213        GBytes* g_memory_output_stream_steal_as_bytes(GMemoryOutputStream* ostream);
1214        void* g_memory_output_stream_steal_data(GMemoryOutputStream* ostream);
1215
1216        // gio.Menu
1217
1218        GType g_menu_get_type();
1219        GMenu* g_menu_new();
1220        void g_menu_append(GMenu* menu, const(char)* label, const(char)* detailedAction);
1221        void g_menu_append_item(GMenu* menu, GMenuItem* item);
1222        void g_menu_append_section(GMenu* menu, const(char)* label, GMenuModel* section);
1223        void g_menu_append_submenu(GMenu* menu, const(char)* label, GMenuModel* submenu);
1224        void g_menu_freeze(GMenu* menu);
1225        void g_menu_insert(GMenu* menu, int position, const(char)* label, const(char)* detailedAction);
1226        void g_menu_insert_item(GMenu* menu, int position, GMenuItem* item);
1227        void g_menu_insert_section(GMenu* menu, int position, const(char)* label, GMenuModel* section);
1228        void g_menu_insert_submenu(GMenu* menu, int position, const(char)* label, GMenuModel* submenu);
1229        void g_menu_prepend(GMenu* menu, const(char)* label, const(char)* detailedAction);
1230        void g_menu_prepend_item(GMenu* menu, GMenuItem* item);
1231        void g_menu_prepend_section(GMenu* menu, const(char)* label, GMenuModel* section);
1232        void g_menu_prepend_submenu(GMenu* menu, const(char)* label, GMenuModel* submenu);
1233        void g_menu_remove(GMenu* menu, int position);
1234        void g_menu_remove_all(GMenu* menu);
1235
1236        // gio.MenuAttributeIter
1237
1238        GType g_menu_attribute_iter_get_type();
1239        const(char)* g_menu_attribute_iter_get_name(GMenuAttributeIter* iter);
1240        int g_menu_attribute_iter_get_next(GMenuAttributeIter* iter, char** outName, GVariant** value);
1241        GVariant* g_menu_attribute_iter_get_value(GMenuAttributeIter* iter);
1242        int g_menu_attribute_iter_next(GMenuAttributeIter* iter);
1243
1244        // gio.MenuItem
1245
1246        GType g_menu_item_get_type();
1247        GMenuItem* g_menu_item_new(const(char)* label, const(char)* detailedAction);
1248        GMenuItem* g_menu_item_new_from_model(GMenuModel* model, int itemIndex);
1249        GMenuItem* g_menu_item_new_section(const(char)* label, GMenuModel* section);
1250        GMenuItem* g_menu_item_new_submenu(const(char)* label, GMenuModel* submenu);
1251        int g_menu_item_get_attribute(GMenuItem* menuItem, const(char)* attribute, const(char)* formatString, ... );
1252        GVariant* g_menu_item_get_attribute_value(GMenuItem* menuItem, const(char)* attribute, GVariantType* expectedType);
1253        GMenuModel* g_menu_item_get_link(GMenuItem* menuItem, const(char)* link);
1254        void g_menu_item_set_action_and_target(GMenuItem* menuItem, const(char)* action, const(char)* formatString, ... );
1255        void g_menu_item_set_action_and_target_value(GMenuItem* menuItem, const(char)* action, GVariant* targetValue);
1256        void g_menu_item_set_attribute(GMenuItem* menuItem, const(char)* attribute, const(char)* formatString, ... );
1257        void g_menu_item_set_attribute_value(GMenuItem* menuItem, const(char)* attribute, GVariant* value);
1258        void g_menu_item_set_detailed_action(GMenuItem* menuItem, const(char)* detailedAction);
1259        void g_menu_item_set_icon(GMenuItem* menuItem, GIcon* icon);
1260        void g_menu_item_set_label(GMenuItem* menuItem, const(char)* label);
1261        void g_menu_item_set_link(GMenuItem* menuItem, const(char)* link, GMenuModel* model);
1262        void g_menu_item_set_section(GMenuItem* menuItem, GMenuModel* section);
1263        void g_menu_item_set_submenu(GMenuItem* menuItem, GMenuModel* submenu);
1264
1265        // gio.MenuLinkIter
1266
1267        GType g_menu_link_iter_get_type();
1268        const(char)* g_menu_link_iter_get_name(GMenuLinkIter* iter);
1269        int g_menu_link_iter_get_next(GMenuLinkIter* iter, char** outLink, GMenuModel** value);
1270        GMenuModel* g_menu_link_iter_get_value(GMenuLinkIter* iter);
1271        int g_menu_link_iter_next(GMenuLinkIter* iter);
1272
1273        // gio.MenuModel
1274
1275        GType g_menu_model_get_type();
1276        int g_menu_model_get_item_attribute(GMenuModel* model, int itemIndex, const(char)* attribute, const(char)* formatString, ... );
1277        GVariant* g_menu_model_get_item_attribute_value(GMenuModel* model, int itemIndex, const(char)* attribute, GVariantType* expectedType);
1278        GMenuModel* g_menu_model_get_item_link(GMenuModel* model, int itemIndex, const(char)* link);
1279        int g_menu_model_get_n_items(GMenuModel* model);
1280        int g_menu_model_is_mutable(GMenuModel* model);
1281        void g_menu_model_items_changed(GMenuModel* model, int position, int removed, int added);
1282        GMenuAttributeIter* g_menu_model_iterate_item_attributes(GMenuModel* model, int itemIndex);
1283        GMenuLinkIter* g_menu_model_iterate_item_links(GMenuModel* model, int itemIndex);
1284
1285        // gio.Mount
1286
1287        GType g_mount_get_type();
1288        int g_mount_can_eject(GMount* mount);
1289        int g_mount_can_unmount(GMount* mount);
1290        void g_mount_eject(GMount* mount, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1291        int g_mount_eject_finish(GMount* mount, GAsyncResult* result, GError** err);
1292        void g_mount_eject_with_operation(GMount* mount, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1293        int g_mount_eject_with_operation_finish(GMount* mount, GAsyncResult* result, GError** err);
1294        GFile* g_mount_get_default_location(GMount* mount);
1295        GDrive* g_mount_get_drive(GMount* mount);
1296        GIcon* g_mount_get_icon(GMount* mount);
1297        char* g_mount_get_name(GMount* mount);
1298        GFile* g_mount_get_root(GMount* mount);
1299        const(char)* g_mount_get_sort_key(GMount* mount);
1300        GIcon* g_mount_get_symbolic_icon(GMount* mount);
1301        char* g_mount_get_uuid(GMount* mount);
1302        GVolume* g_mount_get_volume(GMount* mount);
1303        void g_mount_guess_content_type(GMount* mount, int forceRescan, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1304        char** g_mount_guess_content_type_finish(GMount* mount, GAsyncResult* result, GError** err);
1305        char** g_mount_guess_content_type_sync(GMount* mount, int forceRescan, GCancellable* cancellable, GError** err);
1306        int g_mount_is_shadowed(GMount* mount);
1307        void g_mount_remount(GMount* mount, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1308        int g_mount_remount_finish(GMount* mount, GAsyncResult* result, GError** err);
1309        void g_mount_shadow(GMount* mount);
1310        void g_mount_unmount(GMount* mount, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1311        int g_mount_unmount_finish(GMount* mount, GAsyncResult* result, GError** err);
1312        void g_mount_unmount_with_operation(GMount* mount, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1313        int g_mount_unmount_with_operation_finish(GMount* mount, GAsyncResult* result, GError** err);
1314        void g_mount_unshadow(GMount* mount);
1315
1316        // gio.MountOperation
1317
1318        GType g_mount_operation_get_type();
1319        GMountOperation* g_mount_operation_new();
1320        int g_mount_operation_get_anonymous(GMountOperation* op);
1321        int g_mount_operation_get_choice(GMountOperation* op);
1322        const(char)* g_mount_operation_get_domain(GMountOperation* op);
1323        const(char)* g_mount_operation_get_password(GMountOperation* op);
1324        GPasswordSave g_mount_operation_get_password_save(GMountOperation* op);
1325        const(char)* g_mount_operation_get_username(GMountOperation* op);
1326        void g_mount_operation_reply(GMountOperation* op, GMountOperationResult result);
1327        void g_mount_operation_set_anonymous(GMountOperation* op, int anonymous);
1328        void g_mount_operation_set_choice(GMountOperation* op, int choice);
1329        void g_mount_operation_set_domain(GMountOperation* op, const(char)* domain);
1330        void g_mount_operation_set_password(GMountOperation* op, const(char)* password);
1331        void g_mount_operation_set_password_save(GMountOperation* op, GPasswordSave save);
1332        void g_mount_operation_set_username(GMountOperation* op, const(char)* username);
1333
1334        // gio.NativeVolumeMonitor
1335
1336        GType g_native_volume_monitor_get_type();
1337
1338        // gio.NetworkAddress
1339
1340        GType g_network_address_get_type();
1341        GSocketConnectable* g_network_address_new(const(char)* hostname, ushort port);
1342        GSocketConnectable* g_network_address_new_loopback(ushort port);
1343        GSocketConnectable* g_network_address_parse(const(char)* hostAndPort, ushort defaultPort, GError** err);
1344        GSocketConnectable* g_network_address_parse_uri(const(char)* uri, ushort defaultPort, GError** err);
1345        const(char)* g_network_address_get_hostname(GNetworkAddress* addr);
1346        ushort g_network_address_get_port(GNetworkAddress* addr);
1347        const(char)* g_network_address_get_scheme(GNetworkAddress* addr);
1348
1349        // gio.NetworkMonitor
1350
1351        GType g_network_monitor_get_type();
1352        GNetworkMonitor* g_network_monitor_get_default();
1353        int g_network_monitor_can_reach(GNetworkMonitor* monitor, GSocketConnectable* connectable, GCancellable* cancellable, GError** err);
1354        void g_network_monitor_can_reach_async(GNetworkMonitor* monitor, GSocketConnectable* connectable, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1355        int g_network_monitor_can_reach_finish(GNetworkMonitor* monitor, GAsyncResult* result, GError** err);
1356        GNetworkConnectivity g_network_monitor_get_connectivity(GNetworkMonitor* monitor);
1357        int g_network_monitor_get_network_available(GNetworkMonitor* monitor);
1358        int g_network_monitor_get_network_metered(GNetworkMonitor* monitor);
1359
1360        // gio.NetworkService
1361
1362        GType g_network_service_get_type();
1363        GSocketConnectable* g_network_service_new(const(char)* service, const(char)* protocol, const(char)* domain);
1364        const(char)* g_network_service_get_domain(GNetworkService* srv);
1365        const(char)* g_network_service_get_protocol(GNetworkService* srv);
1366        const(char)* g_network_service_get_scheme(GNetworkService* srv);
1367        const(char)* g_network_service_get_service(GNetworkService* srv);
1368        void g_network_service_set_scheme(GNetworkService* srv, const(char)* scheme);
1369
1370        // gio.Notification
1371
1372        GType g_notification_get_type();
1373        GNotification* g_notification_new(const(char)* title);
1374        void g_notification_add_button(GNotification* notification, const(char)* label, const(char)* detailedAction);
1375        void g_notification_add_button_with_target(GNotification* notification, const(char)* label, const(char)* action, const(char)* targetFormat, ... );
1376        void g_notification_add_button_with_target_value(GNotification* notification, const(char)* label, const(char)* action, GVariant* target);
1377        void g_notification_set_body(GNotification* notification, const(char)* bod);
1378        void g_notification_set_default_action(GNotification* notification, const(char)* detailedAction);
1379        void g_notification_set_default_action_and_target(GNotification* notification, const(char)* action, const(char)* targetFormat, ... );
1380        void g_notification_set_default_action_and_target_value(GNotification* notification, const(char)* action, GVariant* target);
1381        void g_notification_set_icon(GNotification* notification, GIcon* icon);
1382        void g_notification_set_priority(GNotification* notification, GNotificationPriority priority);
1383        void g_notification_set_title(GNotification* notification, const(char)* title);
1384        void g_notification_set_urgent(GNotification* notification, int urgent);
1385
1386        // gio.OutputStream
1387
1388        GType g_output_stream_get_type();
1389        void g_output_stream_clear_pending(GOutputStream* stream);
1390        int g_output_stream_close(GOutputStream* stream, GCancellable* cancellable, GError** err);
1391        void g_output_stream_close_async(GOutputStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1392        int g_output_stream_close_finish(GOutputStream* stream, GAsyncResult* result, GError** err);
1393        int g_output_stream_flush(GOutputStream* stream, GCancellable* cancellable, GError** err);
1394        void g_output_stream_flush_async(GOutputStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1395        int g_output_stream_flush_finish(GOutputStream* stream, GAsyncResult* result, GError** err);
1396        int g_output_stream_has_pending(GOutputStream* stream);
1397        int g_output_stream_is_closed(GOutputStream* stream);
1398        int g_output_stream_is_closing(GOutputStream* stream);
1399        int g_output_stream_printf(GOutputStream* stream, size_t* bytesWritten, GCancellable* cancellable, GError** error, const(char)* format, ... );
1400        int g_output_stream_set_pending(GOutputStream* stream, GError** err);
1401        ptrdiff_t g_output_stream_splice(GOutputStream* stream, GInputStream* source, GOutputStreamSpliceFlags flags, GCancellable* cancellable, GError** err);
1402        void g_output_stream_splice_async(GOutputStream* stream, GInputStream* source, GOutputStreamSpliceFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1403        ptrdiff_t g_output_stream_splice_finish(GOutputStream* stream, GAsyncResult* result, GError** err);
1404        int g_output_stream_vprintf(GOutputStream* stream, size_t* bytesWritten, GCancellable* cancellable, GError** error, const(char)* format, void* args);
1405        ptrdiff_t g_output_stream_write(GOutputStream* stream, void* buffer, size_t count, GCancellable* cancellable, GError** err);
1406        int g_output_stream_write_all(GOutputStream* stream, void* buffer, size_t count, size_t* bytesWritten, GCancellable* cancellable, GError** err);
1407        void g_output_stream_write_all_async(GOutputStream* stream, void* buffer, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1408        int g_output_stream_write_all_finish(GOutputStream* stream, GAsyncResult* result, size_t* bytesWritten, GError** err);
1409        void g_output_stream_write_async(GOutputStream* stream, void* buffer, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1410        ptrdiff_t g_output_stream_write_bytes(GOutputStream* stream, GBytes* bytes, GCancellable* cancellable, GError** err);
1411        void g_output_stream_write_bytes_async(GOutputStream* stream, GBytes* bytes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1412        ptrdiff_t g_output_stream_write_bytes_finish(GOutputStream* stream, GAsyncResult* result, GError** err);
1413        ptrdiff_t g_output_stream_write_finish(GOutputStream* stream, GAsyncResult* result, GError** err);
1414
1415        // gio.Permission
1416
1417        GType g_permission_get_type();
1418        int g_permission_acquire(GPermission* permission, GCancellable* cancellable, GError** err);
1419        void g_permission_acquire_async(GPermission* permission, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1420        int g_permission_acquire_finish(GPermission* permission, GAsyncResult* result, GError** err);
1421        int g_permission_get_allowed(GPermission* permission);
1422        int g_permission_get_can_acquire(GPermission* permission);
1423        int g_permission_get_can_release(GPermission* permission);
1424        void g_permission_impl_update(GPermission* permission, int allowed, int canAcquire, int canRelease);
1425        int g_permission_release(GPermission* permission, GCancellable* cancellable, GError** err);
1426        void g_permission_release_async(GPermission* permission, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1427        int g_permission_release_finish(GPermission* permission, GAsyncResult* result, GError** err);
1428
1429        // gio.PollableInputStream
1430
1431        GType g_pollable_input_stream_get_type();
1432        int g_pollable_input_stream_can_poll(GPollableInputStream* stream);
1433        GSource* g_pollable_input_stream_create_source(GPollableInputStream* stream, GCancellable* cancellable);
1434        int g_pollable_input_stream_is_readable(GPollableInputStream* stream);
1435        ptrdiff_t g_pollable_input_stream_read_nonblocking(GPollableInputStream* stream, void* buffer, size_t count, GCancellable* cancellable, GError** err);
1436
1437        // gio.PollableOutputStream
1438
1439        GType g_pollable_output_stream_get_type();
1440        int g_pollable_output_stream_can_poll(GPollableOutputStream* stream);
1441        GSource* g_pollable_output_stream_create_source(GPollableOutputStream* stream, GCancellable* cancellable);
1442        int g_pollable_output_stream_is_writable(GPollableOutputStream* stream);
1443        ptrdiff_t g_pollable_output_stream_write_nonblocking(GPollableOutputStream* stream, void* buffer, size_t count, GCancellable* cancellable, GError** err);
1444
1445        // gio.PropertyAction
1446
1447        GType g_property_action_get_type();
1448        GPropertyAction* g_property_action_new(const(char)* name, void* object, const(char)* propertyName);
1449
1450        // gio.Proxy
1451
1452        GType g_proxy_get_type();
1453        GProxy* g_proxy_get_default_for_protocol(const(char)* protocol);
1454        GIOStream* g_proxy_connect(GProxy* proxy, GIOStream* connection, GProxyAddress* proxyAddress, GCancellable* cancellable, GError** err);
1455        void g_proxy_connect_async(GProxy* proxy, GIOStream* connection, GProxyAddress* proxyAddress, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1456        GIOStream* g_proxy_connect_finish(GProxy* proxy, GAsyncResult* result, GError** err);
1457        int g_proxy_supports_hostname(GProxy* proxy);
1458
1459        // gio.ProxyAddress
1460
1461        GType g_proxy_address_get_type();
1462        GSocketAddress* g_proxy_address_new(GInetAddress* inetaddr, ushort port, const(char)* protocol, const(char)* destHostname, ushort destPort, const(char)* username, const(char)* password);
1463        const(char)* g_proxy_address_get_destination_hostname(GProxyAddress* proxy);
1464        ushort g_proxy_address_get_destination_port(GProxyAddress* proxy);
1465        const(char)* g_proxy_address_get_destination_protocol(GProxyAddress* proxy);
1466        const(char)* g_proxy_address_get_password(GProxyAddress* proxy);
1467        const(char)* g_proxy_address_get_protocol(GProxyAddress* proxy);
1468        const(char)* g_proxy_address_get_uri(GProxyAddress* proxy);
1469        const(char)* g_proxy_address_get_username(GProxyAddress* proxy);
1470
1471        // gio.ProxyAddressEnumerator
1472
1473        GType g_proxy_address_enumerator_get_type();
1474
1475        // gio.ProxyResolver
1476
1477        GType g_proxy_resolver_get_type();
1478        GProxyResolver* g_proxy_resolver_get_default();
1479        int g_proxy_resolver_is_supported(GProxyResolver* resolver);
1480        char** g_proxy_resolver_lookup(GProxyResolver* resolver, const(char)* uri, GCancellable* cancellable, GError** err);
1481        void g_proxy_resolver_lookup_async(GProxyResolver* resolver, const(char)* uri, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1482        char** g_proxy_resolver_lookup_finish(GProxyResolver* resolver, GAsyncResult* result, GError** err);
1483
1484        // gio.RemoteActionGroup
1485
1486        GType g_remote_action_group_get_type();
1487        void g_remote_action_group_activate_action_full(GRemoteActionGroup* remote, const(char)* actionName, GVariant* parameter, GVariant* platformData);
1488        void g_remote_action_group_change_action_state_full(GRemoteActionGroup* remote, const(char)* actionName, GVariant* value, GVariant* platformData);
1489
1490        // gio.Resolver
1491
1492        GType g_resolver_get_type();
1493        void g_resolver_free_addresses(GList* addresses);
1494        void g_resolver_free_targets(GList* targets);
1495        GResolver* g_resolver_get_default();
1496        char* g_resolver_lookup_by_address(GResolver* resolver, GInetAddress* address, GCancellable* cancellable, GError** err);
1497        void g_resolver_lookup_by_address_async(GResolver* resolver, GInetAddress* address, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1498        char* g_resolver_lookup_by_address_finish(GResolver* resolver, GAsyncResult* result, GError** err);
1499        GList* g_resolver_lookup_by_name(GResolver* resolver, const(char)* hostname, GCancellable* cancellable, GError** err);
1500        void g_resolver_lookup_by_name_async(GResolver* resolver, const(char)* hostname, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1501        GList* g_resolver_lookup_by_name_finish(GResolver* resolver, GAsyncResult* result, GError** err);
1502        GList* g_resolver_lookup_records(GResolver* resolver, const(char)* rrname, GResolverRecordType recordType, GCancellable* cancellable, GError** err);
1503        void g_resolver_lookup_records_async(GResolver* resolver, const(char)* rrname, GResolverRecordType recordType, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1504        GList* g_resolver_lookup_records_finish(GResolver* resolver, GAsyncResult* result, GError** err);
1505        GList* g_resolver_lookup_service(GResolver* resolver, const(char)* service, const(char)* protocol, const(char)* domain, GCancellable* cancellable, GError** err);
1506        void g_resolver_lookup_service_async(GResolver* resolver, const(char)* service, const(char)* protocol, const(char)* domain, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1507        GList* g_resolver_lookup_service_finish(GResolver* resolver, GAsyncResult* result, GError** err);
1508        void g_resolver_set_default(GResolver* resolver);
1509
1510        // gio.Resource
1511
1512        GType g_resource_get_type();
1513        GResource* g_resource_new_from_data(GBytes* data, GError** err);
1514        void g_resources_register(GResource* resource);
1515        void g_resources_unregister(GResource* resource);
1516        char** g_resource_enumerate_children(GResource* resource, const(char)* path, GResourceLookupFlags lookupFlags, GError** err);
1517        int g_resource_get_info(GResource* resource, const(char)* path, GResourceLookupFlags lookupFlags, size_t* size, uint* flags, GError** err);
1518        GBytes* g_resource_lookup_data(GResource* resource, const(char)* path, GResourceLookupFlags lookupFlags, GError** err);
1519        GInputStream* g_resource_open_stream(GResource* resource, const(char)* path, GResourceLookupFlags lookupFlags, GError** err);
1520        GResource* g_resource_ref(GResource* resource);
1521        void g_resource_unref(GResource* resource);
1522        GResource* g_resource_load(char* filename, GError** err);
1523        char** g_resources_enumerate_children(const(char)* path, GResourceLookupFlags lookupFlags, GError** err);
1524        int g_resources_get_info(const(char)* path, GResourceLookupFlags lookupFlags, size_t* size, uint* flags, GError** err);
1525        GBytes* g_resources_lookup_data(const(char)* path, GResourceLookupFlags lookupFlags, GError** err);
1526        GInputStream* g_resources_open_stream(const(char)* path, GResourceLookupFlags lookupFlags, GError** err);
1527
1528        // gio.Seekable
1529
1530        GType g_seekable_get_type();
1531        int g_seekable_can_seek(GSeekable* seekable);
1532        int g_seekable_can_truncate(GSeekable* seekable);
1533        int g_seekable_seek(GSeekable* seekable, long offset, GSeekType type, GCancellable* cancellable, GError** err);
1534        long g_seekable_tell(GSeekable* seekable);
1535        int g_seekable_truncate(GSeekable* seekable, long offset, GCancellable* cancellable, GError** err);
1536
1537        // gio.Settings
1538
1539        GType g_settings_get_type();
1540        GSettings* g_settings_new(const(char)* schemaId);
1541        GSettings* g_settings_new_full(GSettingsSchema* schema, GSettingsBackend* backend, const(char)* path);
1542        GSettings* g_settings_new_with_backend(const(char)* schemaId, GSettingsBackend* backend);
1543        GSettings* g_settings_new_with_backend_and_path(const(char)* schemaId, GSettingsBackend* backend, const(char)* path);
1544        GSettings* g_settings_new_with_path(const(char)* schemaId, const(char)* path);
1545        char** g_settings_list_relocatable_schemas();
1546        char** g_settings_list_schemas();
1547        void g_settings_sync();
1548        void g_settings_unbind(void* object, const(char)* property);
1549        void g_settings_apply(GSettings* settings);
1550        void g_settings_bind(GSettings* settings, const(char)* key, void* object, const(char)* property, GSettingsBindFlags flags);
1551        void g_settings_bind_with_mapping(GSettings* settings, const(char)* key, void* object, const(char)* property, GSettingsBindFlags flags, GSettingsBindGetMapping getMapping, GSettingsBindSetMapping setMapping, void* userData, GDestroyNotify destroy);
1552        void g_settings_bind_writable(GSettings* settings, const(char)* key, void* object, const(char)* property, int inverted);
1553        GAction* g_settings_create_action(GSettings* settings, const(char)* key);
1554        void g_settings_delay(GSettings* settings);
1555        void g_settings_get(GSettings* settings, const(char)* key, const(char)* format, ... );
1556        int g_settings_get_boolean(GSettings* settings, const(char)* key);
1557        GSettings* g_settings_get_child(GSettings* settings, const(char)* name);
1558        GVariant* g_settings_get_default_value(GSettings* settings, const(char)* key);
1559        double g_settings_get_double(GSettings* settings, const(char)* key);
1560        int g_settings_get_enum(GSettings* settings, const(char)* key);
1561        uint g_settings_get_flags(GSettings* settings, const(char)* key);
1562        int g_settings_get_has_unapplied(GSettings* settings);
1563        int g_settings_get_int(GSettings* settings, const(char)* key);
1564        void* g_settings_get_mapped(GSettings* settings, const(char)* key, GSettingsGetMapping mapping, void* userData);
1565        GVariant* g_settings_get_range(GSettings* settings, const(char)* key);
1566        char* g_settings_get_string(GSettings* settings, const(char)* key);
1567        char** g_settings_get_strv(GSettings* settings, const(char)* key);
1568        uint g_settings_get_uint(GSettings* settings, const(char)* key);
1569        GVariant* g_settings_get_user_value(GSettings* settings, const(char)* key);
1570        GVariant* g_settings_get_value(GSettings* settings, const(char)* key);
1571        int g_settings_is_writable(GSettings* settings, const(char)* name);
1572        char** g_settings_list_children(GSettings* settings);
1573        char** g_settings_list_keys(GSettings* settings);
1574        int g_settings_range_check(GSettings* settings, const(char)* key, GVariant* value);
1575        void g_settings_reset(GSettings* settings, const(char)* key);
1576        void g_settings_revert(GSettings* settings);
1577        int g_settings_set(GSettings* settings, const(char)* key, const(char)* format, ... );
1578        int g_settings_set_boolean(GSettings* settings, const(char)* key, int value);
1579        int g_settings_set_double(GSettings* settings, const(char)* key, double value);
1580        int g_settings_set_enum(GSettings* settings, const(char)* key, int value);
1581        int g_settings_set_flags(GSettings* settings, const(char)* key, uint value);
1582        int g_settings_set_int(GSettings* settings, const(char)* key, int value);
1583        int g_settings_set_string(GSettings* settings, const(char)* key, const(char)* value);
1584        int g_settings_set_strv(GSettings* settings, const(char)* key, char** value);
1585        int g_settings_set_uint(GSettings* settings, const(char)* key, uint value);
1586        int g_settings_set_value(GSettings* settings, const(char)* key, GVariant* value);
1587
1588        // gio.SettingsSchema
1589
1590        GType g_settings_schema_get_type();
1591        const(char)* g_settings_schema_get_id(GSettingsSchema* schema);
1592        GSettingsSchemaKey* g_settings_schema_get_key(GSettingsSchema* schema, const(char)* name);
1593        const(char)* g_settings_schema_get_path(GSettingsSchema* schema);
1594        int g_settings_schema_has_key(GSettingsSchema* schema, const(char)* name);
1595        char** g_settings_schema_list_children(GSettingsSchema* schema);
1596        char** g_settings_schema_list_keys(GSettingsSchema* schema);
1597        GSettingsSchema* g_settings_schema_ref(GSettingsSchema* schema);
1598        void g_settings_schema_unref(GSettingsSchema* schema);
1599
1600        // gio.SettingsSchemaKey
1601
1602        GType g_settings_schema_key_get_type();
1603        GVariant* g_settings_schema_key_get_default_value(GSettingsSchemaKey* key);
1604        const(char)* g_settings_schema_key_get_description(GSettingsSchemaKey* key);
1605        const(char)* g_settings_schema_key_get_name(GSettingsSchemaKey* key);
1606        GVariant* g_settings_schema_key_get_range(GSettingsSchemaKey* key);
1607        const(char)* g_settings_schema_key_get_summary(GSettingsSchemaKey* key);
1608        GVariantType* g_settings_schema_key_get_value_type(GSettingsSchemaKey* key);
1609        int g_settings_schema_key_range_check(GSettingsSchemaKey* key, GVariant* value);
1610        GSettingsSchemaKey* g_settings_schema_key_ref(GSettingsSchemaKey* key);
1611        void g_settings_schema_key_unref(GSettingsSchemaKey* key);
1612
1613        // gio.SettingsSchemaSource
1614
1615        GType g_settings_schema_source_get_type();
1616        GSettingsSchemaSource* g_settings_schema_source_new_from_directory(const(char)* directory, GSettingsSchemaSource* parent, int trusted, GError** err);
1617        void g_settings_schema_source_list_schemas(GSettingsSchemaSource* source, int recursive, char*** nonRelocatable, char*** relocatable);
1618        GSettingsSchema* g_settings_schema_source_lookup(GSettingsSchemaSource* source, const(char)* schemaId, int recursive);
1619        GSettingsSchemaSource* g_settings_schema_source_ref(GSettingsSchemaSource* source);
1620        void g_settings_schema_source_unref(GSettingsSchemaSource* source);
1621        GSettingsSchemaSource* g_settings_schema_source_get_default();
1622
1623        // gio.SimpleAction
1624
1625        GType g_simple_action_get_type();
1626        GSimpleAction* g_simple_action_new(const(char)* name, GVariantType* parameterType);
1627        GSimpleAction* g_simple_action_new_stateful(const(char)* name, GVariantType* parameterType, GVariant* state);
1628        void g_simple_action_set_enabled(GSimpleAction* simple, int enabled);
1629        void g_simple_action_set_state(GSimpleAction* simple, GVariant* value);
1630        void g_simple_action_set_state_hint(GSimpleAction* simple, GVariant* stateHint);
1631
1632        // gio.SimpleActionGroup
1633
1634        GType g_simple_action_group_get_type();
1635        GSimpleActionGroup* g_simple_action_group_new();
1636        void g_simple_action_group_add_entries(GSimpleActionGroup* simple, GActionEntry* entries, int nEntries, void* userData);
1637        void g_simple_action_group_insert(GSimpleActionGroup* simple, GAction* action);
1638        GAction* g_simple_action_group_lookup(GSimpleActionGroup* simple, const(char)* actionName);
1639        void g_simple_action_group_remove(GSimpleActionGroup* simple, const(char)* actionName);
1640
1641        // gio.SimpleAsyncResult
1642
1643        GType g_simple_async_result_get_type();
1644        GSimpleAsyncResult* g_simple_async_result_new(GObject* sourceObject, GAsyncReadyCallback callback, void* userData, void* sourceTag);
1645        GSimpleAsyncResult* g_simple_async_result_new_error(GObject* sourceObject, GAsyncReadyCallback callback, void* userData, GQuark domain, int code, const(char)* format, ... );
1646        GSimpleAsyncResult* g_simple_async_result_new_from_error(GObject* sourceObject, GAsyncReadyCallback callback, void* userData, GError* error);
1647        GSimpleAsyncResult* g_simple_async_result_new_take_error(GObject* sourceObject, GAsyncReadyCallback callback, void* userData, GError* error);
1648        int g_simple_async_result_is_valid(GAsyncResult* result, GObject* source, void* sourceTag);
1649        void g_simple_async_result_complete(GSimpleAsyncResult* simple);
1650        void g_simple_async_result_complete_in_idle(GSimpleAsyncResult* simple);
1651        int g_simple_async_result_get_op_res_gboolean(GSimpleAsyncResult* simple);
1652        void* g_simple_async_result_get_op_res_gpointer(GSimpleAsyncResult* simple);
1653        ptrdiff_t g_simple_async_result_get_op_res_gssize(GSimpleAsyncResult* simple);
1654        void* g_simple_async_result_get_source_tag(GSimpleAsyncResult* simple);
1655        int g_simple_async_result_propagate_error(GSimpleAsyncResult* simple, GError** err);
1656        void g_simple_async_result_run_in_thread(GSimpleAsyncResult* simple, GSimpleAsyncThreadFunc func, int ioPriority, GCancellable* cancellable);
1657        void g_simple_async_result_set_check_cancellable(GSimpleAsyncResult* simple, GCancellable* checkCancellable);
1658        void g_simple_async_result_set_error(GSimpleAsyncResult* simple, GQuark domain, int code, const(char)* format, ... );
1659        void g_simple_async_result_set_error_va(GSimpleAsyncResult* simple, GQuark domain, int code, const(char)* format, void* args);
1660        void g_simple_async_result_set_from_error(GSimpleAsyncResult* simple, GError* error);
1661        void g_simple_async_result_set_handle_cancellation(GSimpleAsyncResult* simple, int handleCancellation);
1662        void g_simple_async_result_set_op_res_gboolean(GSimpleAsyncResult* simple, int opRes);
1663        void g_simple_async_result_set_op_res_gpointer(GSimpleAsyncResult* simple, void* opRes, GDestroyNotify destroyOpRes);
1664        void g_simple_async_result_set_op_res_gssize(GSimpleAsyncResult* simple, ptrdiff_t opRes);
1665        void g_simple_async_result_take_error(GSimpleAsyncResult* simple, GError* error);
1666        void g_simple_async_report_error_in_idle(GObject* object, GAsyncReadyCallback callback, void* userData, GQuark domain, int code, const(char)* format, ... );
1667        void g_simple_async_report_gerror_in_idle(GObject* object, GAsyncReadyCallback callback, void* userData, GError* error);
1668        void g_simple_async_report_take_gerror_in_idle(GObject* object, GAsyncReadyCallback callback, void* userData, GError* error);
1669
1670        // gio.SimpleIOStream
1671
1672        GType g_simple_io_stream_get_type();
1673        GIOStream* g_simple_io_stream_new(GInputStream* inputStream, GOutputStream* outputStream);
1674
1675        // gio.SimplePermission
1676
1677        GType g_simple_permission_get_type();
1678        GPermission* g_simple_permission_new(int allowed);
1679
1680        // gio.SimpleProxyResolver
1681
1682        GType g_simple_proxy_resolver_get_type();
1683        GProxyResolver* g_simple_proxy_resolver_new(const(char)* defaultProxy, char** ignoreHosts);
1684        void g_simple_proxy_resolver_set_default_proxy(GSimpleProxyResolver* resolver, const(char)* defaultProxy);
1685        void g_simple_proxy_resolver_set_ignore_hosts(GSimpleProxyResolver* resolver, char** ignoreHosts);
1686        void g_simple_proxy_resolver_set_uri_proxy(GSimpleProxyResolver* resolver, const(char)* uriScheme, const(char)* proxy);
1687
1688        // gio.Socket
1689
1690        GType g_socket_get_type();
1691        GSocket* g_socket_new(GSocketFamily family, GSocketType type, GSocketProtocol protocol, GError** err);
1692        GSocket* g_socket_new_from_fd(int fd, GError** err);
1693        GSocket* g_socket_accept(GSocket* socket, GCancellable* cancellable, GError** err);
1694        int g_socket_bind(GSocket* socket, GSocketAddress* address, int allowReuse, GError** err);
1695        int g_socket_check_connect_result(GSocket* socket, GError** err);
1696        int g_socket_close(GSocket* socket, GError** err);
1697        GIOCondition g_socket_condition_check(GSocket* socket, GIOCondition condition);
1698        int g_socket_condition_timed_wait(GSocket* socket, GIOCondition condition, long timeout, GCancellable* cancellable, GError** err);
1699        int g_socket_condition_wait(GSocket* socket, GIOCondition condition, GCancellable* cancellable, GError** err);
1700        int g_socket_connect(GSocket* socket, GSocketAddress* address, GCancellable* cancellable, GError** err);
1701        GSocketConnection* g_socket_connection_factory_create_connection(GSocket* socket);
1702        GSource* g_socket_create_source(GSocket* socket, GIOCondition condition, GCancellable* cancellable);
1703        ptrdiff_t g_socket_get_available_bytes(GSocket* socket);
1704        int g_socket_get_blocking(GSocket* socket);
1705        int g_socket_get_broadcast(GSocket* socket);
1706        GCredentials* g_socket_get_credentials(GSocket* socket, GError** err);
1707        GSocketFamily g_socket_get_family(GSocket* socket);
1708        int g_socket_get_fd(GSocket* socket);
1709        int g_socket_get_keepalive(GSocket* socket);
1710        int g_socket_get_listen_backlog(GSocket* socket);
1711        GSocketAddress* g_socket_get_local_address(GSocket* socket, GError** err);
1712        int g_socket_get_multicast_loopback(GSocket* socket);
1713        uint g_socket_get_multicast_ttl(GSocket* socket);
1714        int g_socket_get_option(GSocket* socket, int level, int optname, int* value, GError** err);
1715        GSocketProtocol g_socket_get_protocol(GSocket* socket);
1716        GSocketAddress* g_socket_get_remote_address(GSocket* socket, GError** err);
1717        GSocketType g_socket_get_socket_type(GSocket* socket);
1718        uint g_socket_get_timeout(GSocket* socket);
1719        uint g_socket_get_ttl(GSocket* socket);
1720        int g_socket_is_closed(GSocket* socket);
1721        int g_socket_is_connected(GSocket* socket);
1722        int g_socket_join_multicast_group(GSocket* socket, GInetAddress* group, int sourceSpecific, const(char)* iface, GError** err);
1723        int g_socket_leave_multicast_group(GSocket* socket, GInetAddress* group, int sourceSpecific, const(char)* iface, GError** err);
1724        int g_socket_listen(GSocket* socket, GError** err);
1725        ptrdiff_t g_socket_receive(GSocket* socket, char* buffer, size_t size, GCancellable* cancellable, GError** err);
1726        ptrdiff_t g_socket_receive_from(GSocket* socket, GSocketAddress** address, char* buffer, size_t size, GCancellable* cancellable, GError** err);
1727        ptrdiff_t g_socket_receive_message(GSocket* socket, GSocketAddress** address, GInputVector* vectors, int numVectors, GSocketControlMessage*** messages, int* numMessages, int* flags, GCancellable* cancellable, GError** err);
1728        int g_socket_receive_messages(GSocket* socket, GInputMessage* messages, uint numMessages, int flags, GCancellable* cancellable, GError** err);
1729        ptrdiff_t g_socket_receive_with_blocking(GSocket* socket, char* buffer, size_t size, int blocking, GCancellable* cancellable, GError** err);
1730        ptrdiff_t g_socket_send(GSocket* socket, char* buffer, size_t size, GCancellable* cancellable, GError** err);
1731        ptrdiff_t g_socket_send_message(GSocket* socket, GSocketAddress* address, GOutputVector* vectors, int numVectors, GSocketControlMessage** messages, int numMessages, int flags, GCancellable* cancellable, GError** err);
1732        int g_socket_send_messages(GSocket* socket, GOutputMessage* messages, uint numMessages, int flags, GCancellable* cancellable, GError** err);
1733        ptrdiff_t g_socket_send_to(GSocket* socket, GSocketAddress* address, char* buffer, size_t size, GCancellable* cancellable, GError** err);
1734        ptrdiff_t g_socket_send_with_blocking(GSocket* socket, char* buffer, size_t size, int blocking, GCancellable* cancellable, GError** err);
1735        void g_socket_set_blocking(GSocket* socket, int blocking);
1736        void g_socket_set_broadcast(GSocket* socket, int broadcast);
1737        void g_socket_set_keepalive(GSocket* socket, int keepalive);
1738        void g_socket_set_listen_backlog(GSocket* socket, int backlog);
1739        void g_socket_set_multicast_loopback(GSocket* socket, int loopback);
1740        void g_socket_set_multicast_ttl(GSocket* socket, uint ttl);
1741        int g_socket_set_option(GSocket* socket, int level, int optname, int value, GError** err);
1742        void g_socket_set_timeout(GSocket* socket, uint timeout);
1743        void g_socket_set_ttl(GSocket* socket, uint ttl);
1744        int g_socket_shutdown(GSocket* socket, int shutdownRead, int shutdownWrite, GError** err);
1745        int g_socket_speaks_ipv4(GSocket* socket);
1746
1747        // gio.SocketAddress
1748
1749        GType g_socket_address_get_type();
1750        GSocketAddress* g_socket_address_new_from_native(void* native, size_t len);
1751        GSocketFamily g_socket_address_get_family(GSocketAddress* address);
1752        ptrdiff_t g_socket_address_get_native_size(GSocketAddress* address);
1753        int g_socket_address_to_native(GSocketAddress* address, void* dest, size_t destlen, GError** err);
1754
1755        // gio.SocketAddressEnumerator
1756
1757        GType g_socket_address_enumerator_get_type();
1758        GSocketAddress* g_socket_address_enumerator_next(GSocketAddressEnumerator* enumerator, GCancellable* cancellable, GError** err);
1759        void g_socket_address_enumerator_next_async(GSocketAddressEnumerator* enumerator, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1760        GSocketAddress* g_socket_address_enumerator_next_finish(GSocketAddressEnumerator* enumerator, GAsyncResult* result, GError** err);
1761
1762        // gio.SocketClient
1763
1764        GType g_socket_client_get_type();
1765        GSocketClient* g_socket_client_new();
1766        void g_socket_client_add_application_proxy(GSocketClient* client, const(char)* protocol);
1767        GSocketConnection* g_socket_client_connect(GSocketClient* client, GSocketConnectable* connectable, GCancellable* cancellable, GError** err);
1768        void g_socket_client_connect_async(GSocketClient* client, GSocketConnectable* connectable, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1769        GSocketConnection* g_socket_client_connect_finish(GSocketClient* client, GAsyncResult* result, GError** err);
1770        GSocketConnection* g_socket_client_connect_to_host(GSocketClient* client, const(char)* hostAndPort, ushort defaultPort, GCancellable* cancellable, GError** err);
1771        void g_socket_client_connect_to_host_async(GSocketClient* client, const(char)* hostAndPort, ushort defaultPort, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1772        GSocketConnection* g_socket_client_connect_to_host_finish(GSocketClient* client, GAsyncResult* result, GError** err);
1773        GSocketConnection* g_socket_client_connect_to_service(GSocketClient* client, const(char)* domain, const(char)* service, GCancellable* cancellable, GError** err);
1774        void g_socket_client_connect_to_service_async(GSocketClient* client, const(char)* domain, const(char)* service, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1775        GSocketConnection* g_socket_client_connect_to_service_finish(GSocketClient* client, GAsyncResult* result, GError** err);
1776        GSocketConnection* g_socket_client_connect_to_uri(GSocketClient* client, const(char)* uri, ushort defaultPort, GCancellable* cancellable, GError** err);
1777        void g_socket_client_connect_to_uri_async(GSocketClient* client, const(char)* uri, ushort defaultPort, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1778        GSocketConnection* g_socket_client_connect_to_uri_finish(GSocketClient* client, GAsyncResult* result, GError** err);
1779        int g_socket_client_get_enable_proxy(GSocketClient* client);
1780        GSocketFamily g_socket_client_get_family(GSocketClient* client);
1781        GSocketAddress* g_socket_client_get_local_address(GSocketClient* client);
1782        GSocketProtocol g_socket_client_get_protocol(GSocketClient* client);
1783        GProxyResolver* g_socket_client_get_proxy_resolver(GSocketClient* client);
1784        GSocketType g_socket_client_get_socket_type(GSocketClient* client);
1785        uint g_socket_client_get_timeout(GSocketClient* client);
1786        int g_socket_client_get_tls(GSocketClient* client);
1787        GTlsCertificateFlags g_socket_client_get_tls_validation_flags(GSocketClient* client);
1788        void g_socket_client_set_enable_proxy(GSocketClient* client, int enable);
1789        void g_socket_client_set_family(GSocketClient* client, GSocketFamily family);
1790        void g_socket_client_set_local_address(GSocketClient* client, GSocketAddress* address);
1791        void g_socket_client_set_protocol(GSocketClient* client, GSocketProtocol protocol);
1792        void g_socket_client_set_proxy_resolver(GSocketClient* client, GProxyResolver* proxyResolver);
1793        void g_socket_client_set_socket_type(GSocketClient* client, GSocketType type);
1794        void g_socket_client_set_timeout(GSocketClient* client, uint timeout);
1795        void g_socket_client_set_tls(GSocketClient* client, int tls);
1796        void g_socket_client_set_tls_validation_flags(GSocketClient* client, GTlsCertificateFlags flags);
1797
1798        // gio.SocketConnectable
1799
1800        GType g_socket_connectable_get_type();
1801        GSocketAddressEnumerator* g_socket_connectable_enumerate(GSocketConnectable* connectable);
1802        GSocketAddressEnumerator* g_socket_connectable_proxy_enumerate(GSocketConnectable* connectable);
1803        char* g_socket_connectable_to_string(GSocketConnectable* connectable);
1804
1805        // gio.SocketConnection
1806
1807        GType g_socket_connection_get_type();
1808        GType g_socket_connection_factory_lookup_type(GSocketFamily family, GSocketType type, int protocolId);
1809        void g_socket_connection_factory_register_type(GType gType, GSocketFamily family, GSocketType type, int protocol);
1810        int g_socket_connection_connect(GSocketConnection* connection, GSocketAddress* address, GCancellable* cancellable, GError** err);
1811        void g_socket_connection_connect_async(GSocketConnection* connection, GSocketAddress* address, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1812        int g_socket_connection_connect_finish(GSocketConnection* connection, GAsyncResult* result, GError** err);
1813        GSocketAddress* g_socket_connection_get_local_address(GSocketConnection* connection, GError** err);
1814        GSocketAddress* g_socket_connection_get_remote_address(GSocketConnection* connection, GError** err);
1815        GSocket* g_socket_connection_get_socket(GSocketConnection* connection);
1816        int g_socket_connection_is_connected(GSocketConnection* connection);
1817
1818        // gio.SocketControlMessage
1819
1820        GType g_socket_control_message_get_type();
1821        GSocketControlMessage* g_socket_control_message_deserialize(int level, int type, size_t size, void* data);
1822        int g_socket_control_message_get_level(GSocketControlMessage* message);
1823        int g_socket_control_message_get_msg_type(GSocketControlMessage* message);
1824        size_t g_socket_control_message_get_size(GSocketControlMessage* message);
1825        void g_socket_control_message_serialize(GSocketControlMessage* message, void* data);
1826
1827        // gio.SocketListener
1828
1829        GType g_socket_listener_get_type();
1830        GSocketListener* g_socket_listener_new();
1831        GSocketConnection* g_socket_listener_accept(GSocketListener* listener, GObject** sourceObject, GCancellable* cancellable, GError** err);
1832        void g_socket_listener_accept_async(GSocketListener* listener, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1833        GSocketConnection* g_socket_listener_accept_finish(GSocketListener* listener, GAsyncResult* result, GObject** sourceObject, GError** err);
1834        GSocket* g_socket_listener_accept_socket(GSocketListener* listener, GObject** sourceObject, GCancellable* cancellable, GError** err);
1835        void g_socket_listener_accept_socket_async(GSocketListener* listener, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1836        GSocket* g_socket_listener_accept_socket_finish(GSocketListener* listener, GAsyncResult* result, GObject** sourceObject, GError** err);
1837        int g_socket_listener_add_address(GSocketListener* listener, GSocketAddress* address, GSocketType type, GSocketProtocol protocol, GObject* sourceObject, GSocketAddress** effectiveAddress, GError** err);
1838        ushort g_socket_listener_add_any_inet_port(GSocketListener* listener, GObject* sourceObject, GError** err);
1839        int g_socket_listener_add_inet_port(GSocketListener* listener, ushort port, GObject* sourceObject, GError** err);
1840        int g_socket_listener_add_socket(GSocketListener* listener, GSocket* socket, GObject* sourceObject, GError** err);
1841        void g_socket_listener_close(GSocketListener* listener);
1842        void g_socket_listener_set_backlog(GSocketListener* listener, int listenBacklog);
1843
1844        // gio.SocketService
1845
1846        GType g_socket_service_get_type();
1847        GSocketService* g_socket_service_new();
1848        int g_socket_service_is_active(GSocketService* service);
1849        void g_socket_service_start(GSocketService* service);
1850        void g_socket_service_stop(GSocketService* service);
1851
1852        // gio.SrvTarget
1853
1854        GType g_srv_target_get_type();
1855        GSrvTarget* g_srv_target_new(const(char)* hostname, ushort port, ushort priority, ushort weight);
1856        GSrvTarget* g_srv_target_copy(GSrvTarget* target);
1857        void g_srv_target_free(GSrvTarget* target);
1858        const(char)* g_srv_target_get_hostname(GSrvTarget* target);
1859        ushort g_srv_target_get_port(GSrvTarget* target);
1860        ushort g_srv_target_get_priority(GSrvTarget* target);
1861        ushort g_srv_target_get_weight(GSrvTarget* target);
1862        GList* g_srv_target_list_sort(GList* targets);
1863
1864        // gio.StaticResource
1865
1866        void g_static_resource_fini(GStaticResource* staticResource);
1867        GResource* g_static_resource_get_resource(GStaticResource* staticResource);
1868        void g_static_resource_init(GStaticResource* staticResource);
1869
1870        // gio.Subprocess
1871
1872        GType g_subprocess_get_type();
1873        GSubprocess* g_subprocess_new(GSubprocessFlags flags, GError** error, const(char)* argv0, ... );
1874        GSubprocess* g_subprocess_newv(char** argv, GSubprocessFlags flags, GError** err);
1875        int g_subprocess_communicate(GSubprocess* subprocess, GBytes* stdinBuf, GCancellable* cancellable, GBytes** stdoutBuf, GBytes** stderrBuf, GError** err);
1876        void g_subprocess_communicate_async(GSubprocess* subprocess, GBytes* stdinBuf, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1877        int g_subprocess_communicate_finish(GSubprocess* subprocess, GAsyncResult* result, GBytes** stdoutBuf, GBytes** stderrBuf, GError** err);
1878        int g_subprocess_communicate_utf8(GSubprocess* subprocess, const(char)* stdinBuf, GCancellable* cancellable, char** stdoutBuf, char** stderrBuf, GError** err);
1879        void g_subprocess_communicate_utf8_async(GSubprocess* subprocess, const(char)* stdinBuf, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1880        int g_subprocess_communicate_utf8_finish(GSubprocess* subprocess, GAsyncResult* result, char** stdoutBuf, char** stderrBuf, GError** err);
1881        void g_subprocess_force_exit(GSubprocess* subprocess);
1882        int g_subprocess_get_exit_status(GSubprocess* subprocess);
1883        const(char)* g_subprocess_get_identifier(GSubprocess* subprocess);
1884        int g_subprocess_get_if_exited(GSubprocess* subprocess);
1885        int g_subprocess_get_if_signaled(GSubprocess* subprocess);
1886        int g_subprocess_get_status(GSubprocess* subprocess);
1887        GInputStream* g_subprocess_get_stderr_pipe(GSubprocess* subprocess);
1888        GOutputStream* g_subprocess_get_stdin_pipe(GSubprocess* subprocess);
1889        GInputStream* g_subprocess_get_stdout_pipe(GSubprocess* subprocess);
1890        int g_subprocess_get_successful(GSubprocess* subprocess);
1891        int g_subprocess_get_term_sig(GSubprocess* subprocess);
1892        void g_subprocess_send_signal(GSubprocess* subprocess, int signalNum);
1893        int g_subprocess_wait(GSubprocess* subprocess, GCancellable* cancellable, GError** err);
1894        void g_subprocess_wait_async(GSubprocess* subprocess, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1895        int g_subprocess_wait_check(GSubprocess* subprocess, GCancellable* cancellable, GError** err);
1896        void g_subprocess_wait_check_async(GSubprocess* subprocess, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
1897        int g_subprocess_wait_check_finish(GSubprocess* subprocess, GAsyncResult* result, GError** err);
1898        int g_subprocess_wait_finish(GSubprocess* subprocess, GAsyncResult* result, GError** err);
1899
1900        // gio.SubprocessLauncher
1901
1902        GType g_subprocess_launcher_get_type();
1903        GSubprocessLauncher* g_subprocess_launcher_new(GSubprocessFlags flags);
1904        const(char)* g_subprocess_launcher_getenv(GSubprocessLauncher* self, const(char)* variable);
1905        void g_subprocess_launcher_set_child_setup(GSubprocessLauncher* self, GSpawnChildSetupFunc childSetup, void* userData, GDestroyNotify destroyNotify);
1906        void g_subprocess_launcher_set_cwd(GSubprocessLauncher* self, const(char)* cwd);
1907        void g_subprocess_launcher_set_environ(GSubprocessLauncher* self, char** env);
1908        void g_subprocess_launcher_set_flags(GSubprocessLauncher* self, GSubprocessFlags flags);
1909        void g_subprocess_launcher_set_stderr_file_path(GSubprocessLauncher* self, const(char)* path);
1910        void g_subprocess_launcher_set_stdin_file_path(GSubprocessLauncher* self, const(char)* path);
1911        void g_subprocess_launcher_set_stdout_file_path(GSubprocessLauncher* self, const(char)* path);
1912        void g_subprocess_launcher_setenv(GSubprocessLauncher* self, const(char)* variable, const(char)* value, int overwrite);
1913        GSubprocess* g_subprocess_launcher_spawn(GSubprocessLauncher* self, GError** error, const(char)* argv0, ... );
1914        GSubprocess* g_subprocess_launcher_spawnv(GSubprocessLauncher* self, char** argv, GError** err);
1915        void g_subprocess_launcher_take_fd(GSubprocessLauncher* self, int sourceFd, int targetFd);
1916        void g_subprocess_launcher_take_stderr_fd(GSubprocessLauncher* self, int fd);
1917        void g_subprocess_launcher_take_stdin_fd(GSubprocessLauncher* self, int fd);
1918        void g_subprocess_launcher_take_stdout_fd(GSubprocessLauncher* self, int fd);
1919        void g_subprocess_launcher_unsetenv(GSubprocessLauncher* self, const(char)* variable);
1920
1921        // gio.Task
1922
1923        GType g_task_get_type();
1924        GTask* g_task_new(void* sourceObject, GCancellable* cancellable, GAsyncReadyCallback callback, void* callbackData);
1925        int g_task_is_valid(void* result, void* sourceObject);
1926        void g_task_report_error(void* sourceObject, GAsyncReadyCallback callback, void* callbackData, void* sourceTag, GError* error);
1927        void g_task_report_new_error(void* sourceObject, GAsyncReadyCallback callback, void* callbackData, void* sourceTag, GQuark domain, int code, const(char)* format, ... );
1928        void g_task_attach_source(GTask* task, GSource* source, GSourceFunc callback);
1929        GCancellable* g_task_get_cancellable(GTask* task);
1930        int g_task_get_check_cancellable(GTask* task);
1931        int g_task_get_completed(GTask* task);
1932        GMainContext* g_task_get_context(GTask* task);
1933        int g_task_get_priority(GTask* task);
1934        int g_task_get_return_on_cancel(GTask* task);
1935        void* g_task_get_source_object(GTask* task);
1936        void* g_task_get_source_tag(GTask* task);
1937        void* g_task_get_task_data(GTask* task);
1938        int g_task_had_error(GTask* task);
1939        int g_task_propagate_boolean(GTask* task, GError** err);
1940        ptrdiff_t g_task_propagate_int(GTask* task, GError** err);
1941        void* g_task_propagate_pointer(GTask* task, GError** err);
1942        void g_task_return_boolean(GTask* task, int result);
1943        void g_task_return_error(GTask* task, GError* error);
1944        int g_task_return_error_if_cancelled(GTask* task);
1945        void g_task_return_int(GTask* task, ptrdiff_t result);
1946        void g_task_return_new_error(GTask* task, GQuark domain, int code, const(char)* format, ... );
1947        void g_task_return_pointer(GTask* task, void* result, GDestroyNotify resultDestroy);
1948        void g_task_run_in_thread(GTask* task, GTaskThreadFunc taskFunc);
1949        void g_task_run_in_thread_sync(GTask* task, GTaskThreadFunc taskFunc);
1950        void g_task_set_check_cancellable(GTask* task, int checkCancellable);
1951        void g_task_set_priority(GTask* task, int priority);
1952        int g_task_set_return_on_cancel(GTask* task, int returnOnCancel);
1953        void g_task_set_source_tag(GTask* task, void* sourceTag);
1954        void g_task_set_task_data(GTask* task, void* taskData, GDestroyNotify taskDataDestroy);
1955
1956        // gio.TcpConnection
1957
1958        GType g_tcp_connection_get_type();
1959        int g_tcp_connection_get_graceful_disconnect(GTcpConnection* connection);
1960        void g_tcp_connection_set_graceful_disconnect(GTcpConnection* connection, int gracefulDisconnect);
1961
1962        // gio.TcpWrapperConnection
1963
1964        GType g_tcp_wrapper_connection_get_type();
1965        GSocketConnection* g_tcp_wrapper_connection_new(GIOStream* baseIoStream, GSocket* socket);
1966        GIOStream* g_tcp_wrapper_connection_get_base_io_stream(GTcpWrapperConnection* conn);
1967
1968        // gio.TestDBus
1969
1970        GType g_test_dbus_get_type();
1971        GTestDBus* g_test_dbus_new(GTestDBusFlags flags);
1972        void g_test_dbus_unset();
1973        void g_test_dbus_add_service_dir(GTestDBus* self, const(char)* path);
1974        void g_test_dbus_down(GTestDBus* self);
1975        const(char)* g_test_dbus_get_bus_address(GTestDBus* self);
1976        GTestDBusFlags g_test_dbus_get_flags(GTestDBus* self);
1977        void g_test_dbus_stop(GTestDBus* self);
1978        void g_test_dbus_up(GTestDBus* self);
1979
1980        // gio.ThemedIcon
1981
1982        GType g_themed_icon_get_type();
1983        GIcon* g_themed_icon_new(const(char)* iconname);
1984        GIcon* g_themed_icon_new_from_names(char** iconnames, int len);
1985        GIcon* g_themed_icon_new_with_default_fallbacks(const(char)* iconname);
1986        void g_themed_icon_append_name(GThemedIcon* icon, const(char)* iconname);
1987        char** g_themed_icon_get_names(GThemedIcon* icon);
1988        void g_themed_icon_prepend_name(GThemedIcon* icon, const(char)* iconname);
1989
1990        // gio.ThreadedSocketService
1991
1992        GType g_threaded_socket_service_get_type();
1993        GSocketService* g_threaded_socket_service_new(int maxThreads);
1994
1995        // gio.TlsBackend
1996
1997        GType g_tls_backend_get_type();
1998        GTlsBackend* g_tls_backend_get_default();
1999        GType g_tls_backend_get_certificate_type(GTlsBackend* backend);
2000        GType g_tls_backend_get_client_connection_type(GTlsBackend* backend);
2001        GTlsDatabase* g_tls_backend_get_default_database(GTlsBackend* backend);
2002        GType g_tls_backend_get_file_database_type(GTlsBackend* backend);
2003        GType g_tls_backend_get_server_connection_type(GTlsBackend* backend);
2004        int g_tls_backend_supports_tls(GTlsBackend* backend);
2005
2006        // gio.TlsCertificate
2007
2008        GType g_tls_certificate_get_type();
2009        GTlsCertificate* g_tls_certificate_new_from_file(const(char)* file, GError** err);
2010        GTlsCertificate* g_tls_certificate_new_from_files(const(char)* certFile, const(char)* keyFile, GError** err);
2011        GTlsCertificate* g_tls_certificate_new_from_pem(const(char)* data, ptrdiff_t length, GError** err);
2012        GList* g_tls_certificate_list_new_from_file(const(char)* file, GError** err);
2013        GTlsCertificate* g_tls_certificate_get_issuer(GTlsCertificate* cert);
2014        int g_tls_certificate_is_same(GTlsCertificate* certOne, GTlsCertificate* certTwo);
2015        GTlsCertificateFlags g_tls_certificate_verify(GTlsCertificate* cert, GSocketConnectable* identity, GTlsCertificate* trustedCa);
2016
2017        // gio.TlsClientConnection
2018
2019        GType g_tls_client_connection_get_type();
2020        GIOStream* g_tls_client_connection_new(GIOStream* baseIoStream, GSocketConnectable* serverIdentity, GError** err);
2021        void g_tls_client_connection_copy_session_state(GTlsClientConnection* conn, GTlsClientConnection* source);
2022        GList* g_tls_client_connection_get_accepted_cas(GTlsClientConnection* conn);
2023        GSocketConnectable* g_tls_client_connection_get_server_identity(GTlsClientConnection* conn);
2024        int g_tls_client_connection_get_use_ssl3(GTlsClientConnection* conn);
2025        GTlsCertificateFlags g_tls_client_connection_get_validation_flags(GTlsClientConnection* conn);
2026        void g_tls_client_connection_set_server_identity(GTlsClientConnection* conn, GSocketConnectable* identity);
2027        void g_tls_client_connection_set_use_ssl3(GTlsClientConnection* conn, int useSsl3);
2028        void g_tls_client_connection_set_validation_flags(GTlsClientConnection* conn, GTlsCertificateFlags flags);
2029
2030        // gio.TlsConnection
2031
2032        GType g_tls_connection_get_type();
2033        int g_tls_connection_emit_accept_certificate(GTlsConnection* conn, GTlsCertificate* peerCert, GTlsCertificateFlags errors);
2034        GTlsCertificate* g_tls_connection_get_certificate(GTlsConnection* conn);
2035        GTlsDatabase* g_tls_connection_get_database(GTlsConnection* conn);
2036        GTlsInteraction* g_tls_connection_get_interaction(GTlsConnection* conn);
2037        GTlsCertificate* g_tls_connection_get_peer_certificate(GTlsConnection* conn);
2038        GTlsCertificateFlags g_tls_connection_get_peer_certificate_errors(GTlsConnection* conn);
2039        GTlsRehandshakeMode g_tls_connection_get_rehandshake_mode(GTlsConnection* conn);
2040        int g_tls_connection_get_require_close_notify(GTlsConnection* conn);
2041        int g_tls_connection_get_use_system_certdb(GTlsConnection* conn);
2042        int g_tls_connection_handshake(GTlsConnection* conn, GCancellable* cancellable, GError** err);
2043        void g_tls_connection_handshake_async(GTlsConnection* conn, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
2044        int g_tls_connection_handshake_finish(GTlsConnection* conn, GAsyncResult* result, GError** err);
2045        void g_tls_connection_set_certificate(GTlsConnection* conn, GTlsCertificate* certificate);
2046        void g_tls_connection_set_database(GTlsConnection* conn, GTlsDatabase* database);
2047        void g_tls_connection_set_interaction(GTlsConnection* conn, GTlsInteraction* interaction);
2048        void g_tls_connection_set_rehandshake_mode(GTlsConnection* conn, GTlsRehandshakeMode mode);
2049        void g_tls_connection_set_require_close_notify(GTlsConnection* conn, int requireCloseNotify);
2050        void g_tls_connection_set_use_system_certdb(GTlsConnection* conn, int useSystemCertdb);
2051
2052        // gio.TlsDatabase
2053
2054        GType g_tls_database_get_type();
2055        char* g_tls_database_create_certificate_handle(GTlsDatabase* self, GTlsCertificate* certificate);
2056        GTlsCertificate* g_tls_database_lookup_certificate_for_handle(GTlsDatabase* self, const(char)* handle, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GError** err);
2057        void g_tls_database_lookup_certificate_for_handle_async(GTlsDatabase* self, const(char)* handle, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
2058        GTlsCertificate* g_tls_database_lookup_certificate_for_handle_finish(GTlsDatabase* self, GAsyncResult* result, GError** err);
2059        GTlsCertificate* g_tls_database_lookup_certificate_issuer(GTlsDatabase* self, GTlsCertificate* certificate, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GError** err);
2060        void g_tls_database_lookup_certificate_issuer_async(GTlsDatabase* self, GTlsCertificate* certificate, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
2061        GTlsCertificate* g_tls_database_lookup_certificate_issuer_finish(GTlsDatabase* self, GAsyncResult* result, GError** err);
2062        GList* g_tls_database_lookup_certificates_issued_by(GTlsDatabase* self, GByteArray* issuerRawDn, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GError** err);
2063        void g_tls_database_lookup_certificates_issued_by_async(GTlsDatabase* self, GByteArray* issuerRawDn, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
2064        GList* g_tls_database_lookup_certificates_issued_by_finish(GTlsDatabase* self, GAsyncResult* result, GError** err);
2065        GTlsCertificateFlags g_tls_database_verify_chain(GTlsDatabase* self, GTlsCertificate* chain, const(char)* purpose, GSocketConnectable* identity, GTlsInteraction* interaction, GTlsDatabaseVerifyFlags flags, GCancellable* cancellable, GError** err);
2066        void g_tls_database_verify_chain_async(GTlsDatabase* self, GTlsCertificate* chain, const(char)* purpose, GSocketConnectable* identity, GTlsInteraction* interaction, GTlsDatabaseVerifyFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
2067        GTlsCertificateFlags g_tls_database_verify_chain_finish(GTlsDatabase* self, GAsyncResult* result, GError** err);
2068
2069        // gio.TlsFileDatabase
2070
2071        GType g_tls_file_database_get_type();
2072        GTlsDatabase* g_tls_file_database_new(const(char)* anchors, GError** err);
2073
2074        // gio.TlsInteraction
2075
2076        GType g_tls_interaction_get_type();
2077        GTlsInteractionResult g_tls_interaction_ask_password(GTlsInteraction* interaction, GTlsPassword* password, GCancellable* cancellable, GError** err);
2078        void g_tls_interaction_ask_password_async(GTlsInteraction* interaction, GTlsPassword* password, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
2079        GTlsInteractionResult g_tls_interaction_ask_password_finish(GTlsInteraction* interaction, GAsyncResult* result, GError** err);
2080        GTlsInteractionResult g_tls_interaction_invoke_ask_password(GTlsInteraction* interaction, GTlsPassword* password, GCancellable* cancellable, GError** err);
2081        GTlsInteractionResult g_tls_interaction_invoke_request_certificate(GTlsInteraction* interaction, GTlsConnection* connection, GTlsCertificateRequestFlags flags, GCancellable* cancellable, GError** err);
2082        GTlsInteractionResult g_tls_interaction_request_certificate(GTlsInteraction* interaction, GTlsConnection* connection, GTlsCertificateRequestFlags flags, GCancellable* cancellable, GError** err);
2083        void g_tls_interaction_request_certificate_async(GTlsInteraction* interaction, GTlsConnection* connection, GTlsCertificateRequestFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
2084        GTlsInteractionResult g_tls_interaction_request_certificate_finish(GTlsInteraction* interaction, GAsyncResult* result, GError** err);
2085
2086        // gio.TlsPassword
2087
2088        GType g_tls_password_get_type();
2089        GTlsPassword* g_tls_password_new(GTlsPasswordFlags flags, const(char)* description);
2090        const(char)* g_tls_password_get_description(GTlsPassword* password);
2091        GTlsPasswordFlags g_tls_password_get_flags(GTlsPassword* password);
2092        char* g_tls_password_get_value(GTlsPassword* password, size_t* length);
2093        const(char)* g_tls_password_get_warning(GTlsPassword* password);
2094        void g_tls_password_set_description(GTlsPassword* password, const(char)* description);
2095        void g_tls_password_set_flags(GTlsPassword* password, GTlsPasswordFlags flags);
2096        void g_tls_password_set_value(GTlsPassword* password, char* value, ptrdiff_t length);
2097        void g_tls_password_set_value_full(GTlsPassword* password, char* value, ptrdiff_t length, GDestroyNotify destroy);
2098        void g_tls_password_set_warning(GTlsPassword* password, const(char)* warning);
2099
2100        // gio.TlsServerConnection
2101
2102        GType g_tls_server_connection_get_type();
2103        GIOStream* g_tls_server_connection_new(GIOStream* baseIoStream, GTlsCertificate* certificate, GError** err);
2104
2105        // gio.UnixConnection
2106
2107        GType g_unix_connection_get_type();
2108        GCredentials* g_unix_connection_receive_credentials(GUnixConnection* connection, GCancellable* cancellable, GError** err);
2109        void g_unix_connection_receive_credentials_async(GUnixConnection* connection, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
2110        GCredentials* g_unix_connection_receive_credentials_finish(GUnixConnection* connection, GAsyncResult* result, GError** err);
2111        int g_unix_connection_receive_fd(GUnixConnection* connection, GCancellable* cancellable, GError** err);
2112        int g_unix_connection_send_credentials(GUnixConnection* connection, GCancellable* cancellable, GError** err);
2113        void g_unix_connection_send_credentials_async(GUnixConnection* connection, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
2114        int g_unix_connection_send_credentials_finish(GUnixConnection* connection, GAsyncResult* result, GError** err);
2115        int g_unix_connection_send_fd(GUnixConnection* connection, int fd, GCancellable* cancellable, GError** err);
2116
2117        // gio.UnixCredentialsMessage
2118
2119        GType g_unix_credentials_message_get_type();
2120        GSocketControlMessage* g_unix_credentials_message_new();
2121        GSocketControlMessage* g_unix_credentials_message_new_with_credentials(GCredentials* credentials);
2122        int g_unix_credentials_message_is_supported();
2123        GCredentials* g_unix_credentials_message_get_credentials(GUnixCredentialsMessage* message);
2124
2125        // gio.UnixFDList
2126
2127        GType g_unix_fd_list_get_type();
2128        GUnixFDList* g_unix_fd_list_new();
2129        GUnixFDList* g_unix_fd_list_new_from_array(int* fds, int nFds);
2130        int g_unix_fd_list_append(GUnixFDList* list, int fd, GError** err);
2131        int g_unix_fd_list_get(GUnixFDList* list, int index, GError** err);
2132        int g_unix_fd_list_get_length(GUnixFDList* list);
2133        int* g_unix_fd_list_peek_fds(GUnixFDList* list, int* length);
2134        int* g_unix_fd_list_steal_fds(GUnixFDList* list, int* length);
2135
2136        // gio.UnixFDMessage
2137
2138        GType g_unix_fd_message_get_type();
2139        GSocketControlMessage* g_unix_fd_message_new();
2140        GSocketControlMessage* g_unix_fd_message_new_with_fd_list(GUnixFDList* fdList);
2141        int g_unix_fd_message_append_fd(GUnixFDMessage* message, int fd, GError** err);
2142        GUnixFDList* g_unix_fd_message_get_fd_list(GUnixFDMessage* message);
2143        int* g_unix_fd_message_steal_fds(GUnixFDMessage* message, int* length);
2144
2145        // gio.UnixInputStream
2146
2147        GType g_unix_input_stream_get_type();
2148        GInputStream* g_unix_input_stream_new(int fd, int closeFd);
2149        int g_unix_input_stream_get_close_fd(GUnixInputStream* stream);
2150        int g_unix_input_stream_get_fd(GUnixInputStream* stream);
2151        void g_unix_input_stream_set_close_fd(GUnixInputStream* stream, int closeFd);
2152
2153        // gio.UnixMountEntry
2154
2155        int g_unix_is_mount_path_system_internal(const(char)* mountPath);
2156        GUnixMountEntry* g_unix_mount_at(const(char)* mountPath, ulong* timeRead);
2157        int g_unix_mount_compare(GUnixMountEntry* mount1, GUnixMountEntry* mount2);
2158        void g_unix_mount_free(GUnixMountEntry* mountEntry);
2159        const(char)* g_unix_mount_get_device_path(GUnixMountEntry* mountEntry);
2160        const(char)* g_unix_mount_get_fs_type(GUnixMountEntry* mountEntry);
2161        const(char)* g_unix_mount_get_mount_path(GUnixMountEntry* mountEntry);
2162        int g_unix_mount_guess_can_eject(GUnixMountEntry* mountEntry);
2163        GIcon* g_unix_mount_guess_icon(GUnixMountEntry* mountEntry);
2164        char* g_unix_mount_guess_name(GUnixMountEntry* mountEntry);
2165        int g_unix_mount_guess_should_display(GUnixMountEntry* mountEntry);
2166        GIcon* g_unix_mount_guess_symbolic_icon(GUnixMountEntry* mountEntry);
2167        int g_unix_mount_is_readonly(GUnixMountEntry* mountEntry);
2168        int g_unix_mount_is_system_internal(GUnixMountEntry* mountEntry);
2169        int g_unix_mount_points_changed_since(ulong time);
2170        GList* g_unix_mount_points_get(ulong* timeRead);
2171        int g_unix_mounts_changed_since(ulong time);
2172        GList* g_unix_mounts_get(ulong* timeRead);
2173
2174        // gio.UnixMountMonitor
2175
2176        GType g_unix_mount_monitor_get_type();
2177        GUnixMountMonitor* g_unix_mount_monitor_new();
2178        GUnixMountMonitor* g_unix_mount_monitor_get();
2179        void g_unix_mount_monitor_set_rate_limit(GUnixMountMonitor* mountMonitor, int limitMsec);
2180
2181        // gio.UnixMountPoint
2182
2183        int g_unix_mount_point_compare(GUnixMountPoint* mount1, GUnixMountPoint* mount2);
2184        void g_unix_mount_point_free(GUnixMountPoint* mountPoint);
2185        const(char)* g_unix_mount_point_get_device_path(GUnixMountPoint* mountPoint);
2186        const(char)* g_unix_mount_point_get_fs_type(GUnixMountPoint* mountPoint);
2187        const(char)* g_unix_mount_point_get_mount_path(GUnixMountPoint* mountPoint);
2188        const(char)* g_unix_mount_point_get_options(GUnixMountPoint* mountPoint);
2189        int g_unix_mount_point_guess_can_eject(GUnixMountPoint* mountPoint);
2190        GIcon* g_unix_mount_point_guess_icon(GUnixMountPoint* mountPoint);
2191        char* g_unix_mount_point_guess_name(GUnixMountPoint* mountPoint);
2192        GIcon* g_unix_mount_point_guess_symbolic_icon(GUnixMountPoint* mountPoint);
2193        int g_unix_mount_point_is_loopback(GUnixMountPoint* mountPoint);
2194        int g_unix_mount_point_is_readonly(GUnixMountPoint* mountPoint);
2195        int g_unix_mount_point_is_user_mountable(GUnixMountPoint* mountPoint);
2196
2197        // gio.UnixOutputStream
2198
2199        GType g_unix_output_stream_get_type();
2200        GOutputStream* g_unix_output_stream_new(int fd, int closeFd);
2201        int g_unix_output_stream_get_close_fd(GUnixOutputStream* stream);
2202        int g_unix_output_stream_get_fd(GUnixOutputStream* stream);
2203        void g_unix_output_stream_set_close_fd(GUnixOutputStream* stream, int closeFd);
2204
2205        // gio.UnixSocketAddress
2206
2207        GType g_unix_socket_address_get_type();
2208        GSocketAddress* g_unix_socket_address_new(const(char)* path);
2209        GSocketAddress* g_unix_socket_address_new_abstract(char* path, int pathLen);
2210        GSocketAddress* g_unix_socket_address_new_with_type(char* path, int pathLen, GUnixSocketAddressType type);
2211        int g_unix_socket_address_abstract_names_supported();
2212        GUnixSocketAddressType g_unix_socket_address_get_address_type(GUnixSocketAddress* address);
2213        int g_unix_socket_address_get_is_abstract(GUnixSocketAddress* address);
2214        const(char)* g_unix_socket_address_get_path(GUnixSocketAddress* address);
2215        size_t g_unix_socket_address_get_path_len(GUnixSocketAddress* address);
2216
2217        // gio.Vfs
2218
2219        GType g_vfs_get_type();
2220        GVfs* g_vfs_get_default();
2221        GVfs* g_vfs_get_local();
2222        GFile* g_vfs_get_file_for_path(GVfs* vfs, const(char)* path);
2223        GFile* g_vfs_get_file_for_uri(GVfs* vfs, const(char)* uri);
2224        char** g_vfs_get_supported_uri_schemes(GVfs* vfs);
2225        int g_vfs_is_active(GVfs* vfs);
2226        GFile* g_vfs_parse_name(GVfs* vfs, const(char)* parseName);
2227
2228        // gio.Volume
2229
2230        GType g_volume_get_type();
2231        int g_volume_can_eject(GVolume* volume);
2232        int g_volume_can_mount(GVolume* volume);
2233        void g_volume_eject(GVolume* volume, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
2234        int g_volume_eject_finish(GVolume* volume, GAsyncResult* result, GError** err);
2235        void g_volume_eject_with_operation(GVolume* volume, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
2236        int g_volume_eject_with_operation_finish(GVolume* volume, GAsyncResult* result, GError** err);
2237        char** g_volume_enumerate_identifiers(GVolume* volume);
2238        GFile* g_volume_get_activation_root(GVolume* volume);
2239        GDrive* g_volume_get_drive(GVolume* volume);
2240        GIcon* g_volume_get_icon(GVolume* volume);
2241        char* g_volume_get_identifier(GVolume* volume, const(char)* kind);
2242        GMount* g_volume_get_mount(GVolume* volume);
2243        char* g_volume_get_name(GVolume* volume);
2244        const(char)* g_volume_get_sort_key(GVolume* volume);
2245        GIcon* g_volume_get_symbolic_icon(GVolume* volume);
2246        char* g_volume_get_uuid(GVolume* volume);
2247        void g_volume_mount(GVolume* volume, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
2248        int g_volume_mount_finish(GVolume* volume, GAsyncResult* result, GError** err);
2249        int g_volume_should_automount(GVolume* volume);
2250
2251        // gio.VolumeMonitor
2252
2253        GType g_volume_monitor_get_type();
2254        GVolume* g_volume_monitor_adopt_orphan_mount(GMount* mount);
2255        GVolumeMonitor* g_volume_monitor_get();
2256        GList* g_volume_monitor_get_connected_drives(GVolumeMonitor* volumeMonitor);
2257        GMount* g_volume_monitor_get_mount_for_uuid(GVolumeMonitor* volumeMonitor, const(char)* uuid);
2258        GList* g_volume_monitor_get_mounts(GVolumeMonitor* volumeMonitor);
2259        GVolume* g_volume_monitor_get_volume_for_uuid(GVolumeMonitor* volumeMonitor, const(char)* uuid);
2260        GList* g_volume_monitor_get_volumes(GVolumeMonitor* volumeMonitor);
2261
2262        // gio.ZlibCompressor
2263
2264        GType g_zlib_compressor_get_type();
2265        GZlibCompressor* g_zlib_compressor_new(GZlibCompressorFormat format, int level);
2266        GFileInfo* g_zlib_compressor_get_file_info(GZlibCompressor* compressor);
2267        void g_zlib_compressor_set_file_info(GZlibCompressor* compressor, GFileInfo* fileInfo);
2268
2269        // gio.ZlibDecompressor
2270
2271        GType g_zlib_decompressor_get_type();
2272        GZlibDecompressor* g_zlib_decompressor_new(GZlibCompressorFormat format);
2273        GFileInfo* g_zlib_decompressor_get_file_info(GZlibDecompressor* decompressor);
2274
2275        // gio.PollableUtils
2276
2277        GSource* g_pollable_source_new(GObject* pollableStream);
2278        GSource* g_pollable_source_new_full(void* pollableStream, GSource* childSource, GCancellable* cancellable);
2279        ptrdiff_t g_pollable_stream_read(GInputStream* stream, void* buffer, size_t count, int blocking, GCancellable* cancellable, GError** err);
2280        ptrdiff_t g_pollable_stream_write(GOutputStream* stream, void* buffer, size_t count, int blocking, GCancellable* cancellable, GError** err);
2281        int g_pollable_stream_write_all(GOutputStream* stream, void* buffer, size_t count, int blocking, size_t* bytesWritten, GCancellable* cancellable, GError** err);
2282
2283        // gio.DBusNames
2284
2285        uint g_bus_own_name(GBusType busType, const(char)* name, GBusNameOwnerFlags flags, GBusAcquiredCallback busAcquiredHandler, GBusNameAcquiredCallback nameAcquiredHandler, GBusNameLostCallback nameLostHandler, void* userData, GDestroyNotify userDataFreeFunc);
2286        uint g_bus_own_name_on_connection(GDBusConnection* connection, const(char)* name, GBusNameOwnerFlags flags, GBusNameAcquiredCallback nameAcquiredHandler, GBusNameLostCallback nameLostHandler, void* userData, GDestroyNotify userDataFreeFunc);
2287        uint g_bus_own_name_on_connection_with_closures(GDBusConnection* connection, const(char)* name, GBusNameOwnerFlags flags, GClosure* nameAcquiredClosure, GClosure* nameLostClosure);
2288        uint g_bus_own_name_with_closures(GBusType busType, const(char)* name, GBusNameOwnerFlags flags, GClosure* busAcquiredClosure, GClosure* nameAcquiredClosure, GClosure* nameLostClosure);
2289        void g_bus_unown_name(uint ownerId);
2290        void g_bus_unwatch_name(uint watcherId);
2291        uint g_bus_watch_name(GBusType busType, const(char)* name, GBusNameWatcherFlags flags, GBusNameAppearedCallback nameAppearedHandler, GBusNameVanishedCallback nameVanishedHandler, void* userData, GDestroyNotify userDataFreeFunc);
2292        uint g_bus_watch_name_on_connection(GDBusConnection* connection, const(char)* name, GBusNameWatcherFlags flags, GBusNameAppearedCallback nameAppearedHandler, GBusNameVanishedCallback nameVanishedHandler, void* userData, GDestroyNotify userDataFreeFunc);
2293        uint g_bus_watch_name_on_connection_with_closures(GDBusConnection* connection, const(char)* name, GBusNameWatcherFlags flags, GClosure* nameAppearedClosure, GClosure* nameVanishedClosure);
2294        uint g_bus_watch_name_with_closures(GBusType busType, const(char)* name, GBusNameWatcherFlags flags, GClosure* nameAppearedClosure, GClosure* nameVanishedClosure);
2295
2296        // gio.ContentType
2297
2298        int g_content_type_can_be_executable(const(char)* type);
2299        int g_content_type_equals(const(char)* type1, const(char)* type2);
2300        char* g_content_type_from_mime_type(const(char)* mimeType);
2301        char* g_content_type_get_description(const(char)* type);
2302        char* g_content_type_get_generic_icon_name(const(char)* type);
2303        GIcon* g_content_type_get_icon(const(char)* type);
2304        char* g_content_type_get_mime_type(const(char)* type);
2305        GIcon* g_content_type_get_symbolic_icon(const(char)* type);
2306        char* g_content_type_guess(const(char)* filename, char* data, size_t dataSize, int* resultUncertain);
2307        char** g_content_type_guess_for_tree(GFile* root);
2308        int g_content_type_is_a(const(char)* type, const(char)* supertype);
2309        int g_content_type_is_unknown(const(char)* type);
2310        GList* g_content_types_get_registered();
2311
2312        // gio.DBusError
2313
2314        char* g_dbus_error_encode_gerror(GError* error);
2315        char* g_dbus_error_get_remote_error(GError* error);
2316        int g_dbus_error_is_remote_error(GError* error);
2317        GError* g_dbus_error_new_for_dbus_error(const(char)* dbusErrorName, const(char)* dbusErrorMessage);
2318        GQuark g_dbus_error_quark();
2319        int g_dbus_error_register_error(GQuark errorDomain, int errorCode, const(char)* dbusErrorName);
2320        void g_dbus_error_register_error_domain(const(char)* errorDomainQuarkName, size_t* quarkVolatile, GDBusErrorEntry* entries, uint numEntries);
2321        int g_dbus_error_strip_remote_error(GError* error);
2322        int g_dbus_error_unregister_error(GQuark errorDomain, int errorCode, const(char)* dbusErrorName);
2323
2324        // gio.DBusUtilities
2325
2326        char* g_dbus_address_escape_value(const(char)* str);
2327        char* g_dbus_address_get_for_bus_sync(GBusType busType, GCancellable* cancellable, GError** err);
2328        void g_dbus_address_get_stream(const(char)* address, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData);
2329        GIOStream* g_dbus_address_get_stream_finish(GAsyncResult* res, char** outGuid, GError** err);
2330        GIOStream* g_dbus_address_get_stream_sync(const(char)* address, char** outGuid, GCancellable* cancellable, GError** err);
2331        char* g_dbus_generate_guid();
2332        GVariant* g_dbus_gvalue_to_gvariant(GValue* gvalue, GVariantType* type);
2333        void g_dbus_gvariant_to_gvalue(GVariant* value, GValue* outGvalue);
2334        int g_dbus_is_address(const(char)* str);
2335        int g_dbus_is_guid(const(char)* str);
2336        int g_dbus_is_interface_name(const(char)* str);
2337        int g_dbus_is_member_name(const(char)* str);
2338        int g_dbus_is_name(const(char)* str);
2339        int g_dbus_is_supported_address(const(char)* str, GError** err);
2340        int g_dbus_is_unique_name(const(char)* str);
2341
2342        // gio.ErrorGIO
2343
2344        GIOErrorEnum g_io_error_from_errno(int errNo);
2345        GQuark g_io_error_quark();
2346}
Note: See TracBrowser for help on using the repository browser.