1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19 
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 
25 module gtkc.giotypes;
26 
27 public import gtkc.glibtypes;
28 public import gtkc.gobjecttypes;
29 
30 /**
31  * Flags used when creating a #GAppInfo.
32  */
33 public enum GAppInfoCreateFlags
34 {
35 	/**
36 	 * No flags.
37 	 */
38 	NONE = 0,
39 	/**
40 	 * Application opens in a terminal window.
41 	 */
42 	NEEDS_TERMINAL = 1,
43 	/**
44 	 * Application supports URI arguments.
45 	 */
46 	SUPPORTS_URIS = 2,
47 	/**
48 	 * Application supports startup notification. Since 2.26
49 	 */
50 	SUPPORTS_STARTUP_NOTIFICATION = 4,
51 }
52 alias GAppInfoCreateFlags AppInfoCreateFlags;
53 
54 /**
55  * Flags used to define the behaviour of a #GApplication.
56  *
57  * Since: 2.28
58  */
59 public enum GApplicationFlags
60 {
61 	/**
62 	 * Default
63 	 */
64 	FLAGS_NONE = 0,
65 	/**
66 	 * Run as a service. In this mode, registration
67 	 * fails if the service is already running, and the application
68 	 * will initially wait up to 10 seconds for an initial activation
69 	 * message to arrive.
70 	 */
71 	IS_SERVICE = 1,
72 	/**
73 	 * Don't try to become the primary instance.
74 	 */
75 	IS_LAUNCHER = 2,
76 	/**
77 	 * This application handles opening files (in
78 	 * the primary instance). Note that this flag only affects the default
79 	 * implementation of local_command_line(), and has no effect if
80 	 * %G_APPLICATION_HANDLES_COMMAND_LINE is given.
81 	 * See g_application_run() for details.
82 	 */
83 	HANDLES_OPEN = 4,
84 	/**
85 	 * This application handles command line
86 	 * arguments (in the primary instance). Note that this flag only affect
87 	 * the default implementation of local_command_line().
88 	 * See g_application_run() for details.
89 	 */
90 	HANDLES_COMMAND_LINE = 8,
91 	/**
92 	 * Send the environment of the
93 	 * launching process to the primary instance. Set this flag if your
94 	 * application is expected to behave differently depending on certain
95 	 * environment variables. For instance, an editor might be expected
96 	 * to use the <envar>GIT_COMMITTER_NAME</envar> environment variable
97 	 * when editing a git commit message. The environment is available
98 	 * to the #GApplication::command-line signal handler, via
99 	 * g_application_command_line_getenv().
100 	 */
101 	SEND_ENVIRONMENT = 16,
102 	/**
103 	 * Make no attempts to do any of the typical
104 	 * single-instance application negotiation, even if the application
105 	 * ID is given.  The application neither attempts to become the
106 	 * owner of the application ID nor does it check if an existing
107 	 * owner already exists.  Everything occurs in the local process.
108 	 * Since: 2.30.
109 	 */
110 	NON_UNIQUE = 32,
111 }
112 alias GApplicationFlags ApplicationFlags;
113 
114 /**
115  * #GAskPasswordFlags are used to request specific information from the
116  * user, or to notify the user of their choices in an authentication
117  * situation.
118  */
119 public enum GAskPasswordFlags
120 {
121 	/**
122 	 * operation requires a password.
123 	 */
124 	NEED_PASSWORD = 1,
125 	/**
126 	 * operation requires a username.
127 	 */
128 	NEED_USERNAME = 2,
129 	/**
130 	 * operation requires a domain.
131 	 */
132 	NEED_DOMAIN = 4,
133 	/**
134 	 * operation supports saving settings.
135 	 */
136 	SAVING_SUPPORTED = 8,
137 	/**
138 	 * operation supports anonymous users.
139 	 */
140 	ANONYMOUS_SUPPORTED = 16,
141 }
142 alias GAskPasswordFlags AskPasswordFlags;
143 
144 /**
145  * Flags used in g_bus_own_name().
146  *
147  * Since: 2.26
148  */
149 public enum GBusNameOwnerFlags
150 {
151 	/**
152 	 * No flags set.
153 	 */
154 	NONE = 0,
155 	/**
156 	 * Allow another message bus connection to claim the name.
157 	 */
158 	ALLOW_REPLACEMENT = 1,
159 	/**
160 	 * If another message bus connection owns the name and have
161 	 * specified #G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT, then take the name from the other connection.
162 	 */
163 	REPLACE = 2,
164 }
165 alias GBusNameOwnerFlags BusNameOwnerFlags;
166 
167 /**
168  * Flags used in g_bus_watch_name().
169  *
170  * Since: 2.26
171  */
172 public enum GBusNameWatcherFlags
173 {
174 	/**
175 	 * No flags set.
176 	 */
177 	NONE = 0,
178 	/**
179 	 * If no-one owns the name when
180 	 * beginning to watch the name, ask the bus to launch an owner for the
181 	 * name.
182 	 */
183 	AUTO_START = 1,
184 }
185 alias GBusNameWatcherFlags BusNameWatcherFlags;
186 
187 /**
188  * An enumeration for well-known message buses.
189  *
190  * Since: 2.26
191  */
192 public enum GBusType
193 {
194 	/**
195 	 * An alias for the message bus that activated the process, if any.
196 	 */
197 	STARTER = -1,
198 	/**
199 	 * Not a message bus.
200 	 */
201 	NONE = 0,
202 	/**
203 	 * The system-wide message bus.
204 	 */
205 	SYSTEM = 1,
206 	/**
207 	 * The login session message bus.
208 	 */
209 	SESSION = 2,
210 }
211 alias GBusType BusType;
212 
213 /**
214  * Flags used when calling a g_converter_convert().
215  *
216  * Since: 2.24
217  */
218 public enum GConverterFlags
219 {
220 	/**
221 	 * No flags.
222 	 */
223 	NONE = 0,
224 	/**
225 	 * At end of input data
226 	 */
227 	INPUT_AT_END = 1,
228 	/**
229 	 * Flush data
230 	 */
231 	FLUSH = 2,
232 }
233 alias GConverterFlags ConverterFlags;
234 
235 /**
236  * Results returned from g_converter_convert().
237  *
238  * Since: 2.24
239  */
240 public enum GConverterResult
241 {
242 	/**
243 	 * There was an error during conversion.
244 	 */
245 	ERROR = 0,
246 	/**
247 	 * Some data was consumed or produced
248 	 */
249 	CONVERTED = 1,
250 	/**
251 	 * The conversion is finished
252 	 */
253 	FINISHED = 2,
254 	/**
255 	 * Flushing is finished
256 	 */
257 	FLUSHED = 3,
258 }
259 alias GConverterResult ConverterResult;
260 
261 /**
262  * Enumeration describing different kinds of native credential types.
263  *
264  * Since: 2.26
265  */
266 public enum GCredentialsType
267 {
268 	/**
269 	 * Indicates an invalid native credential type.
270 	 */
271 	INVALID = 0,
272 	/**
273 	 * The native credentials type is a <type>struct ucred</type>.
274 	 */
275 	LINUX_UCRED = 1,
276 	/**
277 	 * The native credentials type is a <type>struct cmsgcred</type>.
278 	 */
279 	FREEBSD_CMSGCRED = 2,
280 	/**
281 	 * The native credentials type is a <type>struct unpcbid</type>.
282 	 */
283 	NETBSD_UNPCBID = 3,
284 	/**
285 	 * The native credentials type is a <type>struct sockpeercred</type>. Added in 2.30.
286 	 */
287 	OPENBSD_SOCKPEERCRED = 4,
288 	/**
289 	 * The native credentials type is a <type>ucred_t</type>. Added in 2.40.
290 	 */
291 	SOLARIS_UCRED = 5,
292 }
293 alias GCredentialsType CredentialsType;
294 
295 /**
296  * Flags used in g_dbus_connection_call() and similar APIs.
297  *
298  * Since: 2.26
299  */
300 public enum GDBusCallFlags
301 {
302 	/**
303 	 * No flags set.
304 	 */
305 	NONE = 0,
306 	/**
307 	 * The bus must not launch
308 	 * an owner for the destination name in response to this method
309 	 * invocation.
310 	 */
311 	NO_AUTO_START = 1,
312 }
313 alias GDBusCallFlags DBusCallFlags;
314 
315 /**
316  * Capabilities negotiated with the remote peer.
317  *
318  * Since: 2.26
319  */
320 public enum GDBusCapabilityFlags
321 {
322 	/**
323 	 * No flags set.
324 	 */
325 	NONE = 0,
326 	/**
327 	 * The connection
328 	 * supports exchanging UNIX file descriptors with the remote peer.
329 	 */
330 	UNIX_FD_PASSING = 1,
331 }
332 alias GDBusCapabilityFlags DBusCapabilityFlags;
333 
334 /**
335  * Flags used when creating a new #GDBusConnection.
336  *
337  * Since: 2.26
338  */
339 public enum GDBusConnectionFlags
340 {
341 	/**
342 	 * No flags set.
343 	 */
344 	NONE = 0,
345 	/**
346 	 * Perform authentication against server.
347 	 */
348 	AUTHENTICATION_CLIENT = 1,
349 	/**
350 	 * Perform authentication against client.
351 	 */
352 	AUTHENTICATION_SERVER = 2,
353 	/**
354 	 * When
355 	 * authenticating as a server, allow the anonymous authentication
356 	 * method.
357 	 */
358 	AUTHENTICATION_ALLOW_ANONYMOUS = 4,
359 	/**
360 	 * Pass this flag if connecting to a peer that is a
361 	 * message bus. This means that the Hello() method will be invoked as part of the connection setup.
362 	 */
363 	MESSAGE_BUS_CONNECTION = 8,
364 	/**
365 	 * If set, processing of D-Bus messages is
366 	 * delayed until g_dbus_connection_start_message_processing() is called.
367 	 */
368 	DELAY_MESSAGE_PROCESSING = 16,
369 }
370 alias GDBusConnectionFlags DBusConnectionFlags;
371 
372 /**
373  * Error codes for the %G_DBUS_ERROR error domain.
374  *
375  * Since: 2.26
376  */
377 public enum GDBusError
378 {
379 	/**
380 	 * A generic error; "something went wrong" - see the error message for
381 	 * more.
382 	 */
383 	FAILED = 0,
384 	/**
385 	 * There was not enough memory to complete an operation.
386 	 */
387 	NO_MEMORY = 1,
388 	/**
389 	 * The bus doesn't know how to launch a service to supply the bus name
390 	 * you wanted.
391 	 */
392 	SERVICE_UNKNOWN = 2,
393 	/**
394 	 * The bus name you referenced doesn't exist (i.e. no application owns
395 	 * it).
396 	 */
397 	NAME_HAS_NO_OWNER = 3,
398 	/**
399 	 * No reply to a message expecting one, usually means a timeout occurred.
400 	 */
401 	NO_REPLY = 4,
402 	/**
403 	 * Something went wrong reading or writing to a socket, for example.
404 	 */
405 	IO_ERROR = 5,
406 	/**
407 	 * A D-Bus bus address was malformed.
408 	 */
409 	BAD_ADDRESS = 6,
410 	/**
411 	 * Requested operation isn't supported (like ENOSYS on UNIX).
412 	 */
413 	NOT_SUPPORTED = 7,
414 	/**
415 	 * Some limited resource is exhausted.
416 	 */
417 	LIMITS_EXCEEDED = 8,
418 	/**
419 	 * Security restrictions don't allow doing what you're trying to do.
420 	 */
421 	ACCESS_DENIED = 9,
422 	/**
423 	 * Authentication didn't work.
424 	 */
425 	AUTH_FAILED = 10,
426 	/**
427 	 * Unable to connect to server (probably caused by ECONNREFUSED on a
428 	 * socket).
429 	 */
430 	NO_SERVER = 11,
431 	/**
432 	 * Certain timeout errors, possibly ETIMEDOUT on a socket.  Note that
433 	 * %G_DBUS_ERROR_NO_REPLY is used for message reply timeouts. Warning:
434 	 * this is confusingly-named given that %G_DBUS_ERROR_TIMED_OUT also
435 	 * exists. We can't fix it for compatibility reasons so just be
436 	 * careful.
437 	 */
438 	TIMEOUT = 12,
439 	/**
440 	 * No network access (probably ENETUNREACH on a socket).
441 	 */
442 	NO_NETWORK = 13,
443 	/**
444 	 * Can't bind a socket since its address is in use (i.e. EADDRINUSE).
445 	 */
446 	ADDRESS_IN_USE = 14,
447 	/**
448 	 * The connection is disconnected and you're trying to use it.
449 	 */
450 	DISCONNECTED = 15,
451 	/**
452 	 * Invalid arguments passed to a method call.
453 	 */
454 	INVALID_ARGS = 16,
455 	/**
456 	 * Missing file.
457 	 */
458 	FILE_NOT_FOUND = 17,
459 	/**
460 	 * Existing file and the operation you're using does not silently overwrite.
461 	 */
462 	FILE_EXISTS = 18,
463 	/**
464 	 * Method name you invoked isn't known by the object you invoked it on.
465 	 */
466 	UNKNOWN_METHOD = 19,
467 	/**
468 	 * Certain timeout errors, e.g. while starting a service. Warning: this is
469 	 * confusingly-named given that %G_DBUS_ERROR_TIMEOUT also exists. We
470 	 * can't fix it for compatibility reasons so just be careful.
471 	 */
472 	TIMED_OUT = 20,
473 	/**
474 	 * Tried to remove or modify a match rule that didn't exist.
475 	 */
476 	MATCH_RULE_NOT_FOUND = 21,
477 	/**
478 	 * The match rule isn't syntactically valid.
479 	 */
480 	MATCH_RULE_INVALID = 22,
481 	/**
482 	 * While starting a new process, the exec() call failed.
483 	 */
484 	SPAWN_EXEC_FAILED = 23,
485 	/**
486 	 * While starting a new process, the fork() call failed.
487 	 */
488 	SPAWN_FORK_FAILED = 24,
489 	/**
490 	 * While starting a new process, the child exited with a status code.
491 	 */
492 	SPAWN_CHILD_EXITED = 25,
493 	/**
494 	 * While starting a new process, the child exited on a signal.
495 	 */
496 	SPAWN_CHILD_SIGNALED = 26,
497 	/**
498 	 * While starting a new process, something went wrong.
499 	 */
500 	SPAWN_FAILED = 27,
501 	/**
502 	 * We failed to setup the environment correctly.
503 	 */
504 	SPAWN_SETUP_FAILED = 28,
505 	/**
506 	 * We failed to setup the config parser correctly.
507 	 */
508 	SPAWN_CONFIG_INVALID = 29,
509 	/**
510 	 * Bus name was not valid.
511 	 */
512 	SPAWN_SERVICE_INVALID = 30,
513 	/**
514 	 * Service file not found in system-services directory.
515 	 */
516 	SPAWN_SERVICE_NOT_FOUND = 31,
517 	/**
518 	 * Permissions are incorrect on the setuid helper.
519 	 */
520 	SPAWN_PERMISSIONS_INVALID = 32,
521 	/**
522 	 * Service file invalid (Name, User or Exec missing).
523 	 */
524 	SPAWN_FILE_INVALID = 33,
525 	/**
526 	 * Tried to get a UNIX process ID and it wasn't available.
527 	 */
528 	SPAWN_NO_MEMORY = 34,
529 	/**
530 	 * Tried to get a UNIX process ID and it wasn't available.
531 	 */
532 	UNIX_PROCESS_ID_UNKNOWN = 35,
533 	/**
534 	 * A type signature is not valid.
535 	 */
536 	INVALID_SIGNATURE = 36,
537 	/**
538 	 * A file contains invalid syntax or is otherwise broken.
539 	 */
540 	INVALID_FILE_CONTENT = 37,
541 	/**
542 	 * Asked for SELinux security context and it wasn't available.
543 	 */
544 	SELINUX_SECURITY_CONTEXT_UNKNOWN = 38,
545 	/**
546 	 * Asked for ADT audit data and it wasn't available.
547 	 */
548 	ADT_AUDIT_DATA_UNKNOWN = 39,
549 	/**
550 	 * There's already an object with the requested object path.
551 	 */
552 	OBJECT_PATH_IN_USE = 40,
553 	/**
554 	 * Object you invoked a method on isn't known. Since 2.42
555 	 */
556 	UNKNOWN_OBJECT = 41,
557 	/**
558 	 * Interface you invoked a method on isn't known by the object. Since 2.42
559 	 */
560 	UNKNOWN_INTERFACE = 42,
561 	/**
562 	 * Property you tried to access isn't known by the object. Since 2.42
563 	 */
564 	UNKNOWN_PROPERTY = 43,
565 	/**
566 	 * Property you tried to set is read-only. Since 2.42
567 	 */
568 	PROPERTY_READ_ONLY = 44,
569 }
570 alias GDBusError DBusError;
571 
572 /**
573  * Flags describing the behavior of a #GDBusInterfaceSkeleton instance.
574  *
575  * Since: 2.30
576  */
577 public enum GDBusInterfaceSkeletonFlags
578 {
579 	/**
580 	 * No flags set.
581 	 */
582 	NONE = 0,
583 	/**
584 	 * Each method invocation is handled in
585 	 * a thread dedicated to the invocation. This means that the method implementation can use blocking IO
586 	 * without blocking any other part of the process. It also means that the method implementation must
587 	 * use locking to access data structures used by other threads.
588 	 */
589 	HANDLE_METHOD_INVOCATIONS_IN_THREAD = 1,
590 }
591 alias GDBusInterfaceSkeletonFlags DBusInterfaceSkeletonFlags;
592 
593 /**
594  * Enumeration used to describe the byte order of a D-Bus message.
595  *
596  * Since: 2.26
597  */
598 public enum GDBusMessageByteOrder
599 {
600 	/**
601 	 * The byte order is big endian.
602 	 */
603 	BIG_ENDIAN = 66,
604 	/**
605 	 * The byte order is little endian.
606 	 */
607 	LITTLE_ENDIAN = 108,
608 }
609 alias GDBusMessageByteOrder DBusMessageByteOrder;
610 
611 /**
612  * Message flags used in #GDBusMessage.
613  *
614  * Since: 2.26
615  */
616 public enum GDBusMessageFlags
617 {
618 	/**
619 	 * No flags set.
620 	 */
621 	NONE = 0,
622 	/**
623 	 * A reply is not expected.
624 	 */
625 	NO_REPLY_EXPECTED = 1,
626 	/**
627 	 * The bus must not launch an
628 	 * owner for the destination name in response to this message.
629 	 */
630 	NO_AUTO_START = 2,
631 }
632 alias GDBusMessageFlags DBusMessageFlags;
633 
634 /**
635  * Header fields used in #GDBusMessage.
636  *
637  * Since: 2.26
638  */
639 public enum GDBusMessageHeaderField
640 {
641 	/**
642 	 * Not a valid header field.
643 	 */
644 	INVALID = 0,
645 	/**
646 	 * The object path.
647 	 */
648 	PATH = 1,
649 	/**
650 	 * The interface name.
651 	 */
652 	INTERFACE = 2,
653 	/**
654 	 * The method or signal name.
655 	 */
656 	MEMBER = 3,
657 	/**
658 	 * The name of the error that occurred.
659 	 */
660 	ERROR_NAME = 4,
661 	/**
662 	 * The serial number the message is a reply to.
663 	 */
664 	REPLY_SERIAL = 5,
665 	/**
666 	 * The name the message is intended for.
667 	 */
668 	DESTINATION = 6,
669 	/**
670 	 * Unique name of the sender of the message (filled in by the bus).
671 	 */
672 	SENDER = 7,
673 	/**
674 	 * The signature of the message body.
675 	 */
676 	SIGNATURE = 8,
677 	/**
678 	 * The number of UNIX file descriptors that accompany the message.
679 	 */
680 	NUM_UNIX_FDS = 9,
681 }
682 alias GDBusMessageHeaderField DBusMessageHeaderField;
683 
684 /**
685  * Message types used in #GDBusMessage.
686  *
687  * Since: 2.26
688  */
689 public enum GDBusMessageType
690 {
691 	/**
692 	 * Message is of invalid type.
693 	 */
694 	INVALID = 0,
695 	/**
696 	 * Method call.
697 	 */
698 	METHOD_CALL = 1,
699 	/**
700 	 * Method reply.
701 	 */
702 	METHOD_RETURN = 2,
703 	/**
704 	 * Error reply.
705 	 */
706 	ERROR = 3,
707 	/**
708 	 * Signal emission.
709 	 */
710 	SIGNAL = 4,
711 }
712 alias GDBusMessageType DBusMessageType;
713 
714 /**
715  * Flags used when constructing a #GDBusObjectManagerClient.
716  *
717  * Since: 2.30
718  */
719 public enum GDBusObjectManagerClientFlags
720 {
721 	/**
722 	 * No flags set.
723 	 */
724 	NONE = 0,
725 	/**
726 	 * If not set and the
727 	 * manager is for a well-known name, then request the bus to launch
728 	 * an owner for the name if no-one owns the name. This flag can only
729 	 * be used in managers for well-known names.
730 	 */
731 	DO_NOT_AUTO_START = 1,
732 }
733 alias GDBusObjectManagerClientFlags DBusObjectManagerClientFlags;
734 
735 /**
736  * Flags describing the access control of a D-Bus property.
737  *
738  * Since: 2.26
739  */
740 public enum GDBusPropertyInfoFlags
741 {
742 	/**
743 	 * No flags set.
744 	 */
745 	NONE = 0,
746 	/**
747 	 * Property is readable.
748 	 */
749 	READABLE = 1,
750 	/**
751 	 * Property is writable.
752 	 */
753 	WRITABLE = 2,
754 }
755 alias GDBusPropertyInfoFlags DBusPropertyInfoFlags;
756 
757 /**
758  * Flags used when constructing an instance of a #GDBusProxy derived class.
759  *
760  * Since: 2.26
761  */
762 public enum GDBusProxyFlags
763 {
764 	/**
765 	 * No flags set.
766 	 */
767 	NONE = 0,
768 	/**
769 	 * Don't load properties.
770 	 */
771 	DO_NOT_LOAD_PROPERTIES = 1,
772 	/**
773 	 * Don't connect to signals on the remote object.
774 	 */
775 	DO_NOT_CONNECT_SIGNALS = 2,
776 	/**
777 	 * If not set and the proxy if for a well-known name,
778 	 * then request the bus to launch an owner for the name if no-one owns the name. This flag can
779 	 * only be used in proxies for well-known names.
780 	 */
781 	DO_NOT_AUTO_START = 4,
782 	/**
783 	 * If set, the property value for any <emphasis>invalidated property</emphasis> will be (asynchronously) retrieved upon receiving the <ulink url="http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties">PropertiesChanged</ulink> D-Bus signal and the property will not cause emission of the #GDBusProxy::g-properties-changed signal. When the value is received the #GDBusProxy::g-properties-changed signal is emitted for the property along with the retrieved value. Since 2.32.
784 	 */
785 	GET_INVALIDATED_PROPERTIES = 8,
786 	/**
787 	 * If the proxy is for a well-known name,
788 	 * do not ask the bus to launch an owner during proxy initialization, but allow it to be
789 	 * autostarted by a method call. This flag is only meaningful in proxies for well-known names,
790 	 * and only if %G_DBUS_PROXY_FLAGS_DO_NOT_AUTOSTART is not also specified.
791 	 */
792 	DO_NOT_AUTO_START_AT_CONSTRUCTION = 16,
793 }
794 alias GDBusProxyFlags DBusProxyFlags;
795 
796 /**
797  * Flags used when sending #GDBusMessages on a #GDBusConnection.
798  *
799  * Since: 2.26
800  */
801 public enum GDBusSendMessageFlags
802 {
803 	/**
804 	 * No flags set.
805 	 */
806 	NONE = 0,
807 	/**
808 	 * Do not automatically
809 	 * assign a serial number from the #GDBusConnection object when
810 	 * sending a message.
811 	 */
812 	PRESERVE_SERIAL = 1,
813 }
814 alias GDBusSendMessageFlags DBusSendMessageFlags;
815 
816 /**
817  * Flags used when creating a #GDBusServer.
818  *
819  * Since: 2.26
820  */
821 public enum GDBusServerFlags
822 {
823 	/**
824 	 * No flags set.
825 	 */
826 	NONE = 0,
827 	/**
828 	 * All #GDBusServer::new-connection
829 	 * signals will run in separated dedicated threads (see signal for
830 	 * details).
831 	 */
832 	RUN_IN_THREAD = 1,
833 	/**
834 	 * Allow the anonymous
835 	 * authentication method.
836 	 */
837 	AUTHENTICATION_ALLOW_ANONYMOUS = 2,
838 }
839 alias GDBusServerFlags DBusServerFlags;
840 
841 /**
842  * Flags used when subscribing to signals via g_dbus_connection_signal_subscribe().
843  *
844  * Since: 2.26
845  */
846 public enum GDBusSignalFlags
847 {
848 	/**
849 	 * No flags set.
850 	 */
851 	NONE = 0,
852 	/**
853 	 * Don't actually send the AddMatch
854 	 * D-Bus call for this signal subscription.  This gives you more control
855 	 * over which match rules you add (but you must add them manually).
856 	 */
857 	NO_MATCH_RULE = 1,
858 	/**
859 	 * Match first arguments that
860 	 * contain a bus or interface name with the given namespace.
861 	 */
862 	MATCH_ARG0_NAMESPACE = 2,
863 	/**
864 	 * Match first arguments that
865 	 * contain an object path that is either equivalent to the given path,
866 	 * or one of the paths is a subpath of the other.
867 	 */
868 	MATCH_ARG0_PATH = 4,
869 }
870 alias GDBusSignalFlags DBusSignalFlags;
871 
872 /**
873  * Flags passed to g_dbus_connection_register_subtree().
874  *
875  * Since: 2.26
876  */
877 public enum GDBusSubtreeFlags
878 {
879 	/**
880 	 * No flags set.
881 	 */
882 	NONE = 0,
883 	/**
884 	 * Method calls to objects not in the enumerated range
885 	 * will still be dispatched. This is useful if you want
886 	 * to dynamically spawn objects in the subtree.
887 	 */
888 	DISPATCH_TO_UNENUMERATED_NODES = 1,
889 }
890 alias GDBusSubtreeFlags DBusSubtreeFlags;
891 
892 /**
893  * #GDataStreamByteOrder is used to ensure proper endianness of streaming data sources
894  * across various machine architectures.
895  */
896 public enum GDataStreamByteOrder
897 {
898 	/**
899 	 * Selects Big Endian byte order.
900 	 */
901 	BIG_ENDIAN = 0,
902 	/**
903 	 * Selects Little Endian byte order.
904 	 */
905 	LITTLE_ENDIAN = 1,
906 	/**
907 	 * Selects endianness based on host machine's architecture.
908 	 */
909 	HOST_ENDIAN = 2,
910 }
911 alias GDataStreamByteOrder DataStreamByteOrder;
912 
913 /**
914  * #GDataStreamNewlineType is used when checking for or setting the line endings for a given file.
915  */
916 public enum GDataStreamNewlineType
917 {
918 	/**
919 	 * Selects "LF" line endings, common on most modern UNIX platforms.
920 	 */
921 	LF = 0,
922 	/**
923 	 * Selects "CR" line endings.
924 	 */
925 	CR = 1,
926 	/**
927 	 * Selects "CR, LF" line ending, common on Microsoft Windows.
928 	 */
929 	CR_LF = 2,
930 	/**
931 	 * Automatically try to handle any line ending type.
932 	 */
933 	ANY = 3,
934 }
935 alias GDataStreamNewlineType DataStreamNewlineType;
936 
937 /**
938  * Flags used when starting a drive.
939  *
940  * Since: 2.22
941  */
942 public enum GDriveStartFlags
943 {
944 	/**
945 	 * No flags set.
946 	 */
947 	NONE = 0,
948 }
949 alias GDriveStartFlags DriveStartFlags;
950 
951 /**
952  * Enumeration describing how a drive can be started/stopped.
953  *
954  * Since: 2.22
955  */
956 public enum GDriveStartStopType
957 {
958 	/**
959 	 * Unknown or drive doesn't support
960 	 * start/stop.
961 	 */
962 	UNKNOWN = 0,
963 	/**
964 	 * The stop method will physically
965 	 * shut down the drive and e.g. power down the port the drive is
966 	 * attached to.
967 	 */
968 	SHUTDOWN = 1,
969 	/**
970 	 * The start/stop methods are used
971 	 * for connecting/disconnect to the drive over the network.
972 	 */
973 	NETWORK = 2,
974 	/**
975 	 * The start/stop methods will
976 	 * assemble/disassemble a virtual drive from several physical
977 	 * drives.
978 	 */
979 	MULTIDISK = 3,
980 	/**
981 	 * The start/stop methods will
982 	 * unlock/lock the disk (for example using the ATA <quote>SECURITY
983 	 * UNLOCK DEVICE</quote> command)
984 	 */
985 	PASSWORD = 4,
986 }
987 alias GDriveStartStopType DriveStartStopType;
988 
989 /**
990  * GEmblemOrigin is used to add information about the origin of the emblem
991  * to #GEmblem.
992  *
993  * Since: 2.18
994  */
995 public enum GEmblemOrigin
996 {
997 	/**
998 	 * Emblem of unknown origin
999 	 */
1000 	UNKNOWN = 0,
1001 	/**
1002 	 * Emblem adds device-specific information
1003 	 */
1004 	DEVICE = 1,
1005 	/**
1006 	 * Emblem depicts live metadata, such as "readonly"
1007 	 */
1008 	LIVEMETADATA = 2,
1009 	/**
1010 	 * Emblem comes from a user-defined tag, e.g. set by nautilus (in the future)
1011 	 */
1012 	TAG = 3,
1013 }
1014 alias GEmblemOrigin EmblemOrigin;
1015 
1016 /**
1017  * Flags specifying the behaviour of an attribute.
1018  */
1019 public enum GFileAttributeInfoFlags
1020 {
1021 	/**
1022 	 * no flags set.
1023 	 */
1024 	NONE = 0,
1025 	/**
1026 	 * copy the attribute values when the file is copied.
1027 	 */
1028 	COPY_WITH_FILE = 1,
1029 	/**
1030 	 * copy the attribute values when the file is moved.
1031 	 */
1032 	COPY_WHEN_MOVED = 2,
1033 }
1034 alias GFileAttributeInfoFlags FileAttributeInfoFlags;
1035 
1036 /**
1037  * Used by g_file_set_attributes_from_info() when setting file attributes.
1038  */
1039 public enum GFileAttributeStatus
1040 {
1041 	/**
1042 	 * Attribute value is unset (empty).
1043 	 */
1044 	UNSET = 0,
1045 	/**
1046 	 * Attribute value is set.
1047 	 */
1048 	SET = 1,
1049 	/**
1050 	 * Indicates an error in setting the value.
1051 	 */
1052 	ERROR_SETTING = 2,
1053 }
1054 alias GFileAttributeStatus FileAttributeStatus;
1055 
1056 /**
1057  * The data types for file attributes.
1058  */
1059 public enum GFileAttributeType
1060 {
1061 	/**
1062 	 * indicates an invalid or uninitalized type.
1063 	 */
1064 	INVALID = 0,
1065 	/**
1066 	 * a null terminated UTF8 string.
1067 	 */
1068 	STRING = 1,
1069 	/**
1070 	 * a zero terminated string of non-zero bytes.
1071 	 */
1072 	BYTE_STRING = 2,
1073 	/**
1074 	 * a boolean value.
1075 	 */
1076 	BOOLEAN = 3,
1077 	/**
1078 	 * an unsigned 4-byte/32-bit integer.
1079 	 */
1080 	UINT32 = 4,
1081 	/**
1082 	 * a signed 4-byte/32-bit integer.
1083 	 */
1084 	INT32 = 5,
1085 	/**
1086 	 * an unsigned 8-byte/64-bit integer.
1087 	 */
1088 	UINT64 = 6,
1089 	/**
1090 	 * a signed 8-byte/64-bit integer.
1091 	 */
1092 	INT64 = 7,
1093 	/**
1094 	 * a #GObject.
1095 	 */
1096 	OBJECT = 8,
1097 	/**
1098 	 * a %NULL terminated char **. Since 2.22
1099 	 */
1100 	STRINGV = 9,
1101 }
1102 alias GFileAttributeType FileAttributeType;
1103 
1104 /**
1105  * Flags used when copying or moving files.
1106  */
1107 public enum GFileCopyFlags
1108 {
1109 	/**
1110 	 * No flags set.
1111 	 */
1112 	NONE = 0,
1113 	/**
1114 	 * Overwrite any existing files
1115 	 */
1116 	OVERWRITE = 1,
1117 	/**
1118 	 * Make a backup of any existing files.
1119 	 */
1120 	BACKUP = 2,
1121 	/**
1122 	 * Don't follow symlinks.
1123 	 */
1124 	NOFOLLOW_SYMLINKS = 4,
1125 	/**
1126 	 * Copy all file metadata instead of just default set used for copy (see #GFileInfo).
1127 	 */
1128 	ALL_METADATA = 8,
1129 	/**
1130 	 * Don't use copy and delete fallback if native move not supported.
1131 	 */
1132 	NO_FALLBACK_FOR_MOVE = 16,
1133 	/**
1134 	 * Leaves target file with default perms, instead of setting the source file perms.
1135 	 */
1136 	TARGET_DEFAULT_PERMS = 32,
1137 }
1138 alias GFileCopyFlags FileCopyFlags;
1139 
1140 /**
1141  * Flags used when an operation may create a file.
1142  */
1143 public enum GFileCreateFlags
1144 {
1145 	/**
1146 	 * No flags set.
1147 	 */
1148 	NONE = 0,
1149 	/**
1150 	 * Create a file that can only be
1151 	 * accessed by the current user.
1152 	 */
1153 	PRIVATE = 1,
1154 	/**
1155 	 * Replace the destination
1156 	 * as if it didn't exist before. Don't try to keep any old
1157 	 * permissions, replace instead of following links. This
1158 	 * is generally useful if you're doing a "copy over"
1159 	 * rather than a "save new version of" replace operation.
1160 	 * You can think of it as "unlink destination" before
1161 	 * writing to it, although the implementation may not
1162 	 * be exactly like that. Since 2.20
1163 	 */
1164 	REPLACE_DESTINATION = 2,
1165 }
1166 alias GFileCreateFlags FileCreateFlags;
1167 
1168 /**
1169  * Flags that can be used with g_file_measure_disk_usage().
1170  *
1171  * Since: 2.38
1172  */
1173 public enum GFileMeasureFlags
1174 {
1175 	/**
1176 	 * No flags set.
1177 	 */
1178 	NONE = 0,
1179 	/**
1180 	 * Report any error encountered
1181 	 * while traversing the directory tree.  Normally errors are only
1182 	 * reported for the toplevel file.
1183 	 */
1184 	REPORT_ANY_ERROR = 2,
1185 	/**
1186 	 * Tally usage based on apparent file
1187 	 * sizes.  Normally, the block-size is used, if available, as this is a
1188 	 * more accurate representation of disk space used.
1189 	 * Compare with `du --apparent-size`.
1190 	 */
1191 	APPARENT_SIZE = 4,
1192 	/**
1193 	 * Do not cross mount point boundaries.
1194 	 * Compare with `du -x`.
1195 	 */
1196 	NO_XDEV = 8,
1197 }
1198 alias GFileMeasureFlags FileMeasureFlags;
1199 
1200 /**
1201  * Specifies what type of event a monitor event is.
1202  */
1203 public enum GFileMonitorEvent
1204 {
1205 	/**
1206 	 * a file changed.
1207 	 */
1208 	CHANGED = 0,
1209 	/**
1210 	 * a hint that this was probably the last change in a set of changes.
1211 	 */
1212 	CHANGES_DONE_HINT = 1,
1213 	/**
1214 	 * a file was deleted.
1215 	 */
1216 	DELETED = 2,
1217 	/**
1218 	 * a file was created.
1219 	 */
1220 	CREATED = 3,
1221 	/**
1222 	 * a file attribute was changed.
1223 	 */
1224 	ATTRIBUTE_CHANGED = 4,
1225 	/**
1226 	 * the file location will soon be unmounted.
1227 	 */
1228 	PRE_UNMOUNT = 5,
1229 	/**
1230 	 * the file location was unmounted.
1231 	 */
1232 	UNMOUNTED = 6,
1233 	/**
1234 	 * the file was moved.
1235 	 */
1236 	MOVED = 7,
1237 }
1238 alias GFileMonitorEvent FileMonitorEvent;
1239 
1240 /**
1241  * Flags used to set what a #GFileMonitor will watch for.
1242  */
1243 public enum GFileMonitorFlags
1244 {
1245 	/**
1246 	 * No flags set.
1247 	 */
1248 	NONE = 0,
1249 	/**
1250 	 * Watch for mount events.
1251 	 */
1252 	WATCH_MOUNTS = 1,
1253 	/**
1254 	 * Pair DELETED and CREATED events caused
1255 	 * by file renames (moves) and send a single G_FILE_MONITOR_EVENT_MOVED
1256 	 * event instead (NB: not supported on all backends; the default
1257 	 * behaviour -without specifying this flag- is to send single DELETED
1258 	 * and CREATED events).
1259 	 */
1260 	SEND_MOVED = 2,
1261 	/**
1262 	 * Watch for changes to the file made
1263 	 * via another hard link. Since 2.36.
1264 	 */
1265 	WATCH_HARD_LINKS = 4,
1266 }
1267 alias GFileMonitorFlags FileMonitorFlags;
1268 
1269 /**
1270  * Flags used when querying a #GFileInfo.
1271  */
1272 public enum GFileQueryInfoFlags
1273 {
1274 	/**
1275 	 * No flags set.
1276 	 */
1277 	NONE = 0,
1278 	/**
1279 	 * Don't follow symlinks.
1280 	 */
1281 	NOFOLLOW_SYMLINKS = 1,
1282 }
1283 alias GFileQueryInfoFlags FileQueryInfoFlags;
1284 
1285 /**
1286  * Indicates the file's on-disk type.
1287  */
1288 public enum GFileType
1289 {
1290 	/**
1291 	 * File's type is unknown.
1292 	 */
1293 	UNKNOWN = 0,
1294 	/**
1295 	 * File handle represents a regular file.
1296 	 */
1297 	REGULAR = 1,
1298 	/**
1299 	 * File handle represents a directory.
1300 	 */
1301 	DIRECTORY = 2,
1302 	/**
1303 	 * File handle represents a symbolic link
1304 	 * (Unix systems).
1305 	 */
1306 	SYMBOLIC_LINK = 3,
1307 	/**
1308 	 * File is a "special" file, such as a socket, fifo,
1309 	 * block device, or character device.
1310 	 */
1311 	SPECIAL = 4,
1312 	/**
1313 	 * File is a shortcut (Windows systems).
1314 	 */
1315 	SHORTCUT = 5,
1316 	/**
1317 	 * File is a mountable location.
1318 	 */
1319 	MOUNTABLE = 6,
1320 }
1321 alias GFileType FileType;
1322 
1323 /**
1324  * Indicates a hint from the file system whether files should be
1325  * previewed in a file manager. Returned as the value of the key
1326  * #G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW.
1327  */
1328 public enum GFilesystemPreviewType
1329 {
1330 	/**
1331 	 * Only preview files if user has explicitly requested it.
1332 	 */
1333 	IF_ALWAYS = 0,
1334 	/**
1335 	 * Preview files if user has requested preview of "local" files.
1336 	 */
1337 	IF_LOCAL = 1,
1338 	/**
1339 	 * Never preview files.
1340 	 */
1341 	NEVER = 2,
1342 }
1343 alias GFilesystemPreviewType FilesystemPreviewType;
1344 
1345 /**
1346  * Error codes returned by GIO functions.
1347  *
1348  * Note that this domain may be extended in future GLib releases. In
1349  * general, new error codes either only apply to new APIs, or else
1350  * replace #G_IO_ERROR_FAILED in cases that were not explicitly
1351  * distinguished before. You should therefore avoid writing code like
1352  * |[<!-- language="C" -->
1353  * if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED))
1354  * {
1355  * // Assume that this is EPRINTERONFIRE
1356  * ...
1357  * }
1358  * ]|
1359  * but should instead treat all unrecognized error codes the same as
1360  * #G_IO_ERROR_FAILED.
1361  */
1362 public enum GIOErrorEnum
1363 {
1364 	/**
1365 	 * Generic error condition for when an operation fails
1366 	 * and no more specific #GIOErrorEnum value is defined.
1367 	 */
1368 	FAILED = 0,
1369 	/**
1370 	 * File not found.
1371 	 */
1372 	NOT_FOUND = 1,
1373 	/**
1374 	 * File already exists.
1375 	 */
1376 	EXISTS = 2,
1377 	/**
1378 	 * File is a directory.
1379 	 */
1380 	IS_DIRECTORY = 3,
1381 	/**
1382 	 * File is not a directory.
1383 	 */
1384 	NOT_DIRECTORY = 4,
1385 	/**
1386 	 * File is a directory that isn't empty.
1387 	 */
1388 	NOT_EMPTY = 5,
1389 	/**
1390 	 * File is not a regular file.
1391 	 */
1392 	NOT_REGULAR_FILE = 6,
1393 	/**
1394 	 * File is not a symbolic link.
1395 	 */
1396 	NOT_SYMBOLIC_LINK = 7,
1397 	/**
1398 	 * File cannot be mounted.
1399 	 */
1400 	NOT_MOUNTABLE_FILE = 8,
1401 	/**
1402 	 * Filename is too many characters.
1403 	 */
1404 	FILENAME_TOO_LONG = 9,
1405 	/**
1406 	 * Filename is invalid or contains invalid characters.
1407 	 */
1408 	INVALID_FILENAME = 10,
1409 	/**
1410 	 * File contains too many symbolic links.
1411 	 */
1412 	TOO_MANY_LINKS = 11,
1413 	/**
1414 	 * No space left on drive.
1415 	 */
1416 	NO_SPACE = 12,
1417 	/**
1418 	 * Invalid argument.
1419 	 */
1420 	INVALID_ARGUMENT = 13,
1421 	/**
1422 	 * Permission denied.
1423 	 */
1424 	PERMISSION_DENIED = 14,
1425 	/**
1426 	 * Operation (or one of its parameters) not supported
1427 	 */
1428 	NOT_SUPPORTED = 15,
1429 	/**
1430 	 * File isn't mounted.
1431 	 */
1432 	NOT_MOUNTED = 16,
1433 	/**
1434 	 * File is already mounted.
1435 	 */
1436 	ALREADY_MOUNTED = 17,
1437 	/**
1438 	 * File was closed.
1439 	 */
1440 	CLOSED = 18,
1441 	/**
1442 	 * Operation was cancelled. See #GCancellable.
1443 	 */
1444 	CANCELLED = 19,
1445 	/**
1446 	 * Operations are still pending.
1447 	 */
1448 	PENDING = 20,
1449 	/**
1450 	 * File is read only.
1451 	 */
1452 	READ_ONLY = 21,
1453 	/**
1454 	 * Backup couldn't be created.
1455 	 */
1456 	CANT_CREATE_BACKUP = 22,
1457 	/**
1458 	 * File's Entity Tag was incorrect.
1459 	 */
1460 	WRONG_ETAG = 23,
1461 	/**
1462 	 * Operation timed out.
1463 	 */
1464 	TIMED_OUT = 24,
1465 	/**
1466 	 * Operation would be recursive.
1467 	 */
1468 	WOULD_RECURSE = 25,
1469 	/**
1470 	 * File is busy.
1471 	 */
1472 	BUSY = 26,
1473 	/**
1474 	 * Operation would block.
1475 	 */
1476 	WOULD_BLOCK = 27,
1477 	/**
1478 	 * Host couldn't be found (remote operations).
1479 	 */
1480 	HOST_NOT_FOUND = 28,
1481 	/**
1482 	 * Operation would merge files.
1483 	 */
1484 	WOULD_MERGE = 29,
1485 	/**
1486 	 * Operation failed and a helper program has
1487 	 * already interacted with the user. Do not display any error dialog.
1488 	 */
1489 	FAILED_HANDLED = 30,
1490 	/**
1491 	 * The current process has too many files
1492 	 * open and can't open any more. Duplicate descriptors do count toward
1493 	 * this limit. Since 2.20
1494 	 */
1495 	TOO_MANY_OPEN_FILES = 31,
1496 	/**
1497 	 * The object has not been initialized. Since 2.22
1498 	 */
1499 	NOT_INITIALIZED = 32,
1500 	/**
1501 	 * The requested address is already in use. Since 2.22
1502 	 */
1503 	ADDRESS_IN_USE = 33,
1504 	/**
1505 	 * Need more input to finish operation. Since 2.24
1506 	 */
1507 	PARTIAL_INPUT = 34,
1508 	/**
1509 	 * The input data was invalid. Since 2.24
1510 	 */
1511 	INVALID_DATA = 35,
1512 	/**
1513 	 * A remote object generated an error that
1514 	 * doesn't correspond to a locally registered #GError error
1515 	 * domain. Use g_dbus_error_get_remote_error() to extract the D-Bus
1516 	 * error name and g_dbus_error_strip_remote_error() to fix up the
1517 	 * message so it matches what was received on the wire. Since 2.26.
1518 	 */
1519 	DBUS_ERROR = 36,
1520 	/**
1521 	 * Host unreachable. Since 2.26
1522 	 */
1523 	HOST_UNREACHABLE = 37,
1524 	/**
1525 	 * Network unreachable. Since 2.26
1526 	 */
1527 	NETWORK_UNREACHABLE = 38,
1528 	/**
1529 	 * Connection refused. Since 2.26
1530 	 */
1531 	CONNECTION_REFUSED = 39,
1532 	/**
1533 	 * Connection to proxy server failed. Since 2.26
1534 	 */
1535 	PROXY_FAILED = 40,
1536 	/**
1537 	 * Proxy authentication failed. Since 2.26
1538 	 */
1539 	PROXY_AUTH_FAILED = 41,
1540 	/**
1541 	 * Proxy server needs authentication. Since 2.26
1542 	 */
1543 	PROXY_NEED_AUTH = 42,
1544 	/**
1545 	 * Proxy connection is not allowed by ruleset.
1546 	 * Since 2.26
1547 	 */
1548 	PROXY_NOT_ALLOWED = 43,
1549 	/**
1550 	 * Broken pipe. Since 2.36
1551 	 */
1552 	BROKEN_PIPE = 44,
1553 }
1554 alias GIOErrorEnum IOErrorEnum;
1555 
1556 /**
1557  * Flags for use with g_io_module_scope_new().
1558  *
1559  * Since: 2.30
1560  */
1561 public enum GIOModuleScopeFlags
1562 {
1563 	/**
1564 	 * No module scan flags
1565 	 */
1566 	NONE = 0,
1567 	/**
1568 	 * When using this scope to load or
1569 	 * scan modules, automatically block a modules which has the same base
1570 	 * basename as previously loaded module.
1571 	 */
1572 	BLOCK_DUPLICATES = 1,
1573 }
1574 alias GIOModuleScopeFlags IOModuleScopeFlags;
1575 
1576 /**
1577  * GIOStreamSpliceFlags determine how streams should be spliced.
1578  *
1579  * Since: 2.28
1580  */
1581 public enum GIOStreamSpliceFlags
1582 {
1583 	/**
1584 	 * Do not close either stream.
1585 	 */
1586 	NONE = 0,
1587 	/**
1588 	 * Close the first stream after
1589 	 * the splice.
1590 	 */
1591 	CLOSE_STREAM1 = 1,
1592 	/**
1593 	 * Close the second stream after
1594 	 * the splice.
1595 	 */
1596 	CLOSE_STREAM2 = 2,
1597 	/**
1598 	 * Wait for both splice operations to finish
1599 	 * before calling the callback.
1600 	 */
1601 	WAIT_FOR_BOTH = 4,
1602 }
1603 alias GIOStreamSpliceFlags IOStreamSpliceFlags;
1604 
1605 /**
1606  * Flags used when mounting a mount.
1607  */
1608 public enum GMountMountFlags
1609 {
1610 	/**
1611 	 * No flags set.
1612 	 */
1613 	NONE = 0,
1614 }
1615 alias GMountMountFlags MountMountFlags;
1616 
1617 /**
1618  * #GMountOperationResult is returned as a result when a request for
1619  * information is send by the mounting operation.
1620  */
1621 public enum GMountOperationResult
1622 {
1623 	/**
1624 	 * The request was fulfilled and the
1625 	 * user specified data is now available
1626 	 */
1627 	HANDLED = 0,
1628 	/**
1629 	 * The user requested the mount operation
1630 	 * to be aborted
1631 	 */
1632 	ABORTED = 1,
1633 	/**
1634 	 * The request was unhandled (i.e. not
1635 	 * implemented)
1636 	 */
1637 	UNHANDLED = 2,
1638 }
1639 alias GMountOperationResult MountOperationResult;
1640 
1641 /**
1642  * Flags used when an unmounting a mount.
1643  */
1644 public enum GMountUnmountFlags
1645 {
1646 	/**
1647 	 * No flags set.
1648 	 */
1649 	NONE = 0,
1650 	/**
1651 	 * Unmount even if there are outstanding
1652 	 * file operations on the mount.
1653 	 */
1654 	FORCE = 1,
1655 }
1656 alias GMountUnmountFlags MountUnmountFlags;
1657 
1658 /**
1659  * Priority levels for #GNotifications.
1660  *
1661  * Since: 2.42
1662  */
1663 public enum GNotificationPriority
1664 {
1665 	/**
1666 	 * the default priority, to be used for the
1667 	 * majority of notifications (for example email messages, software updates,
1668 	 * completed download/sync operations)
1669 	 */
1670 	NORMAL = 0,
1671 	/**
1672 	 * for notifications that do not require
1673 	 * immediate attention - typically used for contextual background
1674 	 * information, such as contact birthdays or local weather
1675 	 */
1676 	LOW = 1,
1677 	/**
1678 	 * for events that require more attention,
1679 	 * usually because responses are time-sensitive (for example chat and SMS
1680 	 * messages or alarms)
1681 	 */
1682 	HIGH = 2,
1683 	/**
1684 	 * for urgent notifications, or notifications
1685 	 * that require a response in a short space of time (for example phone calls
1686 	 * or emergency warnings)
1687 	 */
1688 	URGENT = 3,
1689 }
1690 alias GNotificationPriority NotificationPriority;
1691 
1692 /**
1693  * GOutputStreamSpliceFlags determine how streams should be spliced.
1694  */
1695 public enum GOutputStreamSpliceFlags
1696 {
1697 	/**
1698 	 * Do not close either stream.
1699 	 */
1700 	NONE = 0,
1701 	/**
1702 	 * Close the source stream after
1703 	 * the splice.
1704 	 */
1705 	CLOSE_SOURCE = 1,
1706 	/**
1707 	 * Close the target stream after
1708 	 * the splice.
1709 	 */
1710 	CLOSE_TARGET = 2,
1711 }
1712 alias GOutputStreamSpliceFlags OutputStreamSpliceFlags;
1713 
1714 /**
1715  * #GPasswordSave is used to indicate the lifespan of a saved password.
1716  *
1717  * #Gvfs stores passwords in the Gnome keyring when this flag allows it
1718  * to, and later retrieves it again from there.
1719  */
1720 public enum GPasswordSave
1721 {
1722 	/**
1723 	 * never save a password.
1724 	 */
1725 	NEVER = 0,
1726 	/**
1727 	 * save a password for the session.
1728 	 */
1729 	FOR_SESSION = 1,
1730 	/**
1731 	 * save a password permanently.
1732 	 */
1733 	PERMANENTLY = 2,
1734 }
1735 alias GPasswordSave PasswordSave;
1736 
1737 /**
1738  * An error code used with %G_RESOLVER_ERROR in a #GError returned
1739  * from a #GResolver routine.
1740  *
1741  * Since: 2.22
1742  */
1743 public enum GResolverError
1744 {
1745 	/**
1746 	 * the requested name/address/service was not
1747 	 * found
1748 	 */
1749 	NOT_FOUND = 0,
1750 	/**
1751 	 * the requested information could not
1752 	 * be looked up due to a network error or similar problem
1753 	 */
1754 	TEMPORARY_FAILURE = 1,
1755 	/**
1756 	 * unknown error
1757 	 */
1758 	INTERNAL = 2,
1759 }
1760 alias GResolverError ResolverError;
1761 
1762 /**
1763  * The type of record that g_resolver_lookup_records() or
1764  * g_resolver_lookup_records_async() should retrieve. The records are returned
1765  * as lists of #GVariant tuples. Each record type has different values in
1766  * the variant tuples returned.
1767  *
1768  * %G_RESOLVER_RECORD_SRV records are returned as variants with the signature
1769  * '(qqqs)', containing a guint16 with the priority, a guint16 with the
1770  * weight, a guint16 with the port, and a string of the hostname.
1771  *
1772  * %G_RESOLVER_RECORD_MX records are returned as variants with the signature
1773  * '(qs)', representing a guint16 with the preference, and a string containing
1774  * the mail exchanger hostname.
1775  *
1776  * %G_RESOLVER_RECORD_TXT records are returned as variants with the signature
1777  * '(as)', representing an array of the strings in the text record.
1778  *
1779  * %G_RESOLVER_RECORD_SOA records are returned as variants with the signature
1780  * '(ssuuuuu)', representing a string containing the primary name server, a
1781  * string containing the administrator, the serial as a guint32, the refresh
1782  * interval as guint32, the retry interval as a guint32, the expire timeout
1783  * as a guint32, and the ttl as a guint32.
1784  *
1785  * %G_RESOLVER_RECORD_NS records are returned as variants with the signature
1786  * '(s)', representing a string of the hostname of the name server.
1787  *
1788  * Since: 2.34
1789  */
1790 public enum GResolverRecordType
1791 {
1792 	/**
1793 	 * lookup DNS SRV records for a domain
1794 	 */
1795 	SRV = 1,
1796 	/**
1797 	 * lookup DNS MX records for a domain
1798 	 */
1799 	MX = 2,
1800 	/**
1801 	 * lookup DNS TXT records for a name
1802 	 */
1803 	TXT = 3,
1804 	/**
1805 	 * lookup DNS SOA records for a zone
1806 	 */
1807 	SOA = 4,
1808 	/**
1809 	 * lookup DNS NS records for a domain
1810 	 */
1811 	NS = 5,
1812 }
1813 alias GResolverRecordType ResolverRecordType;
1814 
1815 /**
1816  * An error code used with %G_RESOURCE_ERROR in a #GError returned
1817  * from a #GResource routine.
1818  *
1819  * Since: 2.32
1820  */
1821 public enum GResourceError
1822 {
1823 	/**
1824 	 * no file was found at the requested path
1825 	 */
1826 	NOT_FOUND = 0,
1827 	/**
1828 	 * unknown error
1829 	 */
1830 	INTERNAL = 1,
1831 }
1832 alias GResourceError ResourceError;
1833 
1834 /**
1835  * GResourceFlags give information about a particular file inside a resource
1836  * bundle.
1837  *
1838  * Since: 2.32
1839  */
1840 public enum GResourceFlags
1841 {
1842 	/**
1843 	 * No flags set.
1844 	 */
1845 	NONE = 0,
1846 	/**
1847 	 * The file is compressed.
1848 	 */
1849 	COMPRESSED = 1,
1850 }
1851 alias GResourceFlags ResourceFlags;
1852 
1853 /**
1854  * GResourceLookupFlags determine how resource path lookups are handled.
1855  *
1856  * Since: 2.32
1857  */
1858 public enum GResourceLookupFlags
1859 {
1860 	/**
1861 	 * No flags set.
1862 	 */
1863 	NONE = 0,
1864 }
1865 alias GResourceLookupFlags ResourceLookupFlags;
1866 
1867 /**
1868  * Flags used when creating a binding. These flags determine in which
1869  * direction the binding works. The default is to synchronize in both
1870  * directions.
1871  */
1872 public enum GSettingsBindFlags
1873 {
1874 	/**
1875 	 * Equivalent to `G_SETTINGS_BIND_GET|G_SETTINGS_BIND_SET`
1876 	 */
1877 	DEFAULT = 0,
1878 	/**
1879 	 * Update the #GObject property when the setting changes.
1880 	 * It is an error to use this flag if the property is not writable.
1881 	 */
1882 	GET = 1,
1883 	/**
1884 	 * Update the setting when the #GObject property changes.
1885 	 * It is an error to use this flag if the property is not readable.
1886 	 */
1887 	SET = 2,
1888 	/**
1889 	 * Do not try to bind a "sensitivity" property to the writability of the setting
1890 	 */
1891 	NO_SENSITIVITY = 4,
1892 	/**
1893 	 * When set in addition to #G_SETTINGS_BIND_GET, set the #GObject property
1894 	 * value initially from the setting, but do not listen for changes of the setting
1895 	 */
1896 	GET_NO_CHANGES = 8,
1897 	/**
1898 	 * When passed to g_settings_bind(), uses a pair of mapping functions that invert
1899 	 * the boolean value when mapping between the setting and the property.  The setting and property must both
1900 	 * be booleans.  You cannot pass this flag to g_settings_bind_with_mapping().
1901 	 */
1902 	INVERT_BOOLEAN = 16,
1903 }
1904 alias GSettingsBindFlags SettingsBindFlags;
1905 
1906 /**
1907  * Describes an event occurring on a #GSocketClient. See the
1908  * #GSocketClient::event signal for more details.
1909  *
1910  * Additional values may be added to this type in the future.
1911  *
1912  * Since: 2.32
1913  */
1914 public enum GSocketClientEvent
1915 {
1916 	/**
1917 	 * The client is doing a DNS lookup.
1918 	 */
1919 	RESOLVING = 0,
1920 	/**
1921 	 * The client has completed a DNS lookup.
1922 	 */
1923 	RESOLVED = 1,
1924 	/**
1925 	 * The client is connecting to a remote
1926 	 * host (either a proxy or the destination server).
1927 	 */
1928 	CONNECTING = 2,
1929 	/**
1930 	 * The client has connected to a remote
1931 	 * host.
1932 	 */
1933 	CONNECTED = 3,
1934 	/**
1935 	 * The client is negotiating
1936 	 * with a proxy to connect to the destination server.
1937 	 */
1938 	PROXY_NEGOTIATING = 4,
1939 	/**
1940 	 * The client has negotiated
1941 	 * with the proxy server.
1942 	 */
1943 	PROXY_NEGOTIATED = 5,
1944 	/**
1945 	 * The client is performing a
1946 	 * TLS handshake.
1947 	 */
1948 	TLS_HANDSHAKING = 6,
1949 	/**
1950 	 * The client has performed a
1951 	 * TLS handshake.
1952 	 */
1953 	TLS_HANDSHAKED = 7,
1954 	/**
1955 	 * The client is done with a particular
1956 	 * #GSocketConnectable.
1957 	 */
1958 	COMPLETE = 8,
1959 }
1960 alias GSocketClientEvent SocketClientEvent;
1961 
1962 /**
1963  * The protocol family of a #GSocketAddress. (These values are
1964  * identical to the system defines %AF_INET, %AF_INET6 and %AF_UNIX,
1965  * if available.)
1966  *
1967  * Since: 2.22
1968  */
1969 public enum GSocketFamily
1970 {
1971 	/**
1972 	 * no address family
1973 	 */
1974 	INVALID = 0,
1975 	/**
1976 	 * the UNIX domain family
1977 	 */
1978 	UNIX = 1,
1979 	/**
1980 	 * the IPv4 family
1981 	 */
1982 	IPV4 = 2,
1983 	/**
1984 	 * the IPv6 family
1985 	 */
1986 	IPV6 = 10,
1987 }
1988 alias GSocketFamily SocketFamily;
1989 
1990 /**
1991  * Flags used in g_socket_receive_message() and g_socket_send_message().
1992  * The flags listed in the enum are some commonly available flags, but the
1993  * values used for them are the same as on the platform, and any other flags
1994  * are passed in/out as is. So to use a platform specific flag, just include
1995  * the right system header and pass in the flag.
1996  *
1997  * Since: 2.22
1998  */
1999 public enum GSocketMsgFlags
2000 {
2001 	/**
2002 	 * No flags.
2003 	 */
2004 	NONE = 0,
2005 	/**
2006 	 * Request to send/receive out of band data.
2007 	 */
2008 	OOB = 1,
2009 	/**
2010 	 * Read data from the socket without removing it from
2011 	 * the queue.
2012 	 */
2013 	PEEK = 2,
2014 	/**
2015 	 * Don't use a gateway to send out the packet,
2016 	 * only send to hosts on directly connected networks.
2017 	 */
2018 	DONTROUTE = 4,
2019 }
2020 alias GSocketMsgFlags SocketMsgFlags;
2021 
2022 /**
2023  * A protocol identifier is specified when creating a #GSocket, which is a
2024  * family/type specific identifier, where 0 means the default protocol for
2025  * the particular family/type.
2026  *
2027  * This enum contains a set of commonly available and used protocols. You
2028  * can also pass any other identifiers handled by the platform in order to
2029  * use protocols not listed here.
2030  *
2031  * Since: 2.22
2032  */
2033 public enum GSocketProtocol
2034 {
2035 	/**
2036 	 * The protocol type is unknown
2037 	 */
2038 	UNKNOWN = -1,
2039 	/**
2040 	 * The default protocol for the family/type
2041 	 */
2042 	DEFAULT = 0,
2043 	/**
2044 	 * TCP over IP
2045 	 */
2046 	TCP = 6,
2047 	/**
2048 	 * UDP over IP
2049 	 */
2050 	UDP = 17,
2051 	/**
2052 	 * SCTP over IP
2053 	 */
2054 	SCTP = 132,
2055 }
2056 alias GSocketProtocol SocketProtocol;
2057 
2058 /**
2059  * Flags used when creating a #GSocket. Some protocols may not implement
2060  * all the socket types.
2061  *
2062  * Since: 2.22
2063  */
2064 public enum GSocketType
2065 {
2066 	/**
2067 	 * Type unknown or wrong
2068 	 */
2069 	INVALID = 0,
2070 	/**
2071 	 * Reliable connection-based byte streams (e.g. TCP).
2072 	 */
2073 	STREAM = 1,
2074 	/**
2075 	 * Connectionless, unreliable datagram passing.
2076 	 * (e.g. UDP)
2077 	 */
2078 	DATAGRAM = 2,
2079 	/**
2080 	 * Reliable connection-based passing of datagrams
2081 	 * of fixed maximum length (e.g. SCTP).
2082 	 */
2083 	SEQPACKET = 3,
2084 }
2085 alias GSocketType SocketType;
2086 
2087 /**
2088  * Flags to define the behaviour of a #GSubprocess.
2089  *
2090  * Note that the default for stdin is to redirect from /dev/null.  For
2091  * stdout and stderr the default are for them to inherit the
2092  * corresponding descriptor from the calling process.
2093  *
2094  * Note that it is a programmer error to mix 'incompatible' flags.  For
2095  * example, you may not request both %G_SUBPROCESS_FLAGS_STDOUT_PIPE and
2096  * %G_SUBPROCESS_FLAGS_STDOUT_SILENCE.
2097  *
2098  * Since: 2.40
2099  */
2100 public enum GSubprocessFlags
2101 {
2102 	/**
2103 	 * No flags.
2104 	 */
2105 	NONE = 0,
2106 	/**
2107 	 * create a pipe for the stdin of the
2108 	 * spawned process that can be accessed with
2109 	 * g_subprocess_get_stdin_pipe().
2110 	 */
2111 	STDIN_PIPE = 1,
2112 	/**
2113 	 * stdin is inherited from the
2114 	 * calling process.
2115 	 */
2116 	STDIN_INHERIT = 2,
2117 	/**
2118 	 * create a pipe for the stdout of the
2119 	 * spawned process that can be accessed with
2120 	 * g_subprocess_get_stdout_pipe().
2121 	 */
2122 	STDOUT_PIPE = 4,
2123 	/**
2124 	 * silence the stdout of the spawned
2125 	 * process (ie: redirect to /dev/null).
2126 	 */
2127 	STDOUT_SILENCE = 8,
2128 	/**
2129 	 * create a pipe for the stderr of the
2130 	 * spawned process that can be accessed with
2131 	 * g_subprocess_get_stderr_pipe().
2132 	 */
2133 	STDERR_PIPE = 16,
2134 	/**
2135 	 * silence the stderr of the spawned
2136 	 * process (ie: redirect to /dev/null).
2137 	 */
2138 	STDERR_SILENCE = 32,
2139 	/**
2140 	 * merge the stderr of the spawned
2141 	 * process with whatever the stdout happens to be.  This is a good way
2142 	 * of directing both streams to a common log file, for example.
2143 	 */
2144 	STDERR_MERGE = 64,
2145 	/**
2146 	 * spawned processes will inherit the
2147 	 * file descriptors of their parent, unless those descriptors have
2148 	 * been explicitly marked as close-on-exec.  This flag has no effect
2149 	 * over the "standard" file descriptors (stdin, stdout, stderr).
2150 	 */
2151 	INHERIT_FDS = 128,
2152 }
2153 alias GSubprocessFlags SubprocessFlags;
2154 
2155 /**
2156  * Flags to define future #GTestDBus behaviour.
2157  *
2158  * Since: 2.34
2159  */
2160 public enum GTestDBusFlags
2161 {
2162 	/**
2163 	 * No flags.
2164 	 */
2165 	NONE = 0,
2166 }
2167 alias GTestDBusFlags TestDBusFlags;
2168 
2169 /**
2170  * The client authentication mode for a #GTlsServerConnection.
2171  *
2172  * Since: 2.28
2173  */
2174 public enum GTlsAuthenticationMode
2175 {
2176 	/**
2177 	 * client authentication not required
2178 	 */
2179 	NONE = 0,
2180 	/**
2181 	 * client authentication is requested
2182 	 */
2183 	REQUESTED = 1,
2184 	/**
2185 	 * client authentication is required
2186 	 */
2187 	REQUIRED = 2,
2188 }
2189 alias GTlsAuthenticationMode TlsAuthenticationMode;
2190 
2191 /**
2192  * A set of flags describing TLS certification validation. This can be
2193  * used to set which validation steps to perform (eg, with
2194  * g_tls_client_connection_set_validation_flags()), or to describe why
2195  * a particular certificate was rejected (eg, in
2196  * #GTlsConnection::accept-certificate).
2197  *
2198  * Since: 2.28
2199  */
2200 public enum GTlsCertificateFlags
2201 {
2202 	/**
2203 	 * The signing certificate authority is
2204 	 * not known.
2205 	 */
2206 	UNKNOWN_CA = 1,
2207 	/**
2208 	 * The certificate does not match the
2209 	 * expected identity of the site that it was retrieved from.
2210 	 */
2211 	BAD_IDENTITY = 2,
2212 	/**
2213 	 * The certificate's activation time
2214 	 * is still in the future
2215 	 */
2216 	NOT_ACTIVATED = 4,
2217 	/**
2218 	 * The certificate has expired
2219 	 */
2220 	EXPIRED = 8,
2221 	/**
2222 	 * The certificate has been revoked
2223 	 * according to the #GTlsConnection's certificate revocation list.
2224 	 */
2225 	REVOKED = 16,
2226 	/**
2227 	 * The certificate's algorithm is
2228 	 * considered insecure.
2229 	 */
2230 	INSECURE = 32,
2231 	/**
2232 	 * Some other error occurred validating
2233 	 * the certificate
2234 	 */
2235 	GENERIC_ERROR = 64,
2236 	/**
2237 	 * the combination of all of the above
2238 	 * flags
2239 	 */
2240 	VALIDATE_ALL = 127,
2241 }
2242 alias GTlsCertificateFlags TlsCertificateFlags;
2243 
2244 /**
2245  * Flags for g_tls_interaction_request_certificate(),
2246  * g_tls_interaction_request_certificate_async(), and
2247  * g_tls_interaction_invoke_request_certificate().
2248  *
2249  * Since: 2.40
2250  */
2251 public enum GTlsCertificateRequestFlags
2252 {
2253 	/**
2254 	 * No flags
2255 	 */
2256 	NONE = 0,
2257 }
2258 alias GTlsCertificateRequestFlags TlsCertificateRequestFlags;
2259 
2260 /**
2261  * Flags for g_tls_database_lookup_certificate_handle(),
2262  * g_tls_database_lookup_certificate_issuer(),
2263  * and g_tls_database_lookup_certificates_issued_by().
2264  *
2265  * Since: 2.30
2266  */
2267 public enum GTlsDatabaseLookupFlags
2268 {
2269 	/**
2270 	 * No lookup flags
2271 	 */
2272 	NONE = 0,
2273 	/**
2274 	 * Restrict lookup to certificates that have
2275 	 * a private key.
2276 	 */
2277 	KEYPAIR = 1,
2278 }
2279 alias GTlsDatabaseLookupFlags TlsDatabaseLookupFlags;
2280 
2281 /**
2282  * Flags for g_tls_database_verify_chain().
2283  *
2284  * Since: 2.30
2285  */
2286 public enum GTlsDatabaseVerifyFlags
2287 {
2288 	/**
2289 	 * No verification flags
2290 	 */
2291 	NONE = 0,
2292 }
2293 alias GTlsDatabaseVerifyFlags TlsDatabaseVerifyFlags;
2294 
2295 /**
2296  * An error code used with %G_TLS_ERROR in a #GError returned from a
2297  * TLS-related routine.
2298  *
2299  * Since: 2.28
2300  */
2301 public enum GTlsError
2302 {
2303 	/**
2304 	 * No TLS provider is available
2305 	 */
2306 	UNAVAILABLE = 0,
2307 	/**
2308 	 * Miscellaneous TLS error
2309 	 */
2310 	MISC = 1,
2311 	/**
2312 	 * A certificate could not be parsed
2313 	 */
2314 	BAD_CERTIFICATE = 2,
2315 	/**
2316 	 * The TLS handshake failed because the
2317 	 * peer does not seem to be a TLS server.
2318 	 */
2319 	NOT_TLS = 3,
2320 	/**
2321 	 * The TLS handshake failed because the
2322 	 * peer's certificate was not acceptable.
2323 	 */
2324 	HANDSHAKE = 4,
2325 	/**
2326 	 * The TLS handshake failed because
2327 	 * the server requested a client-side certificate, but none was
2328 	 * provided. See g_tls_connection_set_certificate().
2329 	 */
2330 	CERTIFICATE_REQUIRED = 5,
2331 	/**
2332 	 * The TLS connection was closed without proper
2333 	 * notice, which may indicate an attack. See
2334 	 * g_tls_connection_set_require_close_notify().
2335 	 */
2336 	EOF = 6,
2337 }
2338 alias GTlsError TlsError;
2339 
2340 /**
2341  * #GTlsInteractionResult is returned by various functions in #GTlsInteraction
2342  * when finishing an interaction request.
2343  *
2344  * Since: 2.30
2345  */
2346 public enum GTlsInteractionResult
2347 {
2348 	/**
2349 	 * The interaction was unhandled (i.e. not
2350 	 * implemented).
2351 	 */
2352 	UNHANDLED = 0,
2353 	/**
2354 	 * The interaction completed, and resulting data
2355 	 * is available.
2356 	 */
2357 	HANDLED = 1,
2358 	/**
2359 	 * The interaction has failed, or was cancelled.
2360 	 * and the operation should be aborted.
2361 	 */
2362 	FAILED = 2,
2363 }
2364 alias GTlsInteractionResult TlsInteractionResult;
2365 
2366 /**
2367  * Various flags for the password.
2368  *
2369  * Since: 2.30
2370  */
2371 public enum GTlsPasswordFlags
2372 {
2373 	/**
2374 	 * No flags
2375 	 */
2376 	NONE = 0,
2377 	/**
2378 	 * The password was wrong, and the user should retry.
2379 	 */
2380 	RETRY = 2,
2381 	/**
2382 	 * Hint to the user that the password has been
2383 	 * wrong many times, and the user may not have many chances left.
2384 	 */
2385 	MANY_TRIES = 4,
2386 	/**
2387 	 * Hint to the user that this is the last try to get
2388 	 * this password right.
2389 	 */
2390 	FINAL_TRY = 8,
2391 }
2392 alias GTlsPasswordFlags TlsPasswordFlags;
2393 
2394 /**
2395  * When to allow rehandshaking. See
2396  * g_tls_connection_set_rehandshake_mode().
2397  *
2398  * Since: 2.28
2399  */
2400 public enum GTlsRehandshakeMode
2401 {
2402 	/**
2403 	 * Never allow rehandshaking
2404 	 */
2405 	NEVER = 0,
2406 	/**
2407 	 * Allow safe rehandshaking only
2408 	 */
2409 	SAFELY = 1,
2410 	/**
2411 	 * Allow unsafe rehandshaking
2412 	 */
2413 	UNSAFELY = 2,
2414 }
2415 alias GTlsRehandshakeMode TlsRehandshakeMode;
2416 
2417 /**
2418  * The type of name used by a #GUnixSocketAddress.
2419  * %G_UNIX_SOCKET_ADDRESS_PATH indicates a traditional unix domain
2420  * socket bound to a filesystem path. %G_UNIX_SOCKET_ADDRESS_ANONYMOUS
2421  * indicates a socket not bound to any name (eg, a client-side socket,
2422  * or a socket created with socketpair()).
2423  *
2424  * For abstract sockets, there are two incompatible ways of naming
2425  * them; the man pages suggest using the entire `struct sockaddr_un`
2426  * as the name, padding the unused parts of the %sun_path field with
2427  * zeroes; this corresponds to %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED.
2428  * However, many programs instead just use a portion of %sun_path, and
2429  * pass an appropriate smaller length to bind() or connect(). This is
2430  * %G_UNIX_SOCKET_ADDRESS_ABSTRACT.
2431  *
2432  * Since: 2.26
2433  */
2434 public enum GUnixSocketAddressType
2435 {
2436 	/**
2437 	 * invalid
2438 	 */
2439 	INVALID = 0,
2440 	/**
2441 	 * anonymous
2442 	 */
2443 	ANONYMOUS = 1,
2444 	/**
2445 	 * a filesystem path
2446 	 */
2447 	PATH = 2,
2448 	/**
2449 	 * an abstract name
2450 	 */
2451 	ABSTRACT = 3,
2452 	/**
2453 	 * an abstract name, 0-padded
2454 	 * to the full length of a unix socket name
2455 	 */
2456 	ABSTRACT_PADDED = 4,
2457 }
2458 alias GUnixSocketAddressType UnixSocketAddressType;
2459 
2460 /**
2461  * Used to select the type of data format to use for #GZlibDecompressor
2462  * and #GZlibCompressor.
2463  *
2464  * Since: 2.24
2465  */
2466 public enum GZlibCompressorFormat
2467 {
2468 	/**
2469 	 * deflate compression with zlib header
2470 	 */
2471 	ZLIB = 0,
2472 	/**
2473 	 * gzip file format
2474 	 */
2475 	GZIP = 1,
2476 	/**
2477 	 * deflate compression with no header
2478 	 */
2479 	RAW = 2,
2480 }
2481 alias GZlibCompressorFormat ZlibCompressorFormat;
2482 
2483 struct GAction;
2484 
2485 /**
2486  * This struct defines a single action.  It is for use with
2487  * g_action_map_add_action_entries().
2488  *
2489  * The order of the items in the structure are intended to reflect
2490  * frequency of use.  It is permissible to use an incomplete initialiser
2491  * in order to leave some of the later values as %NULL.  All values
2492  * after @name are optional.  Additional optional fields may be added in
2493  * the future.
2494  *
2495  * See g_action_map_add_action_entries() for an example.
2496  */
2497 struct GActionEntry
2498 {
2499 	/**
2500 	 * the name of the action
2501 	 */
2502 	const(char)* name;
2503 	extern(C) void function(GSimpleAction* action, GVariant* parameter, void* userData) activate;
2504 	/**
2505 	 * the type of the parameter that must be passed to the
2506 	 * activate function for this action, given as a single
2507 	 * GVariant type string (or %NULL for no parameter)
2508 	 */
2509 	const(char)* parameterType;
2510 	/**
2511 	 * the initial state for this action, given in
2512 	 * [GVariant text format][gvariant-text].  The state is parsed
2513 	 * with no extra type information, so type tags must be added to
2514 	 * the string if they are necessary.  Stateless actions should
2515 	 * give %NULL here.
2516 	 */
2517 	const(char)* state;
2518 	extern(C) void function(GSimpleAction* action, GVariant* value, void* userData) changeState;
2519 	size_t[3] padding;
2520 }
2521 
2522 struct GActionGroup;
2523 
2524 /**
2525  * The virtual function table for #GActionGroup.
2526  *
2527  * Since: 2.28
2528  */
2529 struct GActionGroupInterface
2530 {
2531 	GTypeInterface gIface;
2532 	/**
2533 	 *
2534 	 * Params:
2535 	 *     actionGroup = a #GActionGroup
2536 	 *     actionName = the name of the action to check for
2537 	 * Return: whether the named action exists
2538 	 */
2539 	extern(C) int function(GActionGroup* actionGroup, const(char)* actionName) hasAction;
2540 	/**
2541 	 *
2542 	 * Params:
2543 	 *     actionGroup = a #GActionGroup
2544 	 * Return: a %NULL-terminated array of the names of the
2545 	 *     actions in the groupb
2546 	 */
2547 	extern(C) char** function(GActionGroup* actionGroup) listActions;
2548 	/**
2549 	 *
2550 	 * Params:
2551 	 *     actionGroup = a #GActionGroup
2552 	 *     actionName = the name of the action to query
2553 	 * Return: whether or not the action is currently enabled
2554 	 */
2555 	extern(C) int function(GActionGroup* actionGroup, const(char)* actionName) getActionEnabled;
2556 	/**
2557 	 *
2558 	 * Params:
2559 	 *     actionGroup = a #GActionGroup
2560 	 *     actionName = the name of the action to query
2561 	 * Return: the parameter type
2562 	 */
2563 	extern(C) GVariantType* function(GActionGroup* actionGroup, const(char)* actionName) getActionParameterType;
2564 	/**
2565 	 *
2566 	 * Params:
2567 	 *     actionGroup = a #GActionGroup
2568 	 *     actionName = the name of the action to query
2569 	 * Return: the state type, if the action
2570 	 *     is stateful
2571 	 */
2572 	extern(C) GVariantType* function(GActionGroup* actionGroup, const(char)* actionName) getActionStateType;
2573 	/**
2574 	 *
2575 	 * Params:
2576 	 *     actionGroup = a #GActionGroup
2577 	 *     actionName = the name of the action to query
2578 	 * Return: the state range hint
2579 	 */
2580 	extern(C) GVariant* function(GActionGroup* actionGroup, const(char)* actionName) getActionStateHint;
2581 	/**
2582 	 *
2583 	 * Params:
2584 	 *     actionGroup = a #GActionGroup
2585 	 *     actionName = the name of the action to query
2586 	 * Return: the current state of the action
2587 	 */
2588 	extern(C) GVariant* function(GActionGroup* actionGroup, const(char)* actionName) getActionState;
2589 	extern(C) void function(GActionGroup* actionGroup, const(char)* actionName, GVariant* value) changeActionState;
2590 	extern(C) void function(GActionGroup* actionGroup, const(char)* actionName, GVariant* parameter) activateAction;
2591 	extern(C) void function(GActionGroup* actionGroup, const(char)* actionName) actionAdded;
2592 	extern(C) void function(GActionGroup* actionGroup, const(char)* actionName) actionRemoved;
2593 	extern(C) void function(GActionGroup* actionGroup, const(char)* actionName, int enabled) actionEnabledChanged;
2594 	extern(C) void function(GActionGroup* actionGroup, const(char)* actionName, GVariant* state) actionStateChanged;
2595 	/**
2596 	 *
2597 	 * Params:
2598 	 *     actionGroup = a #GActionGroup
2599 	 *     actionName = the name of an action in the group
2600 	 *     enabled = if the action is presently enabled
2601 	 *     parameterType = the parameter type, or %NULL if none needed
2602 	 *     stateType = the state type, or %NULL if stateless
2603 	 *     stateHint = the state hint, or %NULL if none
2604 	 *     state = the current state, or %NULL if stateless
2605 	 * Return: %TRUE if the action exists, else %FALSE
2606 	 */
2607 	extern(C) int function(GActionGroup* actionGroup, const(char)* actionName, int* enabled, GVariantType** parameterType, GVariantType** stateType, GVariant** stateHint, GVariant** state) queryAction;
2608 }
2609 
2610 /**
2611  * The virtual function table for #GAction.
2612  *
2613  * Since: 2.28
2614  */
2615 struct GActionInterface
2616 {
2617 	GTypeInterface gIface;
2618 	/**
2619 	 *
2620 	 * Params:
2621 	 *     action = a #GAction
2622 	 * Return: the name of the action
2623 	 */
2624 	extern(C) const(char)* function(GAction* action) getName;
2625 	/**
2626 	 *
2627 	 * Params:
2628 	 *     action = a #GAction
2629 	 * Return: the parameter type
2630 	 */
2631 	extern(C) GVariantType* function(GAction* action) getParameterType;
2632 	/**
2633 	 *
2634 	 * Params:
2635 	 *     action = a #GAction
2636 	 * Return: the state type, if the action is stateful
2637 	 */
2638 	extern(C) GVariantType* function(GAction* action) getStateType;
2639 	/**
2640 	 *
2641 	 * Params:
2642 	 *     action = a #GAction
2643 	 * Return: the state range hint
2644 	 */
2645 	extern(C) GVariant* function(GAction* action) getStateHint;
2646 	/**
2647 	 *
2648 	 * Params:
2649 	 *     action = a #GAction
2650 	 * Return: whether the action is enabled
2651 	 */
2652 	extern(C) int function(GAction* action) getEnabled;
2653 	/**
2654 	 *
2655 	 * Params:
2656 	 *     action = a #GAction
2657 	 * Return: the current state of the action
2658 	 */
2659 	extern(C) GVariant* function(GAction* action) getState;
2660 	extern(C) void function(GAction* action, GVariant* value) changeState;
2661 	extern(C) void function(GAction* action, GVariant* parameter) activate;
2662 }
2663 
2664 struct GActionMap;
2665 
2666 /**
2667  * The virtual function table for #GActionMap.
2668  *
2669  * Since: 2.32
2670  */
2671 struct GActionMapInterface
2672 {
2673 	GTypeInterface gIface;
2674 	/**
2675 	 *
2676 	 * Params:
2677 	 *     actionMap = a #GActionMap
2678 	 *     actionName = the name of an action
2679 	 * Return: a #GAction, or %NULL
2680 	 */
2681 	extern(C) GAction* function(GActionMap* actionMap, const(char)* actionName) lookupAction;
2682 	extern(C) void function(GActionMap* actionMap, GAction* action) addAction;
2683 	extern(C) void function(GActionMap* actionMap, const(char)* actionName) removeAction;
2684 }
2685 
2686 struct GAppInfo;
2687 
2688 /**
2689  * Application Information interface, for operating system portability.
2690  */
2691 struct GAppInfoIface
2692 {
2693 	/**
2694 	 * The parent interface.
2695 	 */
2696 	GTypeInterface gIface;
2697 	/**
2698 	 *
2699 	 * Params:
2700 	 *     appinfo = a #GAppInfo.
2701 	 * Return: a duplicate of @appinfo.
2702 	 */
2703 	extern(C) GAppInfo* function(GAppInfo* appinfo) dup;
2704 	/**
2705 	 *
2706 	 * Params:
2707 	 *     appinfo1 = the first #GAppInfo.
2708 	 *     appinfo2 = the second #GAppInfo.
2709 	 * Return: %TRUE if @appinfo1 is equal to @appinfo2. %FALSE otherwise.
2710 	 */
2711 	extern(C) int function(GAppInfo* appinfo1, GAppInfo* appinfo2) equal;
2712 	/**
2713 	 *
2714 	 * Params:
2715 	 *     appinfo = a #GAppInfo.
2716 	 * Return: a string containing the application's ID.
2717 	 */
2718 	extern(C) const(char)* function(GAppInfo* appinfo) getId;
2719 	/**
2720 	 *
2721 	 * Params:
2722 	 *     appinfo = a #GAppInfo.
2723 	 * Return: the name of the application for @appinfo.
2724 	 */
2725 	extern(C) const(char)* function(GAppInfo* appinfo) getName;
2726 	/**
2727 	 *
2728 	 * Params:
2729 	 *     appinfo = a #GAppInfo.
2730 	 * Return: a string containing a description of the
2731 	 *     application @appinfo, or %NULL if none.
2732 	 */
2733 	extern(C) const(char)* function(GAppInfo* appinfo) getDescription;
2734 	/**
2735 	 *
2736 	 * Params:
2737 	 *     appinfo = a #GAppInfo
2738 	 * Return: a string containing the @appinfo's application
2739 	 *     binaries name
2740 	 */
2741 	extern(C) const(char)* function(GAppInfo* appinfo) getExecutable;
2742 	/**
2743 	 *
2744 	 * Params:
2745 	 *     appinfo = a #GAppInfo.
2746 	 * Return: the default #GIcon for @appinfo or %NULL
2747 	 *     if there is no default icon.
2748 	 */
2749 	extern(C) GIcon* function(GAppInfo* appinfo) getIcon;
2750 	/**
2751 	 *
2752 	 * Params:
2753 	 *     appinfo = a #GAppInfo
2754 	 *     files = a #GList of #GFile objects
2755 	 *     launchContext = a #GAppLaunchContext or %NULL
2756 	 * Return: %TRUE on successful launch, %FALSE otherwise.
2757 	 *
2758 	 * Throws: GException on failure.
2759 	 */
2760 	extern(C) int function(GAppInfo* appinfo, GList* files, GAppLaunchContext* launchContext, GError** err) launch;
2761 	/**
2762 	 *
2763 	 * Params:
2764 	 *     appinfo = a #GAppInfo.
2765 	 * Return: %TRUE if the @appinfo supports URIs.
2766 	 */
2767 	extern(C) int function(GAppInfo* appinfo) supportsUris;
2768 	/**
2769 	 *
2770 	 * Params:
2771 	 *     appinfo = a #GAppInfo.
2772 	 * Return: %TRUE if the @appinfo supports files.
2773 	 */
2774 	extern(C) int function(GAppInfo* appinfo) supportsFiles;
2775 	/**
2776 	 *
2777 	 * Params:
2778 	 *     appinfo = a #GAppInfo
2779 	 *     uris = a #GList containing URIs to launch.
2780 	 *     launchContext = a #GAppLaunchContext or %NULL
2781 	 * Return: %TRUE on successful launch, %FALSE otherwise.
2782 	 *
2783 	 * Throws: GException on failure.
2784 	 */
2785 	extern(C) int function(GAppInfo* appinfo, GList* uris, GAppLaunchContext* launchContext, GError** err) launchUris;
2786 	/**
2787 	 *
2788 	 * Params:
2789 	 *     appinfo = a #GAppInfo.
2790 	 * Return: %TRUE if the @appinfo should be shown, %FALSE otherwise.
2791 	 */
2792 	extern(C) int function(GAppInfo* appinfo) shouldShow;
2793 	/**
2794 	 *
2795 	 * Params:
2796 	 *     appinfo = a #GAppInfo.
2797 	 *     contentType = the content type.
2798 	 * Return: %TRUE on success, %FALSE on error.
2799 	 *
2800 	 * Throws: GException on failure.
2801 	 */
2802 	extern(C) int function(GAppInfo* appinfo, const(char)* contentType, GError** err) setAsDefaultForType;
2803 	/**
2804 	 *
2805 	 * Params:
2806 	 *     appinfo = a #GAppInfo.
2807 	 *     extension = a string containing the file extension (without the dot).
2808 	 * Return: %TRUE on success, %FALSE on error.
2809 	 *
2810 	 * Throws: GException on failure.
2811 	 */
2812 	extern(C) int function(GAppInfo* appinfo, const(char)* extension, GError** err) setAsDefaultForExtension;
2813 	/**
2814 	 *
2815 	 * Params:
2816 	 *     appinfo = a #GAppInfo.
2817 	 *     contentType = a string.
2818 	 * Return: %TRUE on success, %FALSE on error.
2819 	 *
2820 	 * Throws: GException on failure.
2821 	 */
2822 	extern(C) int function(GAppInfo* appinfo, const(char)* contentType, GError** err) addSupportsType;
2823 	/**
2824 	 *
2825 	 * Params:
2826 	 *     appinfo = a #GAppInfo.
2827 	 * Return: %TRUE if it is possible to remove supported
2828 	 *     content types from a given @appinfo, %FALSE if not.
2829 	 */
2830 	extern(C) int function(GAppInfo* appinfo) canRemoveSupportsType;
2831 	/**
2832 	 *
2833 	 * Params:
2834 	 *     appinfo = a #GAppInfo.
2835 	 *     contentType = a string.
2836 	 * Return: %TRUE on success, %FALSE on error.
2837 	 *
2838 	 * Throws: GException on failure.
2839 	 */
2840 	extern(C) int function(GAppInfo* appinfo, const(char)* contentType, GError** err) removeSupportsType;
2841 	/**
2842 	 *
2843 	 * Params:
2844 	 *     appinfo = a #GAppInfo
2845 	 * Return: %TRUE if @appinfo can be deleted
2846 	 */
2847 	extern(C) int function(GAppInfo* appinfo) canDelete;
2848 	/**
2849 	 *
2850 	 * Params:
2851 	 *     appinfo = a #GAppInfo
2852 	 * Return: %TRUE if @appinfo has been deleted
2853 	 */
2854 	extern(C) int function(GAppInfo* appinfo) doDelete;
2855 	/**
2856 	 *
2857 	 * Params:
2858 	 *     appinfo = a #GAppInfo
2859 	 * Return: a string containing the @appinfo's commandline,
2860 	 *     or %NULL if this information is not available
2861 	 */
2862 	extern(C) const(char)* function(GAppInfo* appinfo) getCommandline;
2863 	/**
2864 	 *
2865 	 * Params:
2866 	 *     appinfo = a #GAppInfo.
2867 	 * Return: the display name of the application for @appinfo, or the name if
2868 	 *     no display name is available.
2869 	 */
2870 	extern(C) const(char)* function(GAppInfo* appinfo) getDisplayName;
2871 	/**
2872 	 *
2873 	 * Params:
2874 	 *     appinfo = a #GAppInfo.
2875 	 *     contentType = the content type.
2876 	 * Return: %TRUE on success, %FALSE on error.
2877 	 *
2878 	 * Throws: GException on failure.
2879 	 */
2880 	extern(C) int function(GAppInfo* appinfo, const(char)* contentType, GError** err) setAsLastUsedForType;
2881 	/**
2882 	 *
2883 	 * Params:
2884 	 *     appinfo = a #GAppInfo that can handle files
2885 	 * Return: a list of content types.
2886 	 */
2887 	extern(C) char** function(GAppInfo* appinfo) getSupportedTypes;
2888 }
2889 
2890 struct GAppInfoMonitor;
2891 
2892 struct GAppLaunchContext
2893 {
2894 	GObject parentInstance;
2895 	GAppLaunchContextPrivate* priv;
2896 }
2897 
2898 struct GAppLaunchContextClass
2899 {
2900 	GObjectClass parentClass;
2901 	/**
2902 	 *
2903 	 * Params:
2904 	 *     context = a #GAppLaunchContext
2905 	 *     info = a #GAppInfo
2906 	 *     files = a #GList of #GFile objects
2907 	 * Return: a display string for the display.
2908 	 */
2909 	extern(C) char* function(GAppLaunchContext* context, GAppInfo* info, GList* files) getDisplay;
2910 	/**
2911 	 *
2912 	 * Params:
2913 	 *     context = a #GAppLaunchContext
2914 	 *     info = a #GAppInfo
2915 	 *     files = a #GList of of #GFile objects
2916 	 * Return: a startup notification ID for the application, or %NULL if
2917 	 *     not supported.
2918 	 */
2919 	extern(C) char* function(GAppLaunchContext* context, GAppInfo* info, GList* files) getStartupNotifyId;
2920 	extern(C) void function(GAppLaunchContext* context, const(char)* startupNotifyId) launchFailed;
2921 	extern(C) void function(GAppLaunchContext* context, GAppInfo* info, GVariant* platformData) launched;
2922 	extern(C) void function() GReserved1;
2923 	extern(C) void function() GReserved2;
2924 	extern(C) void function() GReserved3;
2925 	extern(C) void function() GReserved4;
2926 }
2927 
2928 struct GAppLaunchContextPrivate;
2929 
2930 struct GApplication
2931 {
2932 	GObject parentInstance;
2933 	GApplicationPrivate* priv;
2934 }
2935 
2936 /**
2937  * Virtual function table for #GApplication.
2938  *
2939  * Since: 2.28
2940  */
2941 struct GApplicationClass
2942 {
2943 	GObjectClass parentClass;
2944 	extern(C) void function(GApplication* application) startup;
2945 	extern(C) void function(GApplication* application) activate;
2946 	extern(C) void function(GApplication* application, GFile** files, int nFiles, const(char)* hint) open;
2947 	extern(C) int function(GApplication* application, GApplicationCommandLine* commandLine) commandLine;
2948 	/**
2949 	 *
2950 	 * Params:
2951 	 *     application = a #GApplication
2952 	 *     arguments = array of command line arguments
2953 	 *     exitStatus = exit status to fill after processing the command line.
2954 	 * Return: %TRUE if the commandline has been completely handled
2955 	 */
2956 	extern(C) int function(GApplication* application, char*** arguments, int* exitStatus) localCommandLine;
2957 	extern(C) void function(GApplication* application, GVariant* platformData) beforeEmit;
2958 	extern(C) void function(GApplication* application, GVariant* platformData) afterEmit;
2959 	extern(C) void function(GApplication* application, GVariantBuilder* builder) addPlatformData;
2960 	extern(C) void function(GApplication* application) quitMainloop;
2961 	extern(C) void function(GApplication* application) runMainloop;
2962 	extern(C) void function(GApplication* application) shutdown;
2963 	extern(C) int function(GApplication* application, GDBusConnection* connection, const(char)* objectPath, GError** err) dbusRegister;
2964 	extern(C) void function(GApplication* application, GDBusConnection* connection, const(char)* objectPath) dbusUnregister;
2965 	extern(C) int function(GApplication* application, GVariantDict* options) handleLocalOptions;
2966 	void*[8] padding;
2967 }
2968 
2969 struct GApplicationCommandLine
2970 {
2971 	GObject parentInstance;
2972 	GApplicationCommandLinePrivate* priv;
2973 }
2974 
2975 /**
2976  * The #GApplicationCommandLineClass-struct
2977  * contains private data only.
2978  *
2979  * Since: 2.28
2980  */
2981 struct GApplicationCommandLineClass
2982 {
2983 	GObjectClass parentClass;
2984 	extern(C) void function(GApplicationCommandLine* cmdline, const(char)* message) printLiteral;
2985 	extern(C) void function(GApplicationCommandLine* cmdline, const(char)* message) printerrLiteral;
2986 	/**
2987 	 *
2988 	 * Params:
2989 	 *     cmdline = a #GApplicationCommandLine
2990 	 * Return: a #GInputStream for stdin
2991 	 */
2992 	extern(C) GInputStream* function(GApplicationCommandLine* cmdline) getStdin;
2993 	void*[11] padding;
2994 }
2995 
2996 struct GApplicationCommandLinePrivate;
2997 
2998 struct GApplicationPrivate;
2999 
3000 struct GAsyncInitable;
3001 
3002 /**
3003  * Provides an interface for asynchronous initializing object such that
3004  * initialization may fail.
3005  *
3006  * Since: 2.22
3007  */
3008 struct GAsyncInitableIface
3009 {
3010 	/**
3011 	 * The parent interface.
3012 	 */
3013 	GTypeInterface gIface;
3014 	extern(C) void function(GAsyncInitable* initable, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) initAsync;
3015 	/**
3016 	 *
3017 	 * Params:
3018 	 *     initable = a #GAsyncInitable.
3019 	 *     res = a #GAsyncResult.
3020 	 * Return: %TRUE if successful. If an error has occurred, this function
3021 	 *     will return %FALSE and set @error appropriately if present.
3022 	 *
3023 	 * Throws: GException on failure.
3024 	 */
3025 	extern(C) int function(GAsyncInitable* initable, GAsyncResult* res, GError** err) initFinish;
3026 }
3027 
3028 struct GAsyncResult;
3029 
3030 /**
3031  * Interface definition for #GAsyncResult.
3032  */
3033 struct GAsyncResultIface
3034 {
3035 	/**
3036 	 * The parent interface.
3037 	 */
3038 	GTypeInterface gIface;
3039 	/**
3040 	 *
3041 	 * Params:
3042 	 *     res = a #GAsyncResult.
3043 	 * Return: the user data for @res.
3044 	 */
3045 	extern(C) void* function(GAsyncResult* res) getUserData;
3046 	/**
3047 	 *
3048 	 * Params:
3049 	 *     res = a #GAsyncResult
3050 	 * Return: a new reference to the source object for the @res,
3051 	 *     or %NULL if there is none.
3052 	 */
3053 	extern(C) GObject* function(GAsyncResult* res) getSourceObject;
3054 	/**
3055 	 *
3056 	 * Params:
3057 	 *     res = a #GAsyncResult
3058 	 *     sourceTag = an application-defined tag
3059 	 * Return: %TRUE if @res has the indicated @source_tag, %FALSE if
3060 	 *     not.
3061 	 */
3062 	extern(C) int function(GAsyncResult* res, void* sourceTag) isTagged;
3063 }
3064 
3065 struct GBufferedInputStream
3066 {
3067 	GFilterInputStream parentInstance;
3068 	GBufferedInputStreamPrivate* priv;
3069 }
3070 
3071 struct GBufferedInputStreamClass
3072 {
3073 	GFilterInputStreamClass parentClass;
3074 	/**
3075 	 *
3076 	 * Params:
3077 	 *     stream = a #GBufferedInputStream
3078 	 *     count = the number of bytes that will be read from the stream
3079 	 *     cancellable = optional #GCancellable object, %NULL to ignore
3080 	 * Return: the number of bytes read into @stream's buffer, up to @count,
3081 	 *     or -1 on error.
3082 	 *
3083 	 * Throws: GException on failure.
3084 	 */
3085 	extern(C) ptrdiff_t function(GBufferedInputStream* stream, ptrdiff_t count, GCancellable* cancellable, GError** err) fill;
3086 	extern(C) void function(GBufferedInputStream* stream, ptrdiff_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) fillAsync;
3087 	/**
3088 	 *
3089 	 * Params:
3090 	 *     stream = a #GBufferedInputStream
3091 	 *     result = a #GAsyncResult
3092 	 * Return: a #gssize of the read stream, or %-1 on an error.
3093 	 *
3094 	 * Throws: GException on failure.
3095 	 */
3096 	extern(C) ptrdiff_t function(GBufferedInputStream* stream, GAsyncResult* result, GError** err) fillFinish;
3097 	extern(C) void function() GReserved1;
3098 	extern(C) void function() GReserved2;
3099 	extern(C) void function() GReserved3;
3100 	extern(C) void function() GReserved4;
3101 	extern(C) void function() GReserved5;
3102 }
3103 
3104 struct GBufferedInputStreamPrivate;
3105 
3106 struct GBufferedOutputStream
3107 {
3108 	GFilterOutputStream parentInstance;
3109 	GBufferedOutputStreamPrivate* priv;
3110 }
3111 
3112 struct GBufferedOutputStreamClass
3113 {
3114 	GFilterOutputStreamClass parentClass;
3115 	extern(C) void function() GReserved1;
3116 	extern(C) void function() GReserved2;
3117 }
3118 
3119 struct GBufferedOutputStreamPrivate;
3120 
3121 struct GBytesIcon;
3122 
3123 struct GCancellable
3124 {
3125 	GObject parentInstance;
3126 	GCancellablePrivate* priv;
3127 }
3128 
3129 struct GCancellableClass
3130 {
3131 	GObjectClass parentClass;
3132 	extern(C) void function(GCancellable* cancellable) cancelled;
3133 	extern(C) void function() GReserved1;
3134 	extern(C) void function() GReserved2;
3135 	extern(C) void function() GReserved3;
3136 	extern(C) void function() GReserved4;
3137 	extern(C) void function() GReserved5;
3138 }
3139 
3140 struct GCancellablePrivate;
3141 
3142 struct GCharsetConverter;
3143 
3144 struct GCharsetConverterClass
3145 {
3146 	GObjectClass parentClass;
3147 }
3148 
3149 struct GConverter;
3150 
3151 /**
3152  * Provides an interface for converting data from one type
3153  * to another type. The conversion can be stateful
3154  * and may fail at any place.
3155  *
3156  * Since: 2.24
3157  */
3158 struct GConverterIface
3159 {
3160 	/**
3161 	 * The parent interface.
3162 	 */
3163 	GTypeInterface gIface;
3164 	/**
3165 	 *
3166 	 * Params:
3167 	 *     converter = a #GConverter.
3168 	 *     inbuf = the buffer
3169 	 *         containing the data to convert.
3170 	 *     inbufSize = the number of bytes in @inbuf
3171 	 *     outbuf = a buffer to write converted data in.
3172 	 *     outbufSize = the number of bytes in @outbuf, must be at least one
3173 	 *     flags = a #GConverterFlags controlling the conversion details
3174 	 *     bytesRead = will be set to the number of bytes read from @inbuf on success
3175 	 *     bytesWritten = will be set to the number of bytes written to @outbuf on success
3176 	 * Return: a #GConverterResult, %G_CONVERTER_ERROR on error.
3177 	 *
3178 	 * Throws: GException on failure.
3179 	 */
3180 	extern(C) GConverterResult function(GConverter* converter, void* inbuf, size_t inbufSize, void* outbuf, size_t outbufSize, GConverterFlags flags, size_t* bytesRead, size_t* bytesWritten, GError** err) convert;
3181 	extern(C) void function(GConverter* converter) reset;
3182 }
3183 
3184 struct GConverterInputStream
3185 {
3186 	GFilterInputStream parentInstance;
3187 	GConverterInputStreamPrivate* priv;
3188 }
3189 
3190 struct GConverterInputStreamClass
3191 {
3192 	GFilterInputStreamClass parentClass;
3193 	extern(C) void function() GReserved1;
3194 	extern(C) void function() GReserved2;
3195 	extern(C) void function() GReserved3;
3196 	extern(C) void function() GReserved4;
3197 	extern(C) void function() GReserved5;
3198 }
3199 
3200 struct GConverterInputStreamPrivate;
3201 
3202 struct GConverterOutputStream
3203 {
3204 	GFilterOutputStream parentInstance;
3205 	GConverterOutputStreamPrivate* priv;
3206 }
3207 
3208 struct GConverterOutputStreamClass
3209 {
3210 	GFilterOutputStreamClass parentClass;
3211 	extern(C) void function() GReserved1;
3212 	extern(C) void function() GReserved2;
3213 	extern(C) void function() GReserved3;
3214 	extern(C) void function() GReserved4;
3215 	extern(C) void function() GReserved5;
3216 }
3217 
3218 struct GConverterOutputStreamPrivate;
3219 
3220 struct GCredentials;
3221 
3222 /**
3223  * Class structure for #GCredentials.
3224  *
3225  * Since: 2.26
3226  */
3227 struct GCredentialsClass;
3228 
3229 struct GDBusActionGroup;
3230 
3231 struct GDBusAnnotationInfo
3232 {
3233 	/**
3234 	 * The reference count or -1 if statically allocated.
3235 	 */
3236 	int refCount;
3237 	/**
3238 	 * The name of the annotation, e.g. "org.freedesktop.DBus.Deprecated".
3239 	 */
3240 	char* key;
3241 	/**
3242 	 * The value of the annotation.
3243 	 */
3244 	char* value;
3245 	/**
3246 	 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
3247 	 */
3248 	GDBusAnnotationInfo** annotations;
3249 }
3250 
3251 struct GDBusArgInfo
3252 {
3253 	/**
3254 	 * The reference count or -1 if statically allocated.
3255 	 */
3256 	int refCount;
3257 	/**
3258 	 * Name of the argument, e.g. @unix_user_id.
3259 	 */
3260 	char* name;
3261 	/**
3262 	 * D-Bus signature of the argument (a single complete type).
3263 	 */
3264 	char* signature;
3265 	/**
3266 	 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
3267 	 */
3268 	GDBusAnnotationInfo** annotations;
3269 }
3270 
3271 struct GDBusAuthObserver;
3272 
3273 struct GDBusConnection;
3274 
3275 /**
3276  * Struct used in g_dbus_error_register_error_domain().
3277  *
3278  * Since: 2.26
3279  */
3280 struct GDBusErrorEntry
3281 {
3282 	/**
3283 	 * An error code.
3284 	 */
3285 	int errorCode;
3286 	/**
3287 	 * The D-Bus error name to associate with @error_code.
3288 	 */
3289 	const(char)* dbusErrorName;
3290 }
3291 
3292 struct GDBusInterface;
3293 
3294 /**
3295  * Base type for D-Bus interfaces.
3296  *
3297  * Since: 2.30
3298  */
3299 struct GDBusInterfaceIface
3300 {
3301 	/**
3302 	 * The parent interface.
3303 	 */
3304 	GTypeInterface parentIface;
3305 	/**
3306 	 *
3307 	 * Params:
3308 	 *     iface = An exported D-Bus interface.
3309 	 * Return: A #GDBusInterfaceInfo. Do not free.
3310 	 */
3311 	extern(C) GDBusInterfaceInfo* function(GDBusInterface* iface) getInfo;
3312 	/**
3313 	 *
3314 	 * Params:
3315 	 *     iface = An exported D-Bus interface
3316 	 * Return: A #GDBusObject or %NULL. The returned
3317 	 *     reference belongs to @interface_ and should not be freed.
3318 	 */
3319 	extern(C) GDBusObject* function(GDBusInterface* iface) getObject;
3320 	extern(C) void function(GDBusInterface* iface, GDBusObject* object) setObject;
3321 	/**
3322 	 *
3323 	 * Params:
3324 	 *     iface = An exported D-Bus interface.
3325 	 * Return: A #GDBusObject or %NULL. The returned
3326 	 *     reference should be freed with g_object_unref().
3327 	 */
3328 	extern(C) GDBusObject* function(GDBusInterface* iface) dupObject;
3329 }
3330 
3331 struct GDBusInterfaceInfo
3332 {
3333 	/**
3334 	 * The reference count or -1 if statically allocated.
3335 	 */
3336 	int refCount;
3337 	/**
3338 	 * The name of the D-Bus interface, e.g. "org.freedesktop.DBus.Properties".
3339 	 */
3340 	char* name;
3341 	/**
3342 	 * A pointer to a %NULL-terminated array of pointers to #GDBusMethodInfo structures or %NULL if there are no methods.
3343 	 */
3344 	GDBusMethodInfo** methods;
3345 	/**
3346 	 * A pointer to a %NULL-terminated array of pointers to #GDBusSignalInfo structures or %NULL if there are no signals.
3347 	 */
3348 	GDBusSignalInfo** signals;
3349 	/**
3350 	 * A pointer to a %NULL-terminated array of pointers to #GDBusPropertyInfo structures or %NULL if there are no properties.
3351 	 */
3352 	GDBusPropertyInfo** properties;
3353 	/**
3354 	 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
3355 	 */
3356 	GDBusAnnotationInfo** annotations;
3357 }
3358 
3359 struct GDBusInterfaceSkeleton
3360 {
3361 	GObject parentInstance;
3362 	GDBusInterfaceSkeletonPrivate* priv;
3363 }
3364 
3365 /**
3366  * Class structure for #GDBusInterfaceSkeleton.
3367  *
3368  * Since: 2.30
3369  */
3370 struct GDBusInterfaceSkeletonClass
3371 {
3372 	/**
3373 	 * The parent class.
3374 	 */
3375 	GObjectClass parentClass;
3376 	/**
3377 	 *
3378 	 * Params:
3379 	 *     iface = A #GDBusInterfaceSkeleton.
3380 	 * Return: A #GDBusInterfaceInfo (never %NULL). Do not free.
3381 	 */
3382 	extern(C) GDBusInterfaceInfo* function(GDBusInterfaceSkeleton* iface) getInfo;
3383 	/**
3384 	 *
3385 	 * Params:
3386 	 *     iface = A #GDBusInterfaceSkeleton.
3387 	 * Return: A #GDBusInterfaceVTable (never %NULL).
3388 	 */
3389 	extern(C) GDBusInterfaceVTable* function(GDBusInterfaceSkeleton* iface) getVtable;
3390 	/**
3391 	 *
3392 	 * Params:
3393 	 *     iface = A #GDBusInterfaceSkeleton.
3394 	 * Return: A #GVariant of type
3395 	 *     ['a{sv}'][G-VARIANT-TYPE-VARDICT:CAPS].
3396 	 *     Free with g_variant_unref().
3397 	 */
3398 	extern(C) GVariant* function(GDBusInterfaceSkeleton* iface) getProperties;
3399 	extern(C) void function(GDBusInterfaceSkeleton* iface) flush;
3400 	void*[8] vfuncPadding;
3401 	extern(C) int function(GDBusInterfaceSkeleton* iface, GDBusMethodInvocation* invocation) gAuthorizeMethod;
3402 	void*[8] signalPadding;
3403 }
3404 
3405 struct GDBusInterfaceSkeletonPrivate;
3406 
3407 /**
3408  * Virtual table for handling properties and method calls for a D-Bus
3409  * interface.
3410  *
3411  * Since 2.38, if you want to handle getting/setting D-Bus properties
3412  * asynchronously, give %NULL as your get_property() or set_property()
3413  * function. The D-Bus call will be directed to your @method_call function,
3414  * with the provided @interface_name set to "org.freedesktop.DBus.Properties".
3415  *
3416  * The usual checks on the validity of the calls is performed. For
3417  * `Get` calls, an error is automatically returned if the property does
3418  * not exist or the permissions do not allow access. The same checks are
3419  * performed for `Set` calls, and the provided value is also checked for
3420  * being the correct type.
3421  *
3422  * For both `Get` and `Set` calls, the #GDBusMethodInvocation
3423  * passed to the @method_call handler can be queried with
3424  * g_dbus_method_invocation_get_property_info() to get a pointer
3425  * to the #GDBusPropertyInfo of the property.
3426  *
3427  * If you have readable properties specified in your interface info,
3428  * you must ensure that you either provide a non-%NULL @get_property()
3429  * function or provide implementations of both the `Get` and `GetAll`
3430  * methods on org.freedesktop.DBus.Properties interface in your @method_call
3431  * function. Note that the required return type of the `Get` call is
3432  * `(v)`, not the type of the property. `GetAll` expects a return value
3433  * of type `a{sv}`.
3434  *
3435  * If you have writable properties specified in your interface info,
3436  * you must ensure that you either provide a non-%NULL @set_property()
3437  * function or provide an implementation of the `Set` call. If implementing
3438  * the call, you must return the value of type %G_VARIANT_TYPE_UNIT.
3439  *
3440  * Since: 2.26
3441  */
3442 struct GDBusInterfaceVTable
3443 {
3444 	/**
3445 	 * Function for handling incoming method calls.
3446 	 */
3447 	GDBusInterfaceMethodCallFunc methodCall;
3448 	/**
3449 	 * Function for getting a property.
3450 	 */
3451 	GDBusInterfaceGetPropertyFunc getProperty;
3452 	/**
3453 	 * Function for setting a property.
3454 	 */
3455 	GDBusInterfaceSetPropertyFunc setProperty;
3456 	void*[8] padding;
3457 }
3458 
3459 struct GDBusMenuModel;
3460 
3461 struct GDBusMessage;
3462 
3463 struct GDBusMethodInfo
3464 {
3465 	/**
3466 	 * The reference count or -1 if statically allocated.
3467 	 */
3468 	int refCount;
3469 	/**
3470 	 * The name of the D-Bus method, e.g. @RequestName.
3471 	 */
3472 	char* name;
3473 	/**
3474 	 * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no in arguments.
3475 	 */
3476 	GDBusArgInfo** inArgs;
3477 	/**
3478 	 * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no out arguments.
3479 	 */
3480 	GDBusArgInfo** outArgs;
3481 	/**
3482 	 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
3483 	 */
3484 	GDBusAnnotationInfo** annotations;
3485 }
3486 
3487 struct GDBusMethodInvocation;
3488 
3489 struct GDBusNodeInfo
3490 {
3491 	/**
3492 	 * The reference count or -1 if statically allocated.
3493 	 */
3494 	int refCount;
3495 	/**
3496 	 * The path of the node or %NULL if omitted. Note that this may be a relative path. See the D-Bus specification for more details.
3497 	 */
3498 	char* path;
3499 	/**
3500 	 * A pointer to a %NULL-terminated array of pointers to #GDBusInterfaceInfo structures or %NULL if there are no interfaces.
3501 	 */
3502 	GDBusInterfaceInfo** interfaces;
3503 	/**
3504 	 * A pointer to a %NULL-terminated array of pointers to #GDBusNodeInfo structures or %NULL if there are no nodes.
3505 	 */
3506 	GDBusNodeInfo** nodes;
3507 	/**
3508 	 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
3509 	 */
3510 	GDBusAnnotationInfo** annotations;
3511 }
3512 
3513 struct GDBusObject;
3514 
3515 /**
3516  * Base object type for D-Bus objects.
3517  *
3518  * Since: 2.30
3519  */
3520 struct GDBusObjectIface
3521 {
3522 	/**
3523 	 * The parent interface.
3524 	 */
3525 	GTypeInterface parentIface;
3526 	/**
3527 	 *
3528 	 * Params:
3529 	 *     object = A #GDBusObject.
3530 	 * Return: A string owned by @object. Do not free.
3531 	 */
3532 	extern(C) const(char)* function(GDBusObject* object) getObjectPath;
3533 	/**
3534 	 *
3535 	 * Params:
3536 	 *     object = A #GDBusObject.
3537 	 * Return: A list of #GDBusInterface instances.
3538 	 *     The returned list must be freed by g_list_free() after each element has been freed
3539 	 *     with g_object_unref().
3540 	 */
3541 	extern(C) GList* function(GDBusObject* object) getInterfaces;
3542 	/**
3543 	 *
3544 	 * Params:
3545 	 *     object = A #GDBusObject.
3546 	 *     interfaceName = A D-Bus interface name.
3547 	 * Return: %NULL if not found, otherwise a
3548 	 *     #GDBusInterface that must be freed with g_object_unref().
3549 	 */
3550 	extern(C) GDBusInterface* function(GDBusObject* object, const(char)* interfaceName) getInterface;
3551 	extern(C) void function(GDBusObject* object, GDBusInterface* iface) interfaceAdded;
3552 	extern(C) void function(GDBusObject* object, GDBusInterface* iface) interfaceRemoved;
3553 }
3554 
3555 struct GDBusObjectManager;
3556 
3557 struct GDBusObjectManagerClient
3558 {
3559 	GObject parentInstance;
3560 	GDBusObjectManagerClientPrivate* priv;
3561 }
3562 
3563 /**
3564  * Class structure for #GDBusObjectManagerClient.
3565  *
3566  * Since: 2.30
3567  */
3568 struct GDBusObjectManagerClientClass
3569 {
3570 	/**
3571 	 * The parent class.
3572 	 */
3573 	GObjectClass parentClass;
3574 	extern(C) void function(GDBusObjectManagerClient* manager, GDBusObjectProxy* objectProxy, GDBusProxy* interfaceProxy, const(char)* senderName, const(char)* signalName, GVariant* parameters) interfaceProxySignal;
3575 	extern(C) void function(GDBusObjectManagerClient* manager, GDBusObjectProxy* objectProxy, GDBusProxy* interfaceProxy, GVariant* changedProperties, const(char)* invalidatedProperties) interfaceProxyPropertiesChanged;
3576 	void*[8] padding;
3577 }
3578 
3579 struct GDBusObjectManagerClientPrivate;
3580 
3581 /**
3582  * Base type for D-Bus object managers.
3583  *
3584  * Since: 2.30
3585  */
3586 struct GDBusObjectManagerIface
3587 {
3588 	/**
3589 	 * The parent interface.
3590 	 */
3591 	GTypeInterface parentIface;
3592 	/**
3593 	 *
3594 	 * Params:
3595 	 *     manager = A #GDBusObjectManager.
3596 	 * Return: A string owned by @manager. Do not free.
3597 	 */
3598 	extern(C) const(char)* function(GDBusObjectManager* manager) getObjectPath;
3599 	/**
3600 	 *
3601 	 * Params:
3602 	 *     manager = A #GDBusObjectManager.
3603 	 * Return: A list of
3604 	 *     #GDBusObject objects. The returned list should be freed with
3605 	 *     g_list_free() after each element has been freed with
3606 	 *     g_object_unref().
3607 	 */
3608 	extern(C) GList* function(GDBusObjectManager* manager) getObjects;
3609 	/**
3610 	 *
3611 	 * Params:
3612 	 *     manager = A #GDBusObjectManager.
3613 	 *     objectPath = Object path to lookup.
3614 	 * Return: A #GDBusObject or %NULL. Free with
3615 	 *     g_object_unref().
3616 	 */
3617 	extern(C) GDBusObject* function(GDBusObjectManager* manager, const(char)* objectPath) getObject;
3618 	/**
3619 	 *
3620 	 * Params:
3621 	 *     manager = A #GDBusObjectManager.
3622 	 *     objectPath = Object path to lookup.
3623 	 *     interfaceName = D-Bus interface name to lookup.
3624 	 * Return: A #GDBusInterface instance or %NULL. Free
3625 	 *     with g_object_unref().
3626 	 */
3627 	extern(C) GDBusInterface* function(GDBusObjectManager* manager, const(char)* objectPath, const(char)* interfaceName) getInterface;
3628 	extern(C) void function(GDBusObjectManager* manager, GDBusObject* object) objectAdded;
3629 	extern(C) void function(GDBusObjectManager* manager, GDBusObject* object) objectRemoved;
3630 	extern(C) void function(GDBusObjectManager* manager, GDBusObject* object, GDBusInterface* iface) interfaceAdded;
3631 	extern(C) void function(GDBusObjectManager* manager, GDBusObject* object, GDBusInterface* iface) interfaceRemoved;
3632 }
3633 
3634 struct GDBusObjectManagerServer
3635 {
3636 	GObject parentInstance;
3637 	GDBusObjectManagerServerPrivate* priv;
3638 }
3639 
3640 /**
3641  * Class structure for #GDBusObjectManagerServer.
3642  *
3643  * Since: 2.30
3644  */
3645 struct GDBusObjectManagerServerClass
3646 {
3647 	/**
3648 	 * The parent class.
3649 	 */
3650 	GObjectClass parentClass;
3651 	void*[8] padding;
3652 }
3653 
3654 struct GDBusObjectManagerServerPrivate;
3655 
3656 struct GDBusObjectProxy
3657 {
3658 	GObject parentInstance;
3659 	GDBusObjectProxyPrivate* priv;
3660 }
3661 
3662 /**
3663  * Class structure for #GDBusObjectProxy.
3664  *
3665  * Since: 2.30
3666  */
3667 struct GDBusObjectProxyClass
3668 {
3669 	/**
3670 	 * The parent class.
3671 	 */
3672 	GObjectClass parentClass;
3673 	void*[8] padding;
3674 }
3675 
3676 struct GDBusObjectProxyPrivate;
3677 
3678 struct GDBusObjectSkeleton
3679 {
3680 	GObject parentInstance;
3681 	GDBusObjectSkeletonPrivate* priv;
3682 }
3683 
3684 /**
3685  * Class structure for #GDBusObjectSkeleton.
3686  *
3687  * Since: 2.30
3688  */
3689 struct GDBusObjectSkeletonClass
3690 {
3691 	/**
3692 	 * The parent class.
3693 	 */
3694 	GObjectClass parentClass;
3695 	extern(C) int function(GDBusObjectSkeleton* object, GDBusInterfaceSkeleton* iface, GDBusMethodInvocation* invocation) authorizeMethod;
3696 	void*[8] padding;
3697 }
3698 
3699 struct GDBusObjectSkeletonPrivate;
3700 
3701 struct GDBusPropertyInfo
3702 {
3703 	/**
3704 	 * The reference count or -1 if statically allocated.
3705 	 */
3706 	int refCount;
3707 	/**
3708 	 * The name of the D-Bus property, e.g. "SupportedFilesystems".
3709 	 */
3710 	char* name;
3711 	/**
3712 	 * The D-Bus signature of the property (a single complete type).
3713 	 */
3714 	char* signature;
3715 	/**
3716 	 * Access control flags for the property.
3717 	 */
3718 	GDBusPropertyInfoFlags flags;
3719 	/**
3720 	 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
3721 	 */
3722 	GDBusAnnotationInfo** annotations;
3723 }
3724 
3725 struct GDBusProxy
3726 {
3727 	GObject parentInstance;
3728 	GDBusProxyPrivate* priv;
3729 }
3730 
3731 /**
3732  * Class structure for #GDBusProxy.
3733  *
3734  * Since: 2.26
3735  */
3736 struct GDBusProxyClass
3737 {
3738 	GObjectClass parentClass;
3739 	extern(C) void function(GDBusProxy* proxy, GVariant* changedProperties, const(char)* invalidatedProperties) gPropertiesChanged;
3740 	extern(C) void function(GDBusProxy* proxy, const(char)* senderName, const(char)* signalName, GVariant* parameters) gSignal;
3741 	void*[32] padding;
3742 }
3743 
3744 struct GDBusProxyPrivate;
3745 
3746 struct GDBusServer;
3747 
3748 struct GDBusSignalInfo
3749 {
3750 	/**
3751 	 * The reference count or -1 if statically allocated.
3752 	 */
3753 	int refCount;
3754 	/**
3755 	 * The name of the D-Bus signal, e.g. "NameOwnerChanged".
3756 	 */
3757 	char* name;
3758 	/**
3759 	 * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no arguments.
3760 	 */
3761 	GDBusArgInfo** args;
3762 	/**
3763 	 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
3764 	 */
3765 	GDBusAnnotationInfo** annotations;
3766 }
3767 
3768 /**
3769  * Virtual table for handling subtrees registered with g_dbus_connection_register_subtree().
3770  *
3771  * Since: 2.26
3772  */
3773 struct GDBusSubtreeVTable
3774 {
3775 	/**
3776 	 * Function for enumerating child nodes.
3777 	 */
3778 	GDBusSubtreeEnumerateFunc enumerate;
3779 	/**
3780 	 * Function for introspecting a child node.
3781 	 */
3782 	GDBusSubtreeIntrospectFunc introspect;
3783 	/**
3784 	 * Function for dispatching a remote call on a child node.
3785 	 */
3786 	GDBusSubtreeDispatchFunc dispatch;
3787 	void*[8] padding;
3788 }
3789 
3790 struct GDataInputStream
3791 {
3792 	GBufferedInputStream parentInstance;
3793 	GDataInputStreamPrivate* priv;
3794 }
3795 
3796 struct GDataInputStreamClass
3797 {
3798 	GBufferedInputStreamClass parentClass;
3799 	extern(C) void function() GReserved1;
3800 	extern(C) void function() GReserved2;
3801 	extern(C) void function() GReserved3;
3802 	extern(C) void function() GReserved4;
3803 	extern(C) void function() GReserved5;
3804 }
3805 
3806 struct GDataInputStreamPrivate;
3807 
3808 struct GDataOutputStream
3809 {
3810 	GFilterOutputStream parentInstance;
3811 	GDataOutputStreamPrivate* priv;
3812 }
3813 
3814 struct GDataOutputStreamClass
3815 {
3816 	GFilterOutputStreamClass parentClass;
3817 	extern(C) void function() GReserved1;
3818 	extern(C) void function() GReserved2;
3819 	extern(C) void function() GReserved3;
3820 	extern(C) void function() GReserved4;
3821 	extern(C) void function() GReserved5;
3822 }
3823 
3824 struct GDataOutputStreamPrivate;
3825 
3826 struct GDesktopAppInfo;
3827 
3828 struct GDesktopAppInfoClass
3829 {
3830 	GObjectClass parentClass;
3831 }
3832 
3833 struct GDesktopAppInfoLookup;
3834 
3835 struct GDesktopAppInfoLookupIface
3836 {
3837 	GTypeInterface gIface;
3838 	/**
3839 	 *
3840 	 * Params:
3841 	 *     lookup = a #GDesktopAppInfoLookup
3842 	 *     uriScheme = a string containing a URI scheme.
3843 	 * Return: #GAppInfo for given @uri_scheme or %NULL on error.
3844 	 */
3845 	extern(C) GAppInfo* function(GDesktopAppInfoLookup* lookup, const(char)* uriScheme) getDefaultForUriScheme;
3846 }
3847 
3848 struct GDrive;
3849 
3850 /**
3851  * Interface for creating #GDrive implementations.
3852  */
3853 struct GDriveIface
3854 {
3855 	/**
3856 	 * The parent interface.
3857 	 */
3858 	GTypeInterface gIface;
3859 	extern(C) void function(GDrive* drive) changed;
3860 	extern(C) void function(GDrive* drive) disconnected;
3861 	extern(C) void function(GDrive* drive) ejectButton;
3862 	/**
3863 	 *
3864 	 * Params:
3865 	 *     drive = a #GDrive.
3866 	 * Return: a string containing @drive's name. The returned
3867 	 *     string should be freed when no longer needed.
3868 	 */
3869 	extern(C) char* function(GDrive* drive) getName;
3870 	/**
3871 	 *
3872 	 * Params:
3873 	 *     drive = a #GDrive.
3874 	 * Return: #GIcon for the @drive.
3875 	 *     Free the returned object with g_object_unref().
3876 	 */
3877 	extern(C) GIcon* function(GDrive* drive) getIcon;
3878 	/**
3879 	 *
3880 	 * Params:
3881 	 *     drive = a #GDrive.
3882 	 * Return: %TRUE if the @drive contains volumes, %FALSE otherwise.
3883 	 */
3884 	extern(C) int function(GDrive* drive) hasVolumes;
3885 	/**
3886 	 *
3887 	 * Params:
3888 	 *     drive = a #GDrive.
3889 	 * Return: #GList containing any #GVolume objects on the given @drive.
3890 	 */
3891 	extern(C) GList* function(GDrive* drive) getVolumes;
3892 	/**
3893 	 *
3894 	 * Params:
3895 	 *     drive = a #GDrive.
3896 	 * Return: %TRUE if @drive supports removable media, %FALSE otherwise.
3897 	 */
3898 	extern(C) int function(GDrive* drive) isMediaRemovable;
3899 	/**
3900 	 *
3901 	 * Params:
3902 	 *     drive = a #GDrive.
3903 	 * Return: %TRUE if @drive has media, %FALSE otherwise.
3904 	 */
3905 	extern(C) int function(GDrive* drive) hasMedia;
3906 	/**
3907 	 *
3908 	 * Params:
3909 	 *     drive = a #GDrive.
3910 	 * Return: %TRUE if the @drive is capabable of automatically detecting
3911 	 *     media changes, %FALSE otherwise.
3912 	 */
3913 	extern(C) int function(GDrive* drive) isMediaCheckAutomatic;
3914 	/**
3915 	 *
3916 	 * Params:
3917 	 *     drive = a #GDrive.
3918 	 * Return: %TRUE if the @drive can be ejected, %FALSE otherwise.
3919 	 */
3920 	extern(C) int function(GDrive* drive) canEject;
3921 	/**
3922 	 *
3923 	 * Params:
3924 	 *     drive = a #GDrive.
3925 	 * Return: %TRUE if the @drive can be polled for media changes,
3926 	 *     %FALSE otherwise.
3927 	 */
3928 	extern(C) int function(GDrive* drive) canPollForMedia;
3929 	extern(C) void function(GDrive* drive, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) eject;
3930 	/**
3931 	 *
3932 	 * Params:
3933 	 *     drive = a #GDrive.
3934 	 *     result = a #GAsyncResult.
3935 	 * Return: %TRUE if the drive has been ejected successfully,
3936 	 *     %FALSE otherwise.
3937 	 *
3938 	 * Throws: GException on failure.
3939 	 */
3940 	extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) ejectFinish;
3941 	extern(C) void function(GDrive* drive, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) pollForMedia;
3942 	/**
3943 	 *
3944 	 * Params:
3945 	 *     drive = a #GDrive.
3946 	 *     result = a #GAsyncResult.
3947 	 * Return: %TRUE if the drive has been poll_for_mediaed successfully,
3948 	 *     %FALSE otherwise.
3949 	 *
3950 	 * Throws: GException on failure.
3951 	 */
3952 	extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) pollForMediaFinish;
3953 	/**
3954 	 *
3955 	 * Params:
3956 	 *     drive = a #GDrive
3957 	 *     kind = the kind of identifier to return
3958 	 * Return: a newly allocated string containing the
3959 	 *     requested identfier, or %NULL if the #GDrive
3960 	 *     doesn't have this kind of identifier.
3961 	 */
3962 	extern(C) char* function(GDrive* drive, const(char)* kind) getIdentifier;
3963 	/**
3964 	 *
3965 	 * Params:
3966 	 *     drive = a #GDrive
3967 	 * Return: a %NULL-terminated
3968 	 *     array of strings containing kinds of identifiers. Use g_strfreev()
3969 	 *     to free.
3970 	 */
3971 	extern(C) char** function(GDrive* drive) enumerateIdentifiers;
3972 	/**
3973 	 *
3974 	 * Params:
3975 	 *     drive = a #GDrive.
3976 	 * Return: A value from the #GDriveStartStopType enumeration.
3977 	 */
3978 	extern(C) GDriveStartStopType function(GDrive* drive) getStartStopType;
3979 	/**
3980 	 *
3981 	 * Params:
3982 	 *     drive = a #GDrive.
3983 	 * Return: %TRUE if the @drive can be started, %FALSE otherwise.
3984 	 */
3985 	extern(C) int function(GDrive* drive) canStart;
3986 	/**
3987 	 *
3988 	 * Params:
3989 	 *     drive = a #GDrive.
3990 	 * Return: %TRUE if the @drive can be started degraded, %FALSE otherwise.
3991 	 */
3992 	extern(C) int function(GDrive* drive) canStartDegraded;
3993 	extern(C) void function(GDrive* drive, GDriveStartFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) start;
3994 	/**
3995 	 *
3996 	 * Params:
3997 	 *     drive = a #GDrive.
3998 	 *     result = a #GAsyncResult.
3999 	 * Return: %TRUE if the drive has been started successfully,
4000 	 *     %FALSE otherwise.
4001 	 *
4002 	 * Throws: GException on failure.
4003 	 */
4004 	extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) startFinish;
4005 	/**
4006 	 *
4007 	 * Params:
4008 	 *     drive = a #GDrive.
4009 	 * Return: %TRUE if the @drive can be stopped, %FALSE otherwise.
4010 	 */
4011 	extern(C) int function(GDrive* drive) canStop;
4012 	extern(C) void function(GDrive* drive, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) stop;
4013 	/**
4014 	 *
4015 	 * Params:
4016 	 *     drive = a #GDrive.
4017 	 *     result = a #GAsyncResult.
4018 	 * Return: %TRUE if the drive has been stopped successfully,
4019 	 *     %FALSE otherwise.
4020 	 *
4021 	 * Throws: GException on failure.
4022 	 */
4023 	extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) stopFinish;
4024 	extern(C) void function(GDrive* drive) stopButton;
4025 	extern(C) void function(GDrive* drive, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectWithOperation;
4026 	/**
4027 	 *
4028 	 * Params:
4029 	 *     drive = a #GDrive.
4030 	 *     result = a #GAsyncResult.
4031 	 * Return: %TRUE if the drive was successfully ejected. %FALSE otherwise.
4032 	 *
4033 	 * Throws: GException on failure.
4034 	 */
4035 	extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) ejectWithOperationFinish;
4036 	/**
4037 	 *
4038 	 * Params:
4039 	 *     drive = A #GDrive.
4040 	 * Return: Sorting key for @drive or %NULL if no such key is available.
4041 	 */
4042 	extern(C) const(char)* function(GDrive* drive) getSortKey;
4043 	/**
4044 	 *
4045 	 * Params:
4046 	 *     drive = a #GDrive.
4047 	 * Return: symbolic #GIcon for the @drive.
4048 	 *     Free the returned object with g_object_unref().
4049 	 */
4050 	extern(C) GIcon* function(GDrive* drive) getSymbolicIcon;
4051 }
4052 
4053 struct GEmblem;
4054 
4055 struct GEmblemClass;
4056 
4057 struct GEmblemedIcon
4058 {
4059 	GObject parentInstance;
4060 	GEmblemedIconPrivate* priv;
4061 }
4062 
4063 struct GEmblemedIconClass
4064 {
4065 	GObjectClass parentClass;
4066 }
4067 
4068 struct GEmblemedIconPrivate;
4069 
4070 struct GFile;
4071 
4072 /**
4073  * Information about a specific attribute.
4074  */
4075 struct GFileAttributeInfo
4076 {
4077 	/**
4078 	 * the name of the attribute.
4079 	 */
4080 	char* name;
4081 	/**
4082 	 * the #GFileAttributeType type of the attribute.
4083 	 */
4084 	GFileAttributeType type;
4085 	/**
4086 	 * a set of #GFileAttributeInfoFlags.
4087 	 */
4088 	GFileAttributeInfoFlags flags;
4089 }
4090 
4091 struct GFileAttributeInfoList
4092 {
4093 	/**
4094 	 * an array of #GFileAttributeInfos.
4095 	 */
4096 	GFileAttributeInfo* infos;
4097 	/**
4098 	 * the number of values in the array.
4099 	 */
4100 	int nInfos;
4101 }
4102 
4103 struct GFileAttributeMatcher;
4104 
4105 struct GFileDescriptorBased;
4106 
4107 struct GFileDescriptorBasedIface
4108 {
4109 	/**
4110 	 * The parent interface.
4111 	 */
4112 	GTypeInterface gIface;
4113 	/**
4114 	 *
4115 	 * Params:
4116 	 *     fdBased = a #GFileDescriptorBased.
4117 	 * Return: The file descriptor
4118 	 */
4119 	extern(C) int function(GFileDescriptorBased* fdBased) getFd;
4120 }
4121 
4122 struct GFileEnumerator
4123 {
4124 	GObject parentInstance;
4125 	GFileEnumeratorPrivate* priv;
4126 }
4127 
4128 struct GFileEnumeratorClass
4129 {
4130 	GObjectClass parentClass;
4131 	/**
4132 	 *
4133 	 * Params:
4134 	 *     enumerator = a #GFileEnumerator.
4135 	 *     cancellable = optional #GCancellable object, %NULL to ignore.
4136 	 * Return: A #GFileInfo or %NULL on error
4137 	 *     or end of enumerator.  Free the returned object with
4138 	 *     g_object_unref() when no longer needed.
4139 	 *
4140 	 * Throws: GException on failure.
4141 	 */
4142 	extern(C) GFileInfo* function(GFileEnumerator* enumerator, GCancellable* cancellable, GError** err) nextFile;
4143 	extern(C) int function(GFileEnumerator* enumerator, GCancellable* cancellable, GError** err) closeFn;
4144 	extern(C) void function(GFileEnumerator* enumerator, int numFiles, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) nextFilesAsync;
4145 	/**
4146 	 *
4147 	 * Params:
4148 	 *     enumerator = a #GFileEnumerator.
4149 	 *     result = a #GAsyncResult.
4150 	 * Return: a #GList of #GFileInfos. You must free the list with
4151 	 *     g_list_free() and unref the infos with g_object_unref() when you're
4152 	 *     done with them.
4153 	 *
4154 	 * Throws: GException on failure.
4155 	 */
4156 	extern(C) GList* function(GFileEnumerator* enumerator, GAsyncResult* result, GError** err) nextFilesFinish;
4157 	extern(C) void function(GFileEnumerator* enumerator, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) closeAsync;
4158 	/**
4159 	 *
4160 	 * Params:
4161 	 *     enumerator = a #GFileEnumerator.
4162 	 *     result = a #GAsyncResult.
4163 	 * Return: %TRUE if the close operation has finished successfully.
4164 	 *
4165 	 * Throws: GException on failure.
4166 	 */
4167 	extern(C) int function(GFileEnumerator* enumerator, GAsyncResult* result, GError** err) closeFinish;
4168 	extern(C) void function() GReserved1;
4169 	extern(C) void function() GReserved2;
4170 	extern(C) void function() GReserved3;
4171 	extern(C) void function() GReserved4;
4172 	extern(C) void function() GReserved5;
4173 	extern(C) void function() GReserved6;
4174 	extern(C) void function() GReserved7;
4175 }
4176 
4177 struct GFileEnumeratorPrivate;
4178 
4179 struct GFileIOStream
4180 {
4181 	GIOStream parentInstance;
4182 	GFileIOStreamPrivate* priv;
4183 }
4184 
4185 struct GFileIOStreamClass
4186 {
4187 	GIOStreamClass parentClass;
4188 	extern(C) long function(GFileIOStream* stream) tell;
4189 	extern(C) int function(GFileIOStream* stream) canSeek;
4190 	extern(C) int function(GFileIOStream* stream, long offset, GSeekType type, GCancellable* cancellable, GError** err) seek;
4191 	extern(C) int function(GFileIOStream* stream) canTruncate;
4192 	extern(C) int function(GFileIOStream* stream, long size, GCancellable* cancellable, GError** err) truncateFn;
4193 	/**
4194 	 *
4195 	 * Params:
4196 	 *     stream = a #GFileIOStream.
4197 	 *     attributes = a file attribute query string.
4198 	 *     cancellable = optional #GCancellable object, %NULL to ignore.
4199 	 * Return: a #GFileInfo for the @stream, or %NULL on error.
4200 	 *
4201 	 * Throws: GException on failure.
4202 	 */
4203 	extern(C) GFileInfo* function(GFileIOStream* stream, const(char)* attributes, GCancellable* cancellable, GError** err) queryInfo;
4204 	extern(C) void function(GFileIOStream* stream, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryInfoAsync;
4205 	/**
4206 	 *
4207 	 * Params:
4208 	 *     stream = a #GFileIOStream.
4209 	 *     result = a #GAsyncResult.
4210 	 * Return: A #GFileInfo for the finished query.
4211 	 *
4212 	 * Throws: GException on failure.
4213 	 */
4214 	extern(C) GFileInfo* function(GFileIOStream* stream, GAsyncResult* result, GError** err) queryInfoFinish;
4215 	/**
4216 	 *
4217 	 * Params:
4218 	 *     stream = a #GFileIOStream.
4219 	 * Return: the entity tag for the stream.
4220 	 */
4221 	extern(C) char* function(GFileIOStream* stream) getEtag;
4222 	extern(C) void function() GReserved1;
4223 	extern(C) void function() GReserved2;
4224 	extern(C) void function() GReserved3;
4225 	extern(C) void function() GReserved4;
4226 	extern(C) void function() GReserved5;
4227 }
4228 
4229 struct GFileIOStreamPrivate;
4230 
4231 struct GFileIcon;
4232 
4233 struct GFileIconClass;
4234 
4235 /**
4236  * An interface for writing VFS file handles.
4237  */
4238 struct GFileIface
4239 {
4240 	/**
4241 	 * The parent interface.
4242 	 */
4243 	GTypeInterface gIface;
4244 	/**
4245 	 *
4246 	 * Params:
4247 	 *     file = input #GFile
4248 	 * Return: a new #GFile that is a duplicate
4249 	 *     of the given #GFile.
4250 	 */
4251 	extern(C) GFile* function(GFile* file) dup;
4252 	/**
4253 	 *
4254 	 * Params:
4255 	 *     file = #gconstpointer to a #GFile
4256 	 * Return: 0 if @file is not a valid #GFile, otherwise an
4257 	 *     integer that can be used as hash value for the #GFile.
4258 	 *     This function is intended for easily hashing a #GFile to
4259 	 *     add to a #GHashTable or similar data structure.
4260 	 */
4261 	extern(C) uint function(GFile* file) hash;
4262 	/**
4263 	 *
4264 	 * Params:
4265 	 *     file1 = the first #GFile
4266 	 *     file2 = the second #GFile
4267 	 * Return: %TRUE if @file1 and @file2 are equal.
4268 	 */
4269 	extern(C) int function(GFile* file1, GFile* file2) equal;
4270 	/**
4271 	 *
4272 	 * Params:
4273 	 *     file = input #GFile
4274 	 * Return: %TRUE if @file is native
4275 	 */
4276 	extern(C) int function(GFile* file) isNative;
4277 	/**
4278 	 *
4279 	 * Params:
4280 	 *     file = input #GFile
4281 	 *     uriScheme = a string containing a URI scheme
4282 	 * Return: %TRUE if #GFile's backend supports the
4283 	 *     given URI scheme, %FALSE if URI scheme is %NULL,
4284 	 *     not supported, or #GFile is invalid.
4285 	 */
4286 	extern(C) int function(GFile* file, const(char)* uriScheme) hasUriScheme;
4287 	/**
4288 	 *
4289 	 * Params:
4290 	 *     file = input #GFile
4291 	 * Return: a string containing the URI scheme for the given
4292 	 *     #GFile. The returned string should be freed with g_free()
4293 	 *     when no longer needed.
4294 	 */
4295 	extern(C) char* function(GFile* file) getUriScheme;
4296 	/**
4297 	 *
4298 	 * Params:
4299 	 *     file = input #GFile
4300 	 * Return: string containing the #GFile's base name, or
4301 	 *     %NULL if given #GFile is invalid. The returned string should be
4302 	 *     freed with g_free() when no longer needed.
4303 	 */
4304 	extern(C) char* function(GFile* file) getBasename;
4305 	/**
4306 	 *
4307 	 * Params:
4308 	 *     file = input #GFile
4309 	 * Return: string containing the #GFile's path, or %NULL
4310 	 *     if no such path exists. The returned string should be freed
4311 	 *     with g_free() when no longer needed.
4312 	 */
4313 	extern(C) char* function(GFile* file) getPath;
4314 	/**
4315 	 *
4316 	 * Params:
4317 	 *     file = input #GFile
4318 	 * Return: a string containing the #GFile's URI.
4319 	 *     The returned string should be freed with g_free()
4320 	 *     when no longer needed.
4321 	 */
4322 	extern(C) char* function(GFile* file) getUri;
4323 	/**
4324 	 *
4325 	 * Params:
4326 	 *     file = input #GFile
4327 	 * Return: a string containing the #GFile's parse name.
4328 	 *     The returned string should be freed with g_free()
4329 	 *     when no longer needed.
4330 	 */
4331 	extern(C) char* function(GFile* file) getParseName;
4332 	/**
4333 	 *
4334 	 * Params:
4335 	 *     file = input #GFile
4336 	 * Return: a #GFile structure to the
4337 	 *     parent of the given #GFile or %NULL if there is no parent. Free
4338 	 *     the returned object with g_object_unref().
4339 	 */
4340 	extern(C) GFile* function(GFile* file) getParent;
4341 	/**
4342 	 *
4343 	 * Params:
4344 	 *     prefix = input #GFile
4345 	 *     file = input #GFile
4346 	 * Return: %TRUE if the @files's parent, grandparent, etc is @prefix,
4347 	 *     %FALSE otherwise.
4348 	 */
4349 	extern(C) int function(GFile* prefix, GFile* file) prefixMatches;
4350 	/**
4351 	 *
4352 	 * Params:
4353 	 *     parent = input #GFile
4354 	 *     descendant = input #GFile
4355 	 * Return: string with the relative path from @descendant
4356 	 *     to @parent, or %NULL if @descendant doesn't have @parent as
4357 	 *     prefix. The returned string should be freed with g_free() when
4358 	 *     no longer needed.
4359 	 */
4360 	extern(C) char* function(GFile* parent, GFile* descendant) getRelativePath;
4361 	/**
4362 	 *
4363 	 * Params:
4364 	 *     file = input #GFile
4365 	 *     relativePath = a given relative path string
4366 	 * Return: #GFile to the resolved path.
4367 	 *     %NULL if @relative_path is %NULL or if @file is invalid.
4368 	 *     Free the returned object with g_object_unref().
4369 	 */
4370 	extern(C) GFile* function(GFile* file, const(char)* relativePath) resolveRelativePath;
4371 	/**
4372 	 *
4373 	 * Params:
4374 	 *     file = input #GFile
4375 	 *     displayName = string to a possible child
4376 	 * Return: a #GFile to the specified child, or
4377 	 *     %NULL if the display name couldn't be converted.
4378 	 *     Free the returned object with g_object_unref().
4379 	 *
4380 	 * Throws: GException on failure.
4381 	 */
4382 	extern(C) GFile* function(GFile* file, const(char)* displayName, GError** err) getChildForDisplayName;
4383 	/**
4384 	 *
4385 	 * Params:
4386 	 *     file = input #GFile
4387 	 *     attributes = an attribute query string
4388 	 *     flags = a set of #GFileQueryInfoFlags
4389 	 *     cancellable = optional #GCancellable object,
4390 	 *         %NULL to ignore
4391 	 * Return: A #GFileEnumerator if successful,
4392 	 *     %NULL on error. Free the returned object with g_object_unref().
4393 	 *
4394 	 * Throws: GException on failure.
4395 	 */
4396 	extern(C) GFileEnumerator* function(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) enumerateChildren;
4397 	extern(C) void function(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) enumerateChildrenAsync;
4398 	/**
4399 	 *
4400 	 * Params:
4401 	 *     file = input #GFile
4402 	 *     res = a #GAsyncResult
4403 	 * Return: a #GFileEnumerator or %NULL
4404 	 *     if an error occurred.
4405 	 *     Free the returned object with g_object_unref().
4406 	 *
4407 	 * Throws: GException on failure.
4408 	 */
4409 	extern(C) GFileEnumerator* function(GFile* file, GAsyncResult* res, GError** err) enumerateChildrenFinish;
4410 	/**
4411 	 *
4412 	 * Params:
4413 	 *     file = input #GFile
4414 	 *     attributes = an attribute query string
4415 	 *     flags = a set of #GFileQueryInfoFlags
4416 	 *     cancellable = optional #GCancellable object,
4417 	 *         %NULL to ignore
4418 	 * Return: a #GFileInfo for the given @file, or %NULL
4419 	 *     on error. Free the returned object with g_object_unref().
4420 	 *
4421 	 * Throws: GException on failure.
4422 	 */
4423 	extern(C) GFileInfo* function(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) queryInfo;
4424 	extern(C) void function(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryInfoAsync;
4425 	/**
4426 	 *
4427 	 * Params:
4428 	 *     file = input #GFile
4429 	 *     res = a #GAsyncResult
4430 	 * Return: #GFileInfo for given @file
4431 	 *     or %NULL on error. Free the returned object with
4432 	 *     g_object_unref().
4433 	 *
4434 	 * Throws: GException on failure.
4435 	 */
4436 	extern(C) GFileInfo* function(GFile* file, GAsyncResult* res, GError** err) queryInfoFinish;
4437 	/**
4438 	 *
4439 	 * Params:
4440 	 *     file = input #GFile
4441 	 *     attributes = an attribute query string
4442 	 *     cancellable = optional #GCancellable object,
4443 	 *         %NULL to ignore
4444 	 * Return: a #GFileInfo or %NULL if there was an error.
4445 	 *     Free the returned object with g_object_unref().
4446 	 *
4447 	 * Throws: GException on failure.
4448 	 */
4449 	extern(C) GFileInfo* function(GFile* file, const(char)* attributes, GCancellable* cancellable, GError** err) queryFilesystemInfo;
4450 	extern(C) void function(GFile* file, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryFilesystemInfoAsync;
4451 	/**
4452 	 *
4453 	 * Params:
4454 	 *     file = input #GFile
4455 	 *     res = a #GAsyncResult
4456 	 * Return: #GFileInfo for given @file
4457 	 *     or %NULL on error.
4458 	 *     Free the returned object with g_object_unref().
4459 	 *
4460 	 * Throws: GException on failure.
4461 	 */
4462 	extern(C) GFileInfo* function(GFile* file, GAsyncResult* res, GError** err) queryFilesystemInfoFinish;
4463 	/**
4464 	 *
4465 	 * Params:
4466 	 *     file = input #GFile
4467 	 *     cancellable = optional #GCancellable object,
4468 	 *         %NULL to ignore
4469 	 * Return: a #GMount where the @file is located
4470 	 *     or %NULL on error.
4471 	 *     Free the returned object with g_object_unref().
4472 	 *
4473 	 * Throws: GException on failure.
4474 	 */
4475 	extern(C) GMount* function(GFile* file, GCancellable* cancellable, GError** err) findEnclosingMount;
4476 	extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) findEnclosingMountAsync;
4477 	/**
4478 	 *
4479 	 * Params:
4480 	 *     file = a #GFile
4481 	 *     res = a #GAsyncResult
4482 	 * Return: #GMount for given @file or %NULL on error.
4483 	 *     Free the returned object with g_object_unref().
4484 	 *
4485 	 * Throws: GException on failure.
4486 	 */
4487 	extern(C) GMount* function(GFile* file, GAsyncResult* res, GError** err) findEnclosingMountFinish;
4488 	/**
4489 	 *
4490 	 * Params:
4491 	 *     file = input #GFile
4492 	 *     displayName = a string
4493 	 *     cancellable = optional #GCancellable object,
4494 	 *         %NULL to ignore
4495 	 * Return: a #GFile specifying what @file was renamed to,
4496 	 *     or %NULL if there was an error.
4497 	 *     Free the returned object with g_object_unref().
4498 	 *
4499 	 * Throws: GException on failure.
4500 	 */
4501 	extern(C) GFile* function(GFile* file, const(char)* displayName, GCancellable* cancellable, GError** err) setDisplayName;
4502 	extern(C) void function(GFile* file, const(char)* displayName, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) setDisplayNameAsync;
4503 	/**
4504 	 *
4505 	 * Params:
4506 	 *     file = input #GFile
4507 	 *     res = a #GAsyncResult
4508 	 * Return: a #GFile or %NULL on error.
4509 	 *     Free the returned object with g_object_unref().
4510 	 *
4511 	 * Throws: GException on failure.
4512 	 */
4513 	extern(C) GFile* function(GFile* file, GAsyncResult* res, GError** err) setDisplayNameFinish;
4514 	/**
4515 	 *
4516 	 * Params:
4517 	 *     file = input #GFile
4518 	 *     cancellable = optional #GCancellable object,
4519 	 *         %NULL to ignore
4520 	 * Return: a #GFileAttributeInfoList describing the settable attributes.
4521 	 *     When you are done with it, release it with
4522 	 *     g_file_attribute_info_list_unref()
4523 	 *
4524 	 * Throws: GException on failure.
4525 	 */
4526 	extern(C) GFileAttributeInfoList* function(GFile* file, GCancellable* cancellable, GError** err) querySettableAttributes;
4527 	extern(C) void function() QuerySettableAttributesAsync;
4528 	extern(C) void function() QuerySettableAttributesFinish;
4529 	/**
4530 	 *
4531 	 * Params:
4532 	 *     file = input #GFile
4533 	 *     cancellable = optional #GCancellable object,
4534 	 *         %NULL to ignore
4535 	 * Return: a #GFileAttributeInfoList describing the writable namespaces.
4536 	 *     When you are done with it, release it with
4537 	 *     g_file_attribute_info_list_unref()
4538 	 *
4539 	 * Throws: GException on failure.
4540 	 */
4541 	extern(C) GFileAttributeInfoList* function(GFile* file, GCancellable* cancellable, GError** err) queryWritableNamespaces;
4542 	extern(C) void function() QueryWritableNamespacesAsync;
4543 	extern(C) void function() QueryWritableNamespacesFinish;
4544 	/**
4545 	 *
4546 	 * Params:
4547 	 *     file = input #GFile
4548 	 *     attribute = a string containing the attribute's name
4549 	 *     type = The type of the attribute
4550 	 *     valueP = a pointer to the value (or the pointer
4551 	 *         itself if the type is a pointer type)
4552 	 *     flags = a set of #GFileQueryInfoFlags
4553 	 *     cancellable = optional #GCancellable object,
4554 	 *         %NULL to ignore
4555 	 * Return: %TRUE if the attribute was set, %FALSE otherwise.
4556 	 *
4557 	 * Throws: GException on failure.
4558 	 */
4559 	extern(C) int function(GFile* file, const(char)* attribute, GFileAttributeType type, void* valueP, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) setAttribute;
4560 	/**
4561 	 *
4562 	 * Params:
4563 	 *     file = input #GFile
4564 	 *     info = a #GFileInfo
4565 	 *     flags = #GFileQueryInfoFlags
4566 	 *     cancellable = optional #GCancellable object,
4567 	 *         %NULL to ignore
4568 	 * Return: %FALSE if there was any error, %TRUE otherwise.
4569 	 *
4570 	 * Throws: GException on failure.
4571 	 */
4572 	extern(C) int function(GFile* file, GFileInfo* info, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) setAttributesFromInfo;
4573 	extern(C) void function(GFile* file, GFileInfo* info, GFileQueryInfoFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) setAttributesAsync;
4574 	/**
4575 	 *
4576 	 * Params:
4577 	 *     file = input #GFile
4578 	 *     result = a #GAsyncResult
4579 	 *     info = a #GFileInfo
4580 	 * Return: %TRUE if the attributes were set correctly, %FALSE otherwise.
4581 	 *
4582 	 * Throws: GException on failure.
4583 	 */
4584 	extern(C) int function(GFile* file, GAsyncResult* result, GFileInfo** info, GError** err) setAttributesFinish;
4585 	/**
4586 	 *
4587 	 * Params:
4588 	 *     file = #GFile to read
4589 	 *     cancellable = a #GCancellable
4590 	 * Return: #GFileInputStream or %NULL on error.
4591 	 *     Free the returned object with g_object_unref().
4592 	 *
4593 	 * Throws: GException on failure.
4594 	 */
4595 	extern(C) GFileInputStream* function(GFile* file, GCancellable* cancellable, GError** err) readFn;
4596 	extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) readAsync;
4597 	/**
4598 	 *
4599 	 * Params:
4600 	 *     file = input #GFile
4601 	 *     res = a #GAsyncResult
4602 	 * Return: a #GFileInputStream or %NULL on error.
4603 	 *     Free the returned object with g_object_unref().
4604 	 *
4605 	 * Throws: GException on failure.
4606 	 */
4607 	extern(C) GFileInputStream* function(GFile* file, GAsyncResult* res, GError** err) readFinish;
4608 	/**
4609 	 *
4610 	 * Params:
4611 	 *     file = input #GFile
4612 	 *     flags = a set of #GFileCreateFlags
4613 	 *     cancellable = optional #GCancellable object,
4614 	 *         %NULL to ignore
4615 	 * Return: a #GFileOutputStream, or %NULL on error.
4616 	 *     Free the returned object with g_object_unref().
4617 	 *
4618 	 * Throws: GException on failure.
4619 	 */
4620 	extern(C) GFileOutputStream* function(GFile* file, GFileCreateFlags flags, GCancellable* cancellable, GError** err) appendTo;
4621 	extern(C) void function(GFile* file, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) appendToAsync;
4622 	/**
4623 	 *
4624 	 * Params:
4625 	 *     file = input #GFile
4626 	 *     res = #GAsyncResult
4627 	 * Return: a valid #GFileOutputStream
4628 	 *     or %NULL on error.
4629 	 *     Free the returned object with g_object_unref().
4630 	 *
4631 	 * Throws: GException on failure.
4632 	 */
4633 	extern(C) GFileOutputStream* function(GFile* file, GAsyncResult* res, GError** err) appendToFinish;
4634 	/**
4635 	 *
4636 	 * Params:
4637 	 *     file = input #GFile
4638 	 *     flags = a set of #GFileCreateFlags
4639 	 *     cancellable = optional #GCancellable object,
4640 	 *         %NULL to ignore
4641 	 * Return: a #GFileOutputStream for the newly created
4642 	 *     file, or %NULL on error.
4643 	 *     Free the returned object with g_object_unref().
4644 	 *
4645 	 * Throws: GException on failure.
4646 	 */
4647 	extern(C) GFileOutputStream* function(GFile* file, GFileCreateFlags flags, GCancellable* cancellable, GError** err) create;
4648 	extern(C) void function(GFile* file, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) createAsync;
4649 	/**
4650 	 *
4651 	 * Params:
4652 	 *     file = input #GFile
4653 	 *     res = a #GAsyncResult
4654 	 * Return: a #GFileOutputStream or %NULL on error.
4655 	 *     Free the returned object with g_object_unref().
4656 	 *
4657 	 * Throws: GException on failure.
4658 	 */
4659 	extern(C) GFileOutputStream* function(GFile* file, GAsyncResult* res, GError** err) createFinish;
4660 	/**
4661 	 *
4662 	 * Params:
4663 	 *     file = input #GFile
4664 	 *     etag = an optional [entity tag][gfile-etag]
4665 	 *         for the current #GFile, or #NULL to ignore
4666 	 *     makeBackup = %TRUE if a backup should be created
4667 	 *     flags = a set of #GFileCreateFlags
4668 	 *     cancellable = optional #GCancellable object,
4669 	 *         %NULL to ignore
4670 	 * Return: a #GFileOutputStream or %NULL on error.
4671 	 *     Free the returned object with g_object_unref().
4672 	 *
4673 	 * Throws: GException on failure.
4674 	 */
4675 	extern(C) GFileOutputStream* function(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, GCancellable* cancellable, GError** err) replace;
4676 	extern(C) void function(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) replaceAsync;
4677 	/**
4678 	 *
4679 	 * Params:
4680 	 *     file = input #GFile
4681 	 *     res = a #GAsyncResult
4682 	 * Return: a #GFileOutputStream, or %NULL on error.
4683 	 *     Free the returned object with g_object_unref().
4684 	 *
4685 	 * Throws: GException on failure.
4686 	 */
4687 	extern(C) GFileOutputStream* function(GFile* file, GAsyncResult* res, GError** err) replaceFinish;
4688 	/**
4689 	 *
4690 	 * Params:
4691 	 *     file = input #GFile
4692 	 *     cancellable = optional #GCancellable object,
4693 	 *         %NULL to ignore
4694 	 * Return: %TRUE if the file was deleted. %FALSE otherwise.
4695 	 *
4696 	 * Throws: GException on failure.
4697 	 */
4698 	extern(C) int function(GFile* file, GCancellable* cancellable, GError** err) deleteFile;
4699 	extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) deleteFileAsync;
4700 	/**
4701 	 *
4702 	 * Params:
4703 	 *     file = input #GFile
4704 	 *     result = a #GAsyncResult
4705 	 * Return: %TRUE if the file was deleted. %FALSE otherwise.
4706 	 *
4707 	 * Throws: GException on failure.
4708 	 */
4709 	extern(C) int function(GFile* file, GAsyncResult* result, GError** err) deleteFileFinish;
4710 	/**
4711 	 *
4712 	 * Params:
4713 	 *     file = #GFile to send to trash
4714 	 *     cancellable = optional #GCancellable object,
4715 	 *         %NULL to ignore
4716 	 * Return: %TRUE on successful trash, %FALSE otherwise.
4717 	 *
4718 	 * Throws: GException on failure.
4719 	 */
4720 	extern(C) int function(GFile* file, GCancellable* cancellable, GError** err) trash;
4721 	extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) trashAsync;
4722 	/**
4723 	 *
4724 	 * Params:
4725 	 *     file = input #GFile
4726 	 *     result = a #GAsyncResult
4727 	 * Return: %TRUE on successful trash, %FALSE otherwise.
4728 	 *
4729 	 * Throws: GException on failure.
4730 	 */
4731 	extern(C) int function(GFile* file, GAsyncResult* result, GError** err) trashFinish;
4732 	/**
4733 	 *
4734 	 * Params:
4735 	 *     file = input #GFile
4736 	 *     cancellable = optional #GCancellable object,
4737 	 *         %NULL to ignore
4738 	 * Return: %TRUE on successful creation, %FALSE otherwise.
4739 	 *
4740 	 * Throws: GException on failure.
4741 	 */
4742 	extern(C) int function(GFile* file, GCancellable* cancellable, GError** err) makeDirectory;
4743 	extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) makeDirectoryAsync;
4744 	/**
4745 	 *
4746 	 * Params:
4747 	 *     file = input #GFile
4748 	 *     result = a #GAsyncResult
4749 	 * Return: %TRUE on successful directory creation, %FALSE otherwise.
4750 	 *
4751 	 * Throws: GException on failure.
4752 	 */
4753 	extern(C) int function(GFile* file, GAsyncResult* result, GError** err) makeDirectoryFinish;
4754 	/**
4755 	 *
4756 	 * Params:
4757 	 *     file = a #GFile with the name of the symlink to create
4758 	 *     symlinkValue = a string with the path for the target of the new symlink
4759 	 *     cancellable = optional #GCancellable object,
4760 	 *         %NULL to ignore
4761 	 * Return: %TRUE on the creation of a new symlink, %FALSE otherwise.
4762 	 *
4763 	 * Throws: GException on failure.
4764 	 */
4765 	extern(C) int function(GFile* file, const(char)* symlinkValue, GCancellable* cancellable, GError** err) makeSymbolicLink;
4766 	extern(C) void function() MakeSymbolicLinkAsync;
4767 	extern(C) void function() MakeSymbolicLinkFinish;
4768 	/**
4769 	 *
4770 	 * Params:
4771 	 *     source = input #GFile
4772 	 *     destination = destination #GFile
4773 	 *     flags = set of #GFileCopyFlags
4774 	 *     cancellable = optional #GCancellable object,
4775 	 *         %NULL to ignore
4776 	 *     progressCallback = function to callback with
4777 	 *         progress information, or %NULL if progress information is not needed
4778 	 *     progressCallbackData = user data to pass to @progress_callback
4779 	 * Return: %TRUE on success, %FALSE otherwise.
4780 	 *
4781 	 * Throws: GException on failure.
4782 	 */
4783 	extern(C) int function(GFile* source, GFile* destination, GFileCopyFlags flags, GCancellable* cancellable, GFileProgressCallback progressCallback, void* progressCallbackData, GError** err) copy;
4784 	extern(C) void function(GFile* source, GFile* destination, GFileCopyFlags flags, int ioPriority, GCancellable* cancellable, GFileProgressCallback progressCallback, void* progressCallbackData, GAsyncReadyCallback callback, void* userData) copyAsync;
4785 	/**
4786 	 *
4787 	 * Params:
4788 	 *     file = input #GFile
4789 	 *     res = a #GAsyncResult
4790 	 * Return: a %TRUE on success, %FALSE on error.
4791 	 *
4792 	 * Throws: GException on failure.
4793 	 */
4794 	extern(C) int function(GFile* file, GAsyncResult* res, GError** err) copyFinish;
4795 	/**
4796 	 *
4797 	 * Params:
4798 	 *     source = #GFile pointing to the source location
4799 	 *     destination = #GFile pointing to the destination location
4800 	 *     flags = set of #GFileCopyFlags
4801 	 *     cancellable = optional #GCancellable object,
4802 	 *         %NULL to ignore
4803 	 *     progressCallback = #GFileProgressCallback
4804 	 *         function for updates
4805 	 *     progressCallbackData = gpointer to user data for
4806 	 *         the callback function
4807 	 * Return: %TRUE on successful move, %FALSE otherwise.
4808 	 *
4809 	 * Throws: GException on failure.
4810 	 */
4811 	extern(C) int function(GFile* source, GFile* destination, GFileCopyFlags flags, GCancellable* cancellable, GFileProgressCallback progressCallback, void* progressCallbackData, GError** err) move;
4812 	extern(C) void function() MoveAsync;
4813 	extern(C) void function() MoveFinish;
4814 	extern(C) void function(GFile* file, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) mountMountable;
4815 	/**
4816 	 *
4817 	 * Params:
4818 	 *     file = input #GFile
4819 	 *     result = a #GAsyncResult
4820 	 * Return: a #GFile or %NULL on error.
4821 	 *     Free the returned object with g_object_unref().
4822 	 *
4823 	 * Throws: GException on failure.
4824 	 */
4825 	extern(C) GFile* function(GFile* file, GAsyncResult* result, GError** err) mountMountableFinish;
4826 	extern(C) void function(GFile* file, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) unmountMountable;
4827 	/**
4828 	 *
4829 	 * Params:
4830 	 *     file = input #GFile
4831 	 *     result = a #GAsyncResult
4832 	 * Return: %TRUE if the operation finished successfully.
4833 	 *     %FALSE otherwise.
4834 	 *
4835 	 * Throws: GException on failure.
4836 	 */
4837 	extern(C) int function(GFile* file, GAsyncResult* result, GError** err) unmountMountableFinish;
4838 	extern(C) void function(GFile* file, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectMountable;
4839 	/**
4840 	 *
4841 	 * Params:
4842 	 *     file = input #GFile
4843 	 *     result = a #GAsyncResult
4844 	 * Return: %TRUE if the @file was ejected successfully.
4845 	 *     %FALSE otherwise.
4846 	 *
4847 	 * Throws: GException on failure.
4848 	 */
4849 	extern(C) int function(GFile* file, GAsyncResult* result, GError** err) ejectMountableFinish;
4850 	extern(C) void function(GFile* location, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) mountEnclosingVolume;
4851 	/**
4852 	 *
4853 	 * Params:
4854 	 *     location = input #GFile
4855 	 *     result = a #GAsyncResult
4856 	 * Return: %TRUE if successful. If an error has occurred,
4857 	 *     this function will return %FALSE and set @error
4858 	 *     appropriately if present.
4859 	 *
4860 	 * Throws: GException on failure.
4861 	 */
4862 	extern(C) int function(GFile* location, GAsyncResult* result, GError** err) mountEnclosingVolumeFinish;
4863 	/**
4864 	 *
4865 	 * Params:
4866 	 *     file = input #GFile
4867 	 *     flags = a set of #GFileMonitorFlags
4868 	 *     cancellable = optional #GCancellable object,
4869 	 *         %NULL to ignore
4870 	 * Return: a #GFileMonitor for the given @file,
4871 	 *     or %NULL on error.
4872 	 *     Free the returned object with g_object_unref().
4873 	 *
4874 	 * Throws: GException on failure.
4875 	 */
4876 	extern(C) GFileMonitor* function(GFile* file, GFileMonitorFlags flags, GCancellable* cancellable, GError** err) monitorDir;
4877 	/**
4878 	 *
4879 	 * Params:
4880 	 *     file = input #GFile
4881 	 *     flags = a set of #GFileMonitorFlags
4882 	 *     cancellable = optional #GCancellable object,
4883 	 *         %NULL to ignore
4884 	 * Return: a #GFileMonitor for the given @file,
4885 	 *     or %NULL on error.
4886 	 *     Free the returned object with g_object_unref().
4887 	 *
4888 	 * Throws: GException on failure.
4889 	 */
4890 	extern(C) GFileMonitor* function(GFile* file, GFileMonitorFlags flags, GCancellable* cancellable, GError** err) monitorFile;
4891 	/**
4892 	 *
4893 	 * Params:
4894 	 *     file = #GFile to open
4895 	 *     cancellable = a #GCancellable
4896 	 * Return: #GFileIOStream or %NULL on error.
4897 	 *     Free the returned object with g_object_unref().
4898 	 *
4899 	 * Throws: GException on failure.
4900 	 */
4901 	extern(C) GFileIOStream* function(GFile* file, GCancellable* cancellable, GError** err) openReadwrite;
4902 	extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) openReadwriteAsync;
4903 	/**
4904 	 *
4905 	 * Params:
4906 	 *     file = input #GFile
4907 	 *     res = a #GAsyncResult
4908 	 * Return: a #GFileIOStream or %NULL on error.
4909 	 *     Free the returned object with g_object_unref().
4910 	 *
4911 	 * Throws: GException on failure.
4912 	 */
4913 	extern(C) GFileIOStream* function(GFile* file, GAsyncResult* res, GError** err) openReadwriteFinish;
4914 	/**
4915 	 *
4916 	 * Params:
4917 	 *     file = a #GFile
4918 	 *     flags = a set of #GFileCreateFlags
4919 	 *     cancellable = optional #GCancellable object,
4920 	 *         %NULL to ignore
4921 	 * Return: a #GFileIOStream for the newly created
4922 	 *     file, or %NULL on error.
4923 	 *     Free the returned object with g_object_unref().
4924 	 *
4925 	 * Throws: GException on failure.
4926 	 */
4927 	extern(C) GFileIOStream* function(GFile* file, GFileCreateFlags flags, GCancellable* cancellable, GError** err) createReadwrite;
4928 	extern(C) void function(GFile* file, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) createReadwriteAsync;
4929 	/**
4930 	 *
4931 	 * Params:
4932 	 *     file = input #GFile
4933 	 *     res = a #GAsyncResult
4934 	 * Return: a #GFileIOStream or %NULL on error.
4935 	 *     Free the returned object with g_object_unref().
4936 	 *
4937 	 * Throws: GException on failure.
4938 	 */
4939 	extern(C) GFileIOStream* function(GFile* file, GAsyncResult* res, GError** err) createReadwriteFinish;
4940 	/**
4941 	 *
4942 	 * Params:
4943 	 *     file = a #GFile
4944 	 *     etag = an optional [entity tag][gfile-etag]
4945 	 *         for the current #GFile, or #NULL to ignore
4946 	 *     makeBackup = %TRUE if a backup should be created
4947 	 *     flags = a set of #GFileCreateFlags
4948 	 *     cancellable = optional #GCancellable object,
4949 	 *         %NULL to ignore
4950 	 * Return: a #GFileIOStream or %NULL on error.
4951 	 *     Free the returned object with g_object_unref().
4952 	 *
4953 	 * Throws: GException on failure.
4954 	 */
4955 	extern(C) GFileIOStream* function(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, GCancellable* cancellable, GError** err) replaceReadwrite;
4956 	extern(C) void function(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) replaceReadwriteAsync;
4957 	/**
4958 	 *
4959 	 * Params:
4960 	 *     file = input #GFile
4961 	 *     res = a #GAsyncResult
4962 	 * Return: a #GFileIOStream, or %NULL on error.
4963 	 *     Free the returned object with g_object_unref().
4964 	 *
4965 	 * Throws: GException on failure.
4966 	 */
4967 	extern(C) GFileIOStream* function(GFile* file, GAsyncResult* res, GError** err) replaceReadwriteFinish;
4968 	extern(C) void function(GFile* file, GDriveStartFlags flags, GMountOperation* startOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) startMountable;
4969 	/**
4970 	 *
4971 	 * Params:
4972 	 *     file = input #GFile
4973 	 *     result = a #GAsyncResult
4974 	 * Return: %TRUE if the operation finished successfully. %FALSE
4975 	 *     otherwise.
4976 	 *
4977 	 * Throws: GException on failure.
4978 	 */
4979 	extern(C) int function(GFile* file, GAsyncResult* result, GError** err) startMountableFinish;
4980 	extern(C) void function(GFile* file, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) stopMountable;
4981 	/**
4982 	 *
4983 	 * Params:
4984 	 *     file = input #GFile
4985 	 *     result = a #GAsyncResult
4986 	 * Return: %TRUE if the operation finished successfully.
4987 	 *     %FALSE otherwise.
4988 	 *
4989 	 * Throws: GException on failure.
4990 	 */
4991 	extern(C) int function(GFile* file, GAsyncResult* result, GError** err) stopMountableFinish;
4992 	/**
4993 	 * a boolean that indicates whether the #GFile implementation supports thread-default contexts. Since 2.22.
4994 	 */
4995 	bool supportsThreadContexts;
4996 	extern(C) void function(GFile* file, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) unmountMountableWithOperation;
4997 	/**
4998 	 *
4999 	 * Params:
5000 	 *     file = input #GFile
5001 	 *     result = a #GAsyncResult
5002 	 * Return: %TRUE if the operation finished successfully.
5003 	 *     %FALSE otherwise.
5004 	 *
5005 	 * Throws: GException on failure.
5006 	 */
5007 	extern(C) int function(GFile* file, GAsyncResult* result, GError** err) unmountMountableWithOperationFinish;
5008 	extern(C) void function(GFile* file, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectMountableWithOperation;
5009 	/**
5010 	 *
5011 	 * Params:
5012 	 *     file = input #GFile
5013 	 *     result = a #GAsyncResult
5014 	 * Return: %TRUE if the @file was ejected successfully.
5015 	 *     %FALSE otherwise.
5016 	 *
5017 	 * Throws: GException on failure.
5018 	 */
5019 	extern(C) int function(GFile* file, GAsyncResult* result, GError** err) ejectMountableWithOperationFinish;
5020 	extern(C) void function(GFile* file, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) pollMountable;
5021 	/**
5022 	 *
5023 	 * Params:
5024 	 *     file = input #GFile
5025 	 *     result = a #GAsyncResult
5026 	 * Return: %TRUE if the operation finished successfully. %FALSE
5027 	 *     otherwise.
5028 	 *
5029 	 * Throws: GException on failure.
5030 	 */
5031 	extern(C) int function(GFile* file, GAsyncResult* result, GError** err) pollMountableFinish;
5032 	/**
5033 	 *
5034 	 * Params:
5035 	 *     file = a #GFile
5036 	 *     flags = #GFileMeasureFlags
5037 	 *     cancellable = optional #GCancellable
5038 	 *     progressCallback = a #GFileMeasureProgressCallback
5039 	 *     progressData = user_data for @progress_callback
5040 	 *     diskUsage = the number of bytes of disk space used
5041 	 *     numDirs = the number of directories encountered
5042 	 *     numFiles = the number of non-directories encountered
5043 	 * Return: %TRUE if successful, with the out parameters set.
5044 	 *     %FALSE otherwise, with @error set.
5045 	 *
5046 	 * Throws: GException on failure.
5047 	 */
5048 	extern(C) int function(GFile* file, GFileMeasureFlags flags, GCancellable* cancellable, GFileMeasureProgressCallback progressCallback, void* progressData, ulong* diskUsage, ulong* numDirs, ulong* numFiles, GError** err) measureDiskUsage;
5049 	extern(C) void function(GFile* file, GFileMeasureFlags flags, int ioPriority, GCancellable* cancellable, GFileMeasureProgressCallback progressCallback, void* progressData, GAsyncReadyCallback callback, void* userData) measureDiskUsageAsync;
5050 	/**
5051 	 *
5052 	 * Params:
5053 	 *     file = a #GFile
5054 	 *     result = the #GAsyncResult passed to your #GAsyncReadyCallback
5055 	 *     diskUsage = the number of bytes of disk space used
5056 	 *     numDirs = the number of directories encountered
5057 	 *     numFiles = the number of non-directories encountered
5058 	 * Return: %TRUE if successful, with the out parameters set.
5059 	 *     %FALSE otherwise, with @error set.
5060 	 *
5061 	 * Throws: GException on failure.
5062 	 */
5063 	extern(C) int function(GFile* file, GAsyncResult* result, ulong* diskUsage, ulong* numDirs, ulong* numFiles, GError** err) measureDiskUsageFinish;
5064 }
5065 
5066 struct GFileInfo;
5067 
5068 struct GFileInfoClass;
5069 
5070 struct GFileInputStream
5071 {
5072 	GInputStream parentInstance;
5073 	GFileInputStreamPrivate* priv;
5074 }
5075 
5076 struct GFileInputStreamClass
5077 {
5078 	GInputStreamClass parentClass;
5079 	extern(C) long function(GFileInputStream* stream) tell;
5080 	extern(C) int function(GFileInputStream* stream) canSeek;
5081 	extern(C) int function(GFileInputStream* stream, long offset, GSeekType type, GCancellable* cancellable, GError** err) seek;
5082 	/**
5083 	 *
5084 	 * Params:
5085 	 *     stream = a #GFileInputStream.
5086 	 *     attributes = a file attribute query string.
5087 	 *     cancellable = optional #GCancellable object, %NULL to ignore.
5088 	 * Return: a #GFileInfo, or %NULL on error.
5089 	 *
5090 	 * Throws: GException on failure.
5091 	 */
5092 	extern(C) GFileInfo* function(GFileInputStream* stream, const(char)* attributes, GCancellable* cancellable, GError** err) queryInfo;
5093 	extern(C) void function(GFileInputStream* stream, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryInfoAsync;
5094 	/**
5095 	 *
5096 	 * Params:
5097 	 *     stream = a #GFileInputStream.
5098 	 *     result = a #GAsyncResult.
5099 	 * Return: #GFileInfo.
5100 	 *
5101 	 * Throws: GException on failure.
5102 	 */
5103 	extern(C) GFileInfo* function(GFileInputStream* stream, GAsyncResult* result, GError** err) queryInfoFinish;
5104 	extern(C) void function() GReserved1;
5105 	extern(C) void function() GReserved2;
5106 	extern(C) void function() GReserved3;
5107 	extern(C) void function() GReserved4;
5108 	extern(C) void function() GReserved5;
5109 }
5110 
5111 struct GFileInputStreamPrivate;
5112 
5113 struct GFileMonitor
5114 {
5115 	GObject parentInstance;
5116 	GFileMonitorPrivate* priv;
5117 }
5118 
5119 struct GFileMonitorClass
5120 {
5121 	GObjectClass parentClass;
5122 	extern(C) void function(GFileMonitor* monitor, GFile* file, GFile* otherFile, GFileMonitorEvent eventType) changed;
5123 	/**
5124 	 *
5125 	 * Params:
5126 	 *     monitor = a #GFileMonitor.
5127 	 * Return: %TRUE if monitor was cancelled.
5128 	 */
5129 	extern(C) int function(GFileMonitor* monitor) cancel;
5130 	extern(C) void function() GReserved1;
5131 	extern(C) void function() GReserved2;
5132 	extern(C) void function() GReserved3;
5133 	extern(C) void function() GReserved4;
5134 	extern(C) void function() GReserved5;
5135 }
5136 
5137 struct GFileMonitorPrivate;
5138 
5139 struct GFileOutputStream
5140 {
5141 	GOutputStream parentInstance;
5142 	GFileOutputStreamPrivate* priv;
5143 }
5144 
5145 struct GFileOutputStreamClass
5146 {
5147 	GOutputStreamClass parentClass;
5148 	extern(C) long function(GFileOutputStream* stream) tell;
5149 	extern(C) int function(GFileOutputStream* stream) canSeek;
5150 	extern(C) int function(GFileOutputStream* stream, long offset, GSeekType type, GCancellable* cancellable, GError** err) seek;
5151 	extern(C) int function(GFileOutputStream* stream) canTruncate;
5152 	extern(C) int function(GFileOutputStream* stream, long size, GCancellable* cancellable, GError** err) truncateFn;
5153 	/**
5154 	 *
5155 	 * Params:
5156 	 *     stream = a #GFileOutputStream.
5157 	 *     attributes = a file attribute query string.
5158 	 *     cancellable = optional #GCancellable object, %NULL to ignore.
5159 	 * Return: a #GFileInfo for the @stream, or %NULL on error.
5160 	 *
5161 	 * Throws: GException on failure.
5162 	 */
5163 	extern(C) GFileInfo* function(GFileOutputStream* stream, const(char)* attributes, GCancellable* cancellable, GError** err) queryInfo;
5164 	extern(C) void function(GFileOutputStream* stream, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryInfoAsync;
5165 	/**
5166 	 *
5167 	 * Params:
5168 	 *     stream = a #GFileOutputStream.
5169 	 *     result = a #GAsyncResult.
5170 	 * Return: A #GFileInfo for the finished query.
5171 	 *
5172 	 * Throws: GException on failure.
5173 	 */
5174 	extern(C) GFileInfo* function(GFileOutputStream* stream, GAsyncResult* result, GError** err) queryInfoFinish;
5175 	/**
5176 	 *
5177 	 * Params:
5178 	 *     stream = a #GFileOutputStream.
5179 	 * Return: the entity tag for the stream.
5180 	 */
5181 	extern(C) char* function(GFileOutputStream* stream) getEtag;
5182 	extern(C) void function() GReserved1;
5183 	extern(C) void function() GReserved2;
5184 	extern(C) void function() GReserved3;
5185 	extern(C) void function() GReserved4;
5186 	extern(C) void function() GReserved5;
5187 }
5188 
5189 struct GFileOutputStreamPrivate;
5190 
5191 struct GFilenameCompleter;
5192 
5193 struct GFilenameCompleterClass
5194 {
5195 	GObjectClass parentClass;
5196 	extern(C) void function(GFilenameCompleter* filenameCompleter) gotCompletionData;
5197 	extern(C) void function() GReserved1;
5198 	extern(C) void function() GReserved2;
5199 	extern(C) void function() GReserved3;
5200 }
5201 
5202 struct GFilterInputStream
5203 {
5204 	GInputStream parentInstance;
5205 	GInputStream* baseStream;
5206 }
5207 
5208 struct GFilterInputStreamClass
5209 {
5210 	GInputStreamClass parentClass;
5211 	extern(C) void function() GReserved1;
5212 	extern(C) void function() GReserved2;
5213 	extern(C) void function() GReserved3;
5214 }
5215 
5216 struct GFilterOutputStream
5217 {
5218 	GOutputStream parentInstance;
5219 	GOutputStream* baseStream;
5220 }
5221 
5222 struct GFilterOutputStreamClass
5223 {
5224 	GOutputStreamClass parentClass;
5225 	extern(C) void function() GReserved1;
5226 	extern(C) void function() GReserved2;
5227 	extern(C) void function() GReserved3;
5228 }
5229 
5230 struct GIOExtension;
5231 
5232 struct GIOExtensionPoint;
5233 
5234 struct GIOModule;
5235 
5236 struct GIOModuleClass;
5237 
5238 struct GIOModuleScope;
5239 
5240 struct GIOSchedulerJob;
5241 
5242 struct GIOStream
5243 {
5244 	GObject parentInstance;
5245 	GIOStreamPrivate* priv;
5246 }
5247 
5248 struct GIOStreamAdapter;
5249 
5250 struct GIOStreamClass
5251 {
5252 	GObjectClass parentClass;
5253 	/**
5254 	 *
5255 	 * Params:
5256 	 *     stream = a #GIOStream
5257 	 * Return: a #GInputStream, owned by the #GIOStream.
5258 	 *     Do not free.
5259 	 */
5260 	extern(C) GInputStream* function(GIOStream* stream) getInputStream;
5261 	/**
5262 	 *
5263 	 * Params:
5264 	 *     stream = a #GIOStream
5265 	 * Return: a #GOutputStream, owned by the #GIOStream.
5266 	 *     Do not free.
5267 	 */
5268 	extern(C) GOutputStream* function(GIOStream* stream) getOutputStream;
5269 	extern(C) int function(GIOStream* stream, GCancellable* cancellable, GError** err) closeFn;
5270 	extern(C) void function(GIOStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) closeAsync;
5271 	/**
5272 	 *
5273 	 * Params:
5274 	 *     stream = a #GIOStream
5275 	 *     result = a #GAsyncResult
5276 	 * Return: %TRUE if stream was successfully closed, %FALSE otherwise.
5277 	 *
5278 	 * Throws: GException on failure.
5279 	 */
5280 	extern(C) int function(GIOStream* stream, GAsyncResult* result, GError** err) closeFinish;
5281 	extern(C) void function() GReserved1;
5282 	extern(C) void function() GReserved2;
5283 	extern(C) void function() GReserved3;
5284 	extern(C) void function() GReserved4;
5285 	extern(C) void function() GReserved5;
5286 	extern(C) void function() GReserved6;
5287 	extern(C) void function() GReserved7;
5288 	extern(C) void function() GReserved8;
5289 	extern(C) void function() GReserved9;
5290 	extern(C) void function() GReserved10;
5291 }
5292 
5293 struct GIOStreamPrivate;
5294 
5295 struct GIcon;
5296 
5297 /**
5298  * GIconIface is used to implement GIcon types for various
5299  * different systems. See #GThemedIcon and #GLoadableIcon for
5300  * examples of how to implement this interface.
5301  */
5302 struct GIconIface
5303 {
5304 	/**
5305 	 * The parent interface.
5306 	 */
5307 	GTypeInterface gIface;
5308 	/**
5309 	 *
5310 	 * Params:
5311 	 *     icon = #gconstpointer to an icon object.
5312 	 * Return: a #guint containing a hash for the @icon, suitable for
5313 	 *     use in a #GHashTable or similar data structure.
5314 	 */
5315 	extern(C) uint function(GIcon* icon) hash;
5316 	/**
5317 	 *
5318 	 * Params:
5319 	 *     icon1 = pointer to the first #GIcon.
5320 	 *     icon2 = pointer to the second #GIcon.
5321 	 * Return: %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
5322 	 */
5323 	extern(C) int function(GIcon* icon1, GIcon* icon2) equal;
5324 	/**
5325 	 *
5326 	 * Params:
5327 	 *     icon = a #GIcon.
5328 	 * Return: An allocated NUL-terminated UTF8 string or
5329 	 *     %NULL if @icon can't be serialized. Use g_free() to free.
5330 	 */
5331 	extern(C) int function(GIcon* icon, GPtrArray* tokens, int* outVersion) toTokens;
5332 	extern(C) GIcon* function(char** tokens, int numTokens, int versio, GError** err) fromTokens;
5333 	/**
5334 	 *
5335 	 * Params:
5336 	 *     icon = a #GIcon
5337 	 * Return: a #GVariant, or %NULL when serialization fails.
5338 	 */
5339 	extern(C) GVariant* function(GIcon* icon) serialize;
5340 }
5341 
5342 struct GInetAddress
5343 {
5344 	GObject parentInstance;
5345 	GInetAddressPrivate* priv;
5346 }
5347 
5348 struct GInetAddressClass
5349 {
5350 	GObjectClass parentClass;
5351 	/**
5352 	 *
5353 	 * Params:
5354 	 *     address = a #GInetAddress
5355 	 * Return: a representation of @address as a string, which should be
5356 	 *     freed after use.
5357 	 */
5358 	extern(C) char* function(GInetAddress* address) toString;
5359 	/**
5360 	 *
5361 	 * Params:
5362 	 *     address = a #GInetAddress
5363 	 * Return: a pointer to an internal array of the bytes in @address,
5364 	 *     which should not be modified, stored, or freed. The size of this
5365 	 *     array can be gotten with g_inet_address_get_native_size().
5366 	 */
5367 	extern(C) ubyte* function(GInetAddress* address) toBytes;
5368 }
5369 
5370 struct GInetAddressMask
5371 {
5372 	GObject parentInstance;
5373 	GInetAddressMaskPrivate* priv;
5374 }
5375 
5376 struct GInetAddressMaskClass
5377 {
5378 	GObjectClass parentClass;
5379 }
5380 
5381 struct GInetAddressMaskPrivate;
5382 
5383 struct GInetAddressPrivate;
5384 
5385 struct GInetSocketAddress
5386 {
5387 	GSocketAddress parentInstance;
5388 	GInetSocketAddressPrivate* priv;
5389 }
5390 
5391 struct GInetSocketAddressClass
5392 {
5393 	GSocketAddressClass parentClass;
5394 }
5395 
5396 struct GInetSocketAddressPrivate;
5397 
5398 struct GInitable;
5399 
5400 /**
5401  * Provides an interface for initializing object such that initialization
5402  * may fail.
5403  *
5404  * Since: 2.22
5405  */
5406 struct GInitableIface
5407 {
5408 	/**
5409 	 * The parent interface.
5410 	 */
5411 	GTypeInterface gIface;
5412 	/**
5413 	 *
5414 	 * Params:
5415 	 *     initable = a #GInitable.
5416 	 *     cancellable = optional #GCancellable object, %NULL to ignore.
5417 	 * Return: %TRUE if successful. If an error has occurred, this function will
5418 	 *     return %FALSE and set @error appropriately if present.
5419 	 *
5420 	 * Throws: GException on failure.
5421 	 */
5422 	extern(C) int function(GInitable* initable, GCancellable* cancellable, GError** err) init;
5423 }
5424 
5425 struct GInputStream
5426 {
5427 	GObject parentInstance;
5428 	GInputStreamPrivate* priv;
5429 }
5430 
5431 struct GInputStreamClass
5432 {
5433 	GObjectClass parentClass;
5434 	extern(C) ptrdiff_t function(GInputStream* stream, void* buffer, size_t count, GCancellable* cancellable, GError** err) readFn;
5435 	/**
5436 	 *
5437 	 * Params:
5438 	 *     stream = a #GInputStream.
5439 	 *     count = the number of bytes that will be skipped from the stream
5440 	 *     cancellable = optional #GCancellable object, %NULL to ignore.
5441 	 * Return: Number of bytes skipped, or -1 on error
5442 	 *
5443 	 * Throws: GException on failure.
5444 	 */
5445 	extern(C) ptrdiff_t function(GInputStream* stream, size_t count, GCancellable* cancellable, GError** err) skip;
5446 	extern(C) int function(GInputStream* stream, GCancellable* cancellable, GError** err) closeFn;
5447 	extern(C) void function(GInputStream* stream, void* buffer, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) readAsync;
5448 	/**
5449 	 *
5450 	 * Params:
5451 	 *     stream = a #GInputStream.
5452 	 *     result = a #GAsyncResult.
5453 	 * Return: number of bytes read in, or -1 on error, or 0 on end of file.
5454 	 *
5455 	 * Throws: GException on failure.
5456 	 */
5457 	extern(C) ptrdiff_t function(GInputStream* stream, GAsyncResult* result, GError** err) readFinish;
5458 	extern(C) void function(GInputStream* stream, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) skipAsync;
5459 	/**
5460 	 *
5461 	 * Params:
5462 	 *     stream = a #GInputStream.
5463 	 *     result = a #GAsyncResult.
5464 	 * Return: the size of the bytes skipped, or %-1 on error.
5465 	 *
5466 	 * Throws: GException on failure.
5467 	 */
5468 	extern(C) ptrdiff_t function(GInputStream* stream, GAsyncResult* result, GError** err) skipFinish;
5469 	extern(C) void function(GInputStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) closeAsync;
5470 	/**
5471 	 *
5472 	 * Params:
5473 	 *     stream = a #GInputStream.
5474 	 *     result = a #GAsyncResult.
5475 	 * Return: %TRUE if the stream was closed successfully.
5476 	 *
5477 	 * Throws: GException on failure.
5478 	 */
5479 	extern(C) int function(GInputStream* stream, GAsyncResult* result, GError** err) closeFinish;
5480 	extern(C) void function() GReserved1;
5481 	extern(C) void function() GReserved2;
5482 	extern(C) void function() GReserved3;
5483 	extern(C) void function() GReserved4;
5484 	extern(C) void function() GReserved5;
5485 }
5486 
5487 struct GInputStreamPrivate;
5488 
5489 /**
5490  * Structure used for scatter/gather data input.
5491  * You generally pass in an array of #GInputVectors
5492  * and the operation will store the read data starting in the
5493  * first buffer, switching to the next as needed.
5494  *
5495  * Since: 2.22
5496  */
5497 struct GInputVector
5498 {
5499 	/**
5500 	 * Pointer to a buffer where data will be written.
5501 	 */
5502 	void* buffer;
5503 	/**
5504 	 * the available size in @buffer.
5505 	 */
5506 	size_t size;
5507 }
5508 
5509 struct GLoadableIcon;
5510 
5511 /**
5512  * Interface for icons that can be loaded as a stream.
5513  */
5514 struct GLoadableIconIface
5515 {
5516 	/**
5517 	 * The parent interface.
5518 	 */
5519 	GTypeInterface gIface;
5520 	/**
5521 	 *
5522 	 * Params:
5523 	 *     icon = a #GLoadableIcon.
5524 	 *     size = an integer.
5525 	 *     type = a location to store the type of the loaded
5526 	 *         icon, %NULL to ignore.
5527 	 *     cancellable = optional #GCancellable object, %NULL to
5528 	 *         ignore.
5529 	 * Return: a #GInputStream to read the icon from.
5530 	 *
5531 	 * Throws: GException on failure.
5532 	 */
5533 	extern(C) GInputStream* function(GLoadableIcon* icon, int size, char** type, GCancellable* cancellable, GError** err) load;
5534 	extern(C) void function(GLoadableIcon* icon, int size, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) loadAsync;
5535 	/**
5536 	 *
5537 	 * Params:
5538 	 *     icon = a #GLoadableIcon.
5539 	 *     res = a #GAsyncResult.
5540 	 *     type = a location to store the type of the loaded
5541 	 *         icon, %NULL to ignore.
5542 	 * Return: a #GInputStream to read the icon from.
5543 	 *
5544 	 * Throws: GException on failure.
5545 	 */
5546 	extern(C) GInputStream* function(GLoadableIcon* icon, GAsyncResult* res, char** type, GError** err) loadFinish;
5547 }
5548 
5549 struct GMemoryInputStream
5550 {
5551 	GInputStream parentInstance;
5552 	GMemoryInputStreamPrivate* priv;
5553 }
5554 
5555 struct GMemoryInputStreamClass
5556 {
5557 	GInputStreamClass parentClass;
5558 	extern(C) void function() GReserved1;
5559 	extern(C) void function() GReserved2;
5560 	extern(C) void function() GReserved3;
5561 	extern(C) void function() GReserved4;
5562 	extern(C) void function() GReserved5;
5563 }
5564 
5565 struct GMemoryInputStreamPrivate;
5566 
5567 struct GMemoryOutputStream
5568 {
5569 	GOutputStream parentInstance;
5570 	GMemoryOutputStreamPrivate* priv;
5571 }
5572 
5573 struct GMemoryOutputStreamClass
5574 {
5575 	GOutputStreamClass parentClass;
5576 	extern(C) void function() GReserved1;
5577 	extern(C) void function() GReserved2;
5578 	extern(C) void function() GReserved3;
5579 	extern(C) void function() GReserved4;
5580 	extern(C) void function() GReserved5;
5581 }
5582 
5583 struct GMemoryOutputStreamPrivate;
5584 
5585 struct GMenu;
5586 
5587 struct GMenuAttributeIter
5588 {
5589 	GObject parentInstance;
5590 	GMenuAttributeIterPrivate* priv;
5591 }
5592 
5593 struct GMenuAttributeIterClass
5594 {
5595 	GObjectClass parentClass;
5596 	/**
5597 	 *
5598 	 * Params:
5599 	 *     iter = a #GMenuAttributeIter
5600 	 *     outName = the type of the attribute
5601 	 *     value = the attribute value
5602 	 * Return: %TRUE on success, or %FALSE if there is no additional
5603 	 *     attribute
5604 	 */
5605 	extern(C) int function(GMenuAttributeIter* iter, char** outName, GVariant** value) getNext;
5606 }
5607 
5608 struct GMenuAttributeIterPrivate;
5609 
5610 struct GMenuItem;
5611 
5612 struct GMenuLinkIter
5613 {
5614 	GObject parentInstance;
5615 	GMenuLinkIterPrivate* priv;
5616 }
5617 
5618 struct GMenuLinkIterClass
5619 {
5620 	GObjectClass parentClass;
5621 	/**
5622 	 *
5623 	 * Params:
5624 	 *     iter = a #GMenuLinkIter
5625 	 *     outLink = the name of the link
5626 	 *     value = the linked #GMenuModel
5627 	 * Return: %TRUE on success, or %FALSE if there is no additional link
5628 	 */
5629 	extern(C) int function(GMenuLinkIter* iter, char** outLink, GMenuModel** value) getNext;
5630 }
5631 
5632 struct GMenuLinkIterPrivate;
5633 
5634 struct GMenuModel
5635 {
5636 	GObject parentInstance;
5637 	GMenuModelPrivate* priv;
5638 }
5639 
5640 struct GMenuModelClass
5641 {
5642 	GObjectClass parentClass;
5643 	/**
5644 	 *
5645 	 * Params:
5646 	 *     model = a #GMenuModel
5647 	 * Return: %TRUE if the model is mutable (ie: "items-changed" may be
5648 	 *     emitted).
5649 	 */
5650 	extern(C) int function(GMenuModel* model) isMutable;
5651 	/**
5652 	 *
5653 	 * Params:
5654 	 *     model = a #GMenuModel
5655 	 * Return: the number of items
5656 	 */
5657 	extern(C) int function(GMenuModel* model) getNItems;
5658 	extern(C) void function(GMenuModel* model, int itemIndex, GHashTable** attributes) getItemAttributes;
5659 	/**
5660 	 *
5661 	 * Params:
5662 	 *     model = a #GMenuModel
5663 	 *     itemIndex = the index of the item
5664 	 * Return: a new #GMenuAttributeIter
5665 	 */
5666 	extern(C) GMenuAttributeIter* function(GMenuModel* model, int itemIndex) iterateItemAttributes;
5667 	/**
5668 	 *
5669 	 * Params:
5670 	 *     model = a #GMenuModel
5671 	 *     itemIndex = the index of the item
5672 	 *     attribute = the attribute to query
5673 	 *     expectedType = the expected type of the attribute, or
5674 	 *         %NULL
5675 	 * Return: the value of the attribute
5676 	 */
5677 	extern(C) GVariant* function(GMenuModel* model, int itemIndex, const(char)* attribute, GVariantType* expectedType) getItemAttributeValue;
5678 	extern(C) void function(GMenuModel* model, int itemIndex, GHashTable** links) getItemLinks;
5679 	/**
5680 	 *
5681 	 * Params:
5682 	 *     model = a #GMenuModel
5683 	 *     itemIndex = the index of the item
5684 	 * Return: a new #GMenuLinkIter
5685 	 */
5686 	extern(C) GMenuLinkIter* function(GMenuModel* model, int itemIndex) iterateItemLinks;
5687 	/**
5688 	 *
5689 	 * Params:
5690 	 *     model = a #GMenuModel
5691 	 *     itemIndex = the index of the item
5692 	 *     link = the link to query
5693 	 * Return: the linked #GMenuModel, or %NULL
5694 	 */
5695 	extern(C) GMenuModel* function(GMenuModel* model, int itemIndex, const(char)* link) getItemLink;
5696 }
5697 
5698 struct GMenuModelPrivate;
5699 
5700 struct GMount;
5701 
5702 /**
5703  * Interface for implementing operations for mounts.
5704  */
5705 struct GMountIface
5706 {
5707 	/**
5708 	 * The parent interface.
5709 	 */
5710 	GTypeInterface gIface;
5711 	extern(C) void function(GMount* mount) changed;
5712 	extern(C) void function(GMount* mount) unmounted;
5713 	/**
5714 	 *
5715 	 * Params:
5716 	 *     mount = a #GMount.
5717 	 * Return: a #GFile.
5718 	 *     The returned object should be unreffed with
5719 	 *     g_object_unref() when no longer needed.
5720 	 */
5721 	extern(C) GFile* function(GMount* mount) getRoot;
5722 	/**
5723 	 *
5724 	 * Params:
5725 	 *     mount = a #GMount.
5726 	 * Return: the name for the given @mount.
5727 	 *     The returned string should be freed with g_free()
5728 	 *     when no longer needed.
5729 	 */
5730 	extern(C) char* function(GMount* mount) getName;
5731 	/**
5732 	 *
5733 	 * Params:
5734 	 *     mount = a #GMount.
5735 	 * Return: a #GIcon.
5736 	 *     The returned object should be unreffed with
5737 	 *     g_object_unref() when no longer needed.
5738 	 */
5739 	extern(C) GIcon* function(GMount* mount) getIcon;
5740 	/**
5741 	 *
5742 	 * Params:
5743 	 *     mount = a #GMount.
5744 	 * Return: the UUID for @mount or %NULL if no UUID can be computed.
5745 	 *     The returned string should be freed with g_free()
5746 	 *     when no longer needed.
5747 	 */
5748 	extern(C) char* function(GMount* mount) getUuid;
5749 	/**
5750 	 *
5751 	 * Params:
5752 	 *     mount = a #GMount.
5753 	 * Return: a #GVolume or %NULL if @mount is not associated with a volume.
5754 	 *     The returned object should be unreffed with
5755 	 *     g_object_unref() when no longer needed.
5756 	 */
5757 	extern(C) GVolume* function(GMount* mount) getVolume;
5758 	/**
5759 	 *
5760 	 * Params:
5761 	 *     mount = a #GMount.
5762 	 * Return: a #GDrive or %NULL if @mount is not associated with a volume or a drive.
5763 	 *     The returned object should be unreffed with
5764 	 *     g_object_unref() when no longer needed.
5765 	 */
5766 	extern(C) GDrive* function(GMount* mount) getDrive;
5767 	/**
5768 	 *
5769 	 * Params:
5770 	 *     mount = a #GMount.
5771 	 * Return: %TRUE if the @mount can be unmounted.
5772 	 */
5773 	extern(C) int function(GMount* mount) canUnmount;
5774 	/**
5775 	 *
5776 	 * Params:
5777 	 *     mount = a #GMount.
5778 	 * Return: %TRUE if the @mount can be ejected.
5779 	 */
5780 	extern(C) int function(GMount* mount) canEject;
5781 	extern(C) void function(GMount* mount, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) unmount;
5782 	/**
5783 	 *
5784 	 * Params:
5785 	 *     mount = a #GMount.
5786 	 *     result = a #GAsyncResult.
5787 	 * Return: %TRUE if the mount was successfully unmounted. %FALSE otherwise.
5788 	 *
5789 	 * Throws: GException on failure.
5790 	 */
5791 	extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) unmountFinish;
5792 	extern(C) void function(GMount* mount, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) eject;
5793 	/**
5794 	 *
5795 	 * Params:
5796 	 *     mount = a #GMount.
5797 	 *     result = a #GAsyncResult.
5798 	 * Return: %TRUE if the mount was successfully ejected. %FALSE otherwise.
5799 	 *
5800 	 * Throws: GException on failure.
5801 	 */
5802 	extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) ejectFinish;
5803 	extern(C) void function(GMount* mount, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) remount;
5804 	/**
5805 	 *
5806 	 * Params:
5807 	 *     mount = a #GMount.
5808 	 *     result = a #GAsyncResult.
5809 	 * Return: %TRUE if the mount was successfully remounted. %FALSE otherwise.
5810 	 *
5811 	 * Throws: GException on failure.
5812 	 */
5813 	extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) remountFinish;
5814 	extern(C) void function(GMount* mount, int forceRescan, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) guessContentType;
5815 	/**
5816 	 *
5817 	 * Params:
5818 	 *     mount = a #GMount
5819 	 *     result = a #GAsyncResult
5820 	 * Return: a %NULL-terminated array of content types or %NULL on error.
5821 	 *     Caller should free this array with g_strfreev() when done with it.
5822 	 *
5823 	 * Throws: GException on failure.
5824 	 */
5825 	extern(C) char** function(GMount* mount, GAsyncResult* result, GError** err) guessContentTypeFinish;
5826 	/**
5827 	 *
5828 	 * Params:
5829 	 *     mount = a #GMount
5830 	 *     forceRescan = Whether to force a rescan of the content.
5831 	 *         Otherwise a cached result will be used if available
5832 	 *     cancellable = optional #GCancellable object, %NULL to ignore
5833 	 * Return: a %NULL-terminated array of content types or %NULL on error.
5834 	 *     Caller should free this array with g_strfreev() when done with it.
5835 	 *
5836 	 * Throws: GException on failure.
5837 	 */
5838 	extern(C) char** function(GMount* mount, int forceRescan, GCancellable* cancellable, GError** err) guessContentTypeSync;
5839 	extern(C) void function(GMount* mount) preUnmount;
5840 	extern(C) void function(GMount* mount, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) unmountWithOperation;
5841 	/**
5842 	 *
5843 	 * Params:
5844 	 *     mount = a #GMount.
5845 	 *     result = a #GAsyncResult.
5846 	 * Return: %TRUE if the mount was successfully unmounted. %FALSE otherwise.
5847 	 *
5848 	 * Throws: GException on failure.
5849 	 */
5850 	extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) unmountWithOperationFinish;
5851 	extern(C) void function(GMount* mount, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectWithOperation;
5852 	/**
5853 	 *
5854 	 * Params:
5855 	 *     mount = a #GMount.
5856 	 *     result = a #GAsyncResult.
5857 	 * Return: %TRUE if the mount was successfully ejected. %FALSE otherwise.
5858 	 *
5859 	 * Throws: GException on failure.
5860 	 */
5861 	extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) ejectWithOperationFinish;
5862 	/**
5863 	 *
5864 	 * Params:
5865 	 *     mount = a #GMount.
5866 	 * Return: a #GFile.
5867 	 *     The returned object should be unreffed with
5868 	 *     g_object_unref() when no longer needed.
5869 	 */
5870 	extern(C) GFile* function(GMount* mount) getDefaultLocation;
5871 	/**
5872 	 *
5873 	 * Params:
5874 	 *     mount = A #GMount.
5875 	 * Return: Sorting key for @mount or %NULL if no such key is available.
5876 	 */
5877 	extern(C) const(char)* function(GMount* mount) getSortKey;
5878 	/**
5879 	 *
5880 	 * Params:
5881 	 *     mount = a #GMount.
5882 	 * Return: a #GIcon.
5883 	 *     The returned object should be unreffed with
5884 	 *     g_object_unref() when no longer needed.
5885 	 */
5886 	extern(C) GIcon* function(GMount* mount) getSymbolicIcon;
5887 }
5888 
5889 struct GMountOperation
5890 {
5891 	GObject parentInstance;
5892 	GMountOperationPrivate* priv;
5893 }
5894 
5895 struct GMountOperationClass
5896 {
5897 	GObjectClass parentClass;
5898 	extern(C) void function(GMountOperation* op, const(char)* message, const(char)* defaultUser, const(char)* defaultDomain, GAskPasswordFlags flags) askPassword;
5899 	extern(C) void function(GMountOperation* op, const(char)* message, const(char)* choices) askQuestion;
5900 	extern(C) void function(GMountOperation* op, GMountOperationResult result) reply;
5901 	extern(C) void function(GMountOperation* op) aborted;
5902 	extern(C) void function(GMountOperation* op, const(char)* message, GArray* processes, const(char)* choices) showProcesses;
5903 	extern(C) void function(GMountOperation* op, const(char)* message, long timeLeft, long bytesLeft) showUnmountProgress;
5904 	extern(C) void function() GReserved1;
5905 	extern(C) void function() GReserved2;
5906 	extern(C) void function() GReserved3;
5907 	extern(C) void function() GReserved4;
5908 	extern(C) void function() GReserved5;
5909 	extern(C) void function() GReserved6;
5910 	extern(C) void function() GReserved7;
5911 	extern(C) void function() GReserved8;
5912 	extern(C) void function() GReserved9;
5913 }
5914 
5915 struct GMountOperationPrivate;
5916 
5917 struct GNativeVolumeMonitor
5918 {
5919 	GVolumeMonitor parentInstance;
5920 }
5921 
5922 struct GNativeVolumeMonitorClass
5923 {
5924 	GVolumeMonitorClass parentClass;
5925 	extern(C) GMount* function(const(char)* mountPath, GCancellable* cancellable) getMountForMountPath;
5926 }
5927 
5928 struct GNetworkAddress
5929 {
5930 	GObject parentInstance;
5931 	GNetworkAddressPrivate* priv;
5932 }
5933 
5934 struct GNetworkAddressClass
5935 {
5936 	GObjectClass parentClass;
5937 }
5938 
5939 struct GNetworkAddressPrivate;
5940 
5941 struct GNetworkMonitor;
5942 
5943 struct GNetworkMonitorInterface
5944 {
5945 	GTypeInterface gIface;
5946 	extern(C) void function(GNetworkMonitor* monitor, int available) networkChanged;
5947 	/**
5948 	 *
5949 	 * Params:
5950 	 *     monitor = a #GNetworkMonitor
5951 	 *     connectable = a #GSocketConnectable
5952 	 *     cancellable = a #GCancellable, or %NULL
5953 	 * Return: %TRUE if @connectable is reachable, %FALSE if not.
5954 	 *
5955 	 * Throws: GException on failure.
5956 	 */
5957 	extern(C) int function(GNetworkMonitor* monitor, GSocketConnectable* connectable, GCancellable* cancellable, GError** err) canReach;
5958 	extern(C) void function(GNetworkMonitor* monitor, GSocketConnectable* connectable, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) canReachAsync;
5959 	/**
5960 	 *
5961 	 * Params:
5962 	 *     monitor = a #GNetworkMonitor
5963 	 *     result = a #GAsyncResult
5964 	 * Return: %TRUE if network is reachable, %FALSE if not.
5965 	 *
5966 	 * Throws: GException on failure.
5967 	 */
5968 	extern(C) int function(GNetworkMonitor* monitor, GAsyncResult* result, GError** err) canReachFinish;
5969 }
5970 
5971 struct GNetworkService
5972 {
5973 	GObject parentInstance;
5974 	GNetworkServicePrivate* priv;
5975 }
5976 
5977 struct GNetworkServiceClass
5978 {
5979 	GObjectClass parentClass;
5980 }
5981 
5982 struct GNetworkServicePrivate;
5983 
5984 struct GNotification;
5985 
5986 struct GOutputStream
5987 {
5988 	GObject parentInstance;
5989 	GOutputStreamPrivate* priv;
5990 }
5991 
5992 struct GOutputStreamClass
5993 {
5994 	GObjectClass parentClass;
5995 	/**
5996 	 *
5997 	 * Params:
5998 	 *     stream = a #GOutputStream.
5999 	 *     buffer = the buffer containing the data to write.
6000 	 *     count = the number of bytes to write
6001 	 *     cancellable = optional cancellable object
6002 	 * Return: Number of bytes written, or -1 on error
6003 	 *
6004 	 * Throws: GException on failure.
6005 	 */
6006 	extern(C) ptrdiff_t function(GOutputStream* stream, void* buffer, size_t count, GCancellable* cancellable, GError** err) writeFn;
6007 	/**
6008 	 *
6009 	 * Params:
6010 	 *     stream = a #GOutputStream.
6011 	 *     source = a #GInputStream.
6012 	 *     flags = a set of #GOutputStreamSpliceFlags.
6013 	 *     cancellable = optional #GCancellable object, %NULL to ignore.
6014 	 * Return: a #gssize containing the size of the data spliced, or
6015 	 *     -1 if an error occurred. Note that if the number of bytes
6016 	 *     spliced is greater than %G_MAXSSIZE, then that will be
6017 	 *     returned, and there is no way to determine the actual number
6018 	 *     of bytes spliced.
6019 	 *
6020 	 * Throws: GException on failure.
6021 	 */
6022 	extern(C) ptrdiff_t function(GOutputStream* stream, GInputStream* source, GOutputStreamSpliceFlags flags, GCancellable* cancellable, GError** err) splice;
6023 	/**
6024 	 *
6025 	 * Params:
6026 	 *     stream = a #GOutputStream.
6027 	 *     cancellable = optional cancellable object
6028 	 * Return: %TRUE on success, %FALSE on error
6029 	 *
6030 	 * Throws: GException on failure.
6031 	 */
6032 	extern(C) int function(GOutputStream* stream, GCancellable* cancellable, GError** err) flush;
6033 	extern(C) int function(GOutputStream* stream, GCancellable* cancellable, GError** err) closeFn;
6034 	extern(C) void function(GOutputStream* stream, void* buffer, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) writeAsync;
6035 	/**
6036 	 *
6037 	 * Params:
6038 	 *     stream = a #GOutputStream.
6039 	 *     result = a #GAsyncResult.
6040 	 * Return: a #gssize containing the number of bytes written to the stream.
6041 	 *
6042 	 * Throws: GException on failure.
6043 	 */
6044 	extern(C) ptrdiff_t function(GOutputStream* stream, GAsyncResult* result, GError** err) writeFinish;
6045 	extern(C) void function(GOutputStream* stream, GInputStream* source, GOutputStreamSpliceFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) spliceAsync;
6046 	/**
6047 	 *
6048 	 * Params:
6049 	 *     stream = a #GOutputStream.
6050 	 *     result = a #GAsyncResult.
6051 	 * Return: a #gssize of the number of bytes spliced. Note that if the
6052 	 *     number of bytes spliced is greater than %G_MAXSSIZE, then that
6053 	 *     will be returned, and there is no way to determine the actual
6054 	 *     number of bytes spliced.
6055 	 *
6056 	 * Throws: GException on failure.
6057 	 */
6058 	extern(C) ptrdiff_t function(GOutputStream* stream, GAsyncResult* result, GError** err) spliceFinish;
6059 	extern(C) void function(GOutputStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) flushAsync;
6060 	/**
6061 	 *
6062 	 * Params:
6063 	 *     stream = a #GOutputStream.
6064 	 *     result = a GAsyncResult.
6065 	 * Return: %TRUE if flush operation succeeded, %FALSE otherwise.
6066 	 *
6067 	 * Throws: GException on failure.
6068 	 */
6069 	extern(C) int function(GOutputStream* stream, GAsyncResult* result, GError** err) flushFinish;
6070 	extern(C) void function(GOutputStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) closeAsync;
6071 	/**
6072 	 *
6073 	 * Params:
6074 	 *     stream = a #GOutputStream.
6075 	 *     result = a #GAsyncResult.
6076 	 * Return: %TRUE if stream was successfully closed, %FALSE otherwise.
6077 	 *
6078 	 * Throws: GException on failure.
6079 	 */
6080 	extern(C) int function(GOutputStream* stream, GAsyncResult* result, GError** err) closeFinish;
6081 	extern(C) void function() GReserved1;
6082 	extern(C) void function() GReserved2;
6083 	extern(C) void function() GReserved3;
6084 	extern(C) void function() GReserved4;
6085 	extern(C) void function() GReserved5;
6086 	extern(C) void function() GReserved6;
6087 	extern(C) void function() GReserved7;
6088 	extern(C) void function() GReserved8;
6089 }
6090 
6091 struct GOutputStreamPrivate;
6092 
6093 /**
6094  * Structure used for scatter/gather data output.
6095  * You generally pass in an array of #GOutputVectors
6096  * and the operation will use all the buffers as if they were
6097  * one buffer.
6098  *
6099  * Since: 2.22
6100  */
6101 struct GOutputVector
6102 {
6103 	/**
6104 	 * Pointer to a buffer of data to read.
6105 	 */
6106 	void* buffer;
6107 	/**
6108 	 * the size of @buffer.
6109 	 */
6110 	size_t size;
6111 }
6112 
6113 struct GPermission
6114 {
6115 	GObject parentInstance;
6116 	GPermissionPrivate* priv;
6117 }
6118 
6119 struct GPermissionClass
6120 {
6121 	GObjectClass parentClass;
6122 	/**
6123 	 *
6124 	 * Params:
6125 	 *     permission = a #GPermission instance
6126 	 *     cancellable = a #GCancellable, or %NULL
6127 	 * Return: %TRUE if the permission was successfully acquired
6128 	 *
6129 	 * Throws: GException on failure.
6130 	 */
6131 	extern(C) int function(GPermission* permission, GCancellable* cancellable, GError** err) acquire;
6132 	extern(C) void function(GPermission* permission, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) acquireAsync;
6133 	/**
6134 	 *
6135 	 * Params:
6136 	 *     permission = a #GPermission instance
6137 	 *     result = the #GAsyncResult given to the #GAsyncReadyCallback
6138 	 * Return: %TRUE if the permission was successfully acquired
6139 	 *
6140 	 * Throws: GException on failure.
6141 	 */
6142 	extern(C) int function(GPermission* permission, GAsyncResult* result, GError** err) acquireFinish;
6143 	/**
6144 	 *
6145 	 * Params:
6146 	 *     permission = a #GPermission instance
6147 	 *     cancellable = a #GCancellable, or %NULL
6148 	 * Return: %TRUE if the permission was successfully released
6149 	 *
6150 	 * Throws: GException on failure.
6151 	 */
6152 	extern(C) int function(GPermission* permission, GCancellable* cancellable, GError** err) release;
6153 	extern(C) void function(GPermission* permission, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) releaseAsync;
6154 	/**
6155 	 *
6156 	 * Params:
6157 	 *     permission = a #GPermission instance
6158 	 *     result = the #GAsyncResult given to the #GAsyncReadyCallback
6159 	 * Return: %TRUE if the permission was successfully released
6160 	 *
6161 	 * Throws: GException on failure.
6162 	 */
6163 	extern(C) int function(GPermission* permission, GAsyncResult* result, GError** err) releaseFinish;
6164 	void*[16] reserved;
6165 }
6166 
6167 struct GPermissionPrivate;
6168 
6169 struct GPollableInputStream;
6170 
6171 /**
6172  * The interface for pollable input streams.
6173  *
6174  * The default implementation of @can_poll always returns %TRUE.
6175  *
6176  * The default implementation of @read_nonblocking calls
6177  * g_pollable_input_stream_is_readable(), and then calls
6178  * g_input_stream_read() if it returns %TRUE. This means you only need
6179  * to override it if it is possible that your @is_readable
6180  * implementation may return %TRUE when the stream is not actually
6181  * readable.
6182  *
6183  * Since: 2.28
6184  */
6185 struct GPollableInputStreamInterface
6186 {
6187 	/**
6188 	 * The parent interface.
6189 	 */
6190 	GTypeInterface gIface;
6191 	/**
6192 	 *
6193 	 * Params:
6194 	 *     stream = a #GPollableInputStream.
6195 	 * Return: %TRUE if @stream is pollable, %FALSE if not.
6196 	 */
6197 	extern(C) int function(GPollableInputStream* stream) canPoll;
6198 	/**
6199 	 *
6200 	 * Params:
6201 	 *     stream = a #GPollableInputStream.
6202 	 * Return: %TRUE if @stream is readable, %FALSE if not. If an error
6203 	 *     has occurred on @stream, this will result in
6204 	 *     g_pollable_input_stream_is_readable() returning %TRUE, and the
6205 	 *     next attempt to read will return the error.
6206 	 */
6207 	extern(C) int function(GPollableInputStream* stream) isReadable;
6208 	/**
6209 	 *
6210 	 * Params:
6211 	 *     stream = a #GPollableInputStream.
6212 	 *     cancellable = a #GCancellable, or %NULL
6213 	 * Return: a new #GSource
6214 	 */
6215 	extern(C) GSource* function(GPollableInputStream* stream, GCancellable* cancellable) createSource;
6216 	/**
6217 	 *
6218 	 * Params:
6219 	 *     stream = a #GPollableInputStream
6220 	 *     buffer = a buffer to
6221 	 *         read data into (which should be at least @count bytes long).
6222 	 *     count = the number of bytes you want to read
6223 	 * Return: the number of bytes read, or -1 on error (including
6224 	 *     %G_IO_ERROR_WOULD_BLOCK).
6225 	 *
6226 	 * Throws: GException on failure.
6227 	 */
6228 	extern(C) ptrdiff_t function(GPollableInputStream* stream, void* buffer, size_t count, GError** err) readNonblocking;
6229 }
6230 
6231 struct GPollableOutputStream;
6232 
6233 /**
6234  * The interface for pollable output streams.
6235  *
6236  * The default implementation of @can_poll always returns %TRUE.
6237  *
6238  * The default implementation of @write_nonblocking calls
6239  * g_pollable_output_stream_is_writable(), and then calls
6240  * g_output_stream_write() if it returns %TRUE. This means you only
6241  * need to override it if it is possible that your @is_writable
6242  * implementation may return %TRUE when the stream is not actually
6243  * writable.
6244  *
6245  * Since: 2.28
6246  */
6247 struct GPollableOutputStreamInterface
6248 {
6249 	/**
6250 	 * The parent interface.
6251 	 */
6252 	GTypeInterface gIface;
6253 	/**
6254 	 *
6255 	 * Params:
6256 	 *     stream = a #GPollableOutputStream.
6257 	 * Return: %TRUE if @stream is pollable, %FALSE if not.
6258 	 */
6259 	extern(C) int function(GPollableOutputStream* stream) canPoll;
6260 	/**
6261 	 *
6262 	 * Params:
6263 	 *     stream = a #GPollableOutputStream.
6264 	 * Return: %TRUE if @stream is writable, %FALSE if not. If an error
6265 	 *     has occurred on @stream, this will result in
6266 	 *     g_pollable_output_stream_is_writable() returning %TRUE, and the
6267 	 *     next attempt to write will return the error.
6268 	 */
6269 	extern(C) int function(GPollableOutputStream* stream) isWritable;
6270 	/**
6271 	 *
6272 	 * Params:
6273 	 *     stream = a #GPollableOutputStream.
6274 	 *     cancellable = a #GCancellable, or %NULL
6275 	 * Return: a new #GSource
6276 	 */
6277 	extern(C) GSource* function(GPollableOutputStream* stream, GCancellable* cancellable) createSource;
6278 	/**
6279 	 *
6280 	 * Params:
6281 	 *     stream = a #GPollableOutputStream
6282 	 *     buffer = a buffer to write
6283 	 *         data from
6284 	 *     count = the number of bytes you want to write
6285 	 * Return: the number of bytes written, or -1 on error (including
6286 	 *     %G_IO_ERROR_WOULD_BLOCK).
6287 	 *
6288 	 * Throws: GException on failure.
6289 	 */
6290 	extern(C) ptrdiff_t function(GPollableOutputStream* stream, void* buffer, size_t count, GError** err) writeNonblocking;
6291 }
6292 
6293 struct GPropertyAction;
6294 
6295 struct GProxy;
6296 
6297 struct GProxyAddress
6298 {
6299 	GInetSocketAddress parentInstance;
6300 	GProxyAddressPrivate* priv;
6301 }
6302 
6303 struct GProxyAddressClass
6304 {
6305 	GInetSocketAddressClass parentClass;
6306 }
6307 
6308 struct GProxyAddressEnumerator
6309 {
6310 	GSocketAddressEnumerator parentInstance;
6311 	GProxyAddressEnumeratorPrivate* priv;
6312 }
6313 
6314 struct GProxyAddressEnumeratorClass
6315 {
6316 	GSocketAddressEnumeratorClass parentClass;
6317 	extern(C) void function() GReserved1;
6318 	extern(C) void function() GReserved2;
6319 	extern(C) void function() GReserved3;
6320 	extern(C) void function() GReserved4;
6321 	extern(C) void function() GReserved5;
6322 	extern(C) void function() GReserved6;
6323 	extern(C) void function() GReserved7;
6324 }
6325 
6326 struct GProxyAddressEnumeratorPrivate;
6327 
6328 struct GProxyAddressPrivate;
6329 
6330 /**
6331  * Provides an interface for handling proxy connection and payload.
6332  *
6333  * Since: 2.26
6334  */
6335 struct GProxyInterface
6336 {
6337 	/**
6338 	 * The parent interface.
6339 	 */
6340 	GTypeInterface gIface;
6341 	/**
6342 	 *
6343 	 * Params:
6344 	 *     proxy = a #GProxy
6345 	 *     connection = a #GIOStream
6346 	 *     proxyAddress = a #GProxyAddress
6347 	 *     cancellable = a #GCancellable
6348 	 * Return: a #GIOStream that will replace @connection. This might
6349 	 *     be the same as @connection, in which case a reference
6350 	 *     will be added.
6351 	 *
6352 	 * Throws: GException on failure.
6353 	 */
6354 	extern(C) GIOStream* function(GProxy* proxy, GIOStream* connection, GProxyAddress* proxyAddress, GCancellable* cancellable, GError** err) connect;
6355 	extern(C) void function(GProxy* proxy, GIOStream* connection, GProxyAddress* proxyAddress, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) connectAsync;
6356 	/**
6357 	 *
6358 	 * Params:
6359 	 *     proxy = a #GProxy
6360 	 *     result = a #GAsyncResult
6361 	 * Return: a #GIOStream.
6362 	 *
6363 	 * Throws: GException on failure.
6364 	 */
6365 	extern(C) GIOStream* function(GProxy* proxy, GAsyncResult* result, GError** err) connectFinish;
6366 	/**
6367 	 *
6368 	 * Params:
6369 	 *     proxy = a #GProxy
6370 	 * Return: %TRUE if hostname resolution is supported.
6371 	 */
6372 	extern(C) int function(GProxy* proxy) supportsHostname;
6373 }
6374 
6375 struct GProxyResolver;
6376 
6377 struct GProxyResolverInterface
6378 {
6379 	GTypeInterface gIface;
6380 	/**
6381 	 *
6382 	 * Params:
6383 	 *     resolver = a #GProxyResolver
6384 	 * Return: %TRUE if @resolver is supported.
6385 	 */
6386 	extern(C) int function(GProxyResolver* resolver) isSupported;
6387 	/**
6388 	 *
6389 	 * Params:
6390 	 *     resolver = a #GProxyResolver
6391 	 *     uri = a URI representing the destination to connect to
6392 	 *     cancellable = a #GCancellable, or %NULL
6393 	 * Return: A
6394 	 *     NULL-terminated array of proxy URIs. Must be freed
6395 	 *     with g_strfreev().
6396 	 *
6397 	 * Throws: GException on failure.
6398 	 */
6399 	extern(C) char** function(GProxyResolver* resolver, const(char)* uri, GCancellable* cancellable, GError** err) lookup;
6400 	extern(C) void function(GProxyResolver* resolver, const(char)* uri, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupAsync;
6401 	/**
6402 	 *
6403 	 * Params:
6404 	 *     resolver = a #GProxyResolver
6405 	 *     result = the result passed to your #GAsyncReadyCallback
6406 	 * Return: A
6407 	 *     NULL-terminated array of proxy URIs. Must be freed
6408 	 *     with g_strfreev().
6409 	 *
6410 	 * Throws: GException on failure.
6411 	 */
6412 	extern(C) char** function(GProxyResolver* resolver, GAsyncResult* result, GError** err) lookupFinish;
6413 }
6414 
6415 struct GRemoteActionGroup;
6416 
6417 /**
6418  * The virtual function table for #GRemoteActionGroup.
6419  *
6420  * Since: 2.32
6421  */
6422 struct GRemoteActionGroupInterface
6423 {
6424 	GTypeInterface gIface;
6425 	extern(C) void function(GRemoteActionGroup* remote, const(char)* actionName, GVariant* parameter, GVariant* platformData) activateActionFull;
6426 	extern(C) void function(GRemoteActionGroup* remote, const(char)* actionName, GVariant* value, GVariant* platformData) changeActionStateFull;
6427 }
6428 
6429 struct GResolver
6430 {
6431 	GObject parentInstance;
6432 	GResolverPrivate* priv;
6433 }
6434 
6435 struct GResolverClass
6436 {
6437 	GObjectClass parentClass;
6438 	extern(C) void function(GResolver* resolver) reload;
6439 	/**
6440 	 *
6441 	 * Params:
6442 	 *     resolver = a #GResolver
6443 	 *     hostname = the hostname to look up
6444 	 *     cancellable = a #GCancellable, or %NULL
6445 	 * Return: a non-empty #GList
6446 	 *     of #GInetAddress, or %NULL on error. You
6447 	 *     must unref each of the addresses and free the list when you are
6448 	 *     done with it. (You can use g_resolver_free_addresses() to do this.)
6449 	 *
6450 	 * Throws: GException on failure.
6451 	 */
6452 	extern(C) GList* function(GResolver* resolver, const(char)* hostname, GCancellable* cancellable, GError** err) lookupByName;
6453 	extern(C) void function(GResolver* resolver, const(char)* hostname, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupByNameAsync;
6454 	/**
6455 	 *
6456 	 * Params:
6457 	 *     resolver = a #GResolver
6458 	 *     result = the result passed to your #GAsyncReadyCallback
6459 	 * Return: a #GList
6460 	 *     of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name()
6461 	 *     for more details.
6462 	 *
6463 	 * Throws: GException on failure.
6464 	 */
6465 	extern(C) GList* function(GResolver* resolver, GAsyncResult* result, GError** err) lookupByNameFinish;
6466 	/**
6467 	 *
6468 	 * Params:
6469 	 *     resolver = a #GResolver
6470 	 *     address = the address to reverse-resolve
6471 	 *     cancellable = a #GCancellable, or %NULL
6472 	 * Return: a hostname (either ASCII-only, or in ASCII-encoded
6473 	 *     form), or %NULL on error.
6474 	 *
6475 	 * Throws: GException on failure.
6476 	 */
6477 	extern(C) char* function(GResolver* resolver, GInetAddress* address, GCancellable* cancellable, GError** err) lookupByAddress;
6478 	extern(C) void function(GResolver* resolver, GInetAddress* address, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupByAddressAsync;
6479 	/**
6480 	 *
6481 	 * Params:
6482 	 *     resolver = a #GResolver
6483 	 *     result = the result passed to your #GAsyncReadyCallback
6484 	 * Return: a hostname (either ASCII-only, or in ASCII-encoded
6485 	 *     form), or %NULL on error.
6486 	 *
6487 	 * Throws: GException on failure.
6488 	 */
6489 	extern(C) char* function(GResolver* resolver, GAsyncResult* result, GError** err) lookupByAddressFinish;
6490 	extern(C) GList* function(GResolver* resolver, const(char)* rrname, GCancellable* cancellable, GError** err) lookupService;
6491 	extern(C) void function(GResolver* resolver, const(char)* rrname, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupServiceAsync;
6492 	/**
6493 	 *
6494 	 * Params:
6495 	 *     resolver = a #GResolver
6496 	 *     result = the result passed to your #GAsyncReadyCallback
6497 	 * Return: a non-empty #GList of
6498 	 *     #GSrvTarget, or %NULL on error. See g_resolver_lookup_service() for more
6499 	 *     details.
6500 	 *
6501 	 * Throws: GException on failure.
6502 	 */
6503 	extern(C) GList* function(GResolver* resolver, GAsyncResult* result, GError** err) lookupServiceFinish;
6504 	/**
6505 	 *
6506 	 * Params:
6507 	 *     resolver = a #GResolver
6508 	 *     rrname = the DNS name to lookup the record for
6509 	 *     recordType = the type of DNS record to lookup
6510 	 *     cancellable = a #GCancellable, or %NULL
6511 	 * Return: a non-empty #GList of
6512 	 *     #GVariant, or %NULL on error. You must free each of the records and the list
6513 	 *     when you are done with it. (You can use g_list_free_full() with
6514 	 *     g_variant_unref() to do this.)
6515 	 *
6516 	 * Throws: GException on failure.
6517 	 */
6518 	extern(C) GList* function(GResolver* resolver, const(char)* rrname, GResolverRecordType recordType, GCancellable* cancellable, GError** err) lookupRecords;
6519 	extern(C) void function(GResolver* resolver, const(char)* rrname, GResolverRecordType recordType, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupRecordsAsync;
6520 	/**
6521 	 *
6522 	 * Params:
6523 	 *     resolver = a #GResolver
6524 	 *     result = the result passed to your #GAsyncReadyCallback
6525 	 * Return: a non-empty #GList of
6526 	 *     #GVariant, or %NULL on error. You must free each of the records and the list
6527 	 *     when you are done with it. (You can use g_list_free_full() with
6528 	 *     g_variant_unref() to do this.)
6529 	 *
6530 	 * Throws: GException on failure.
6531 	 */
6532 	extern(C) GList* function(GResolver* resolver, GAsyncResult* result, GError** err) lookupRecordsFinish;
6533 	extern(C) void function() GReserved4;
6534 	extern(C) void function() GReserved5;
6535 	extern(C) void function() GReserved6;
6536 }
6537 
6538 struct GResolverPrivate;
6539 
6540 struct GResource;
6541 
6542 struct GSeekable;
6543 
6544 /**
6545  * Provides an interface for implementing seekable functionality on I/O Streams.
6546  */
6547 struct GSeekableIface
6548 {
6549 	/**
6550 	 * The parent interface.
6551 	 */
6552 	GTypeInterface gIface;
6553 	/**
6554 	 *
6555 	 * Params:
6556 	 *     seekable = a #GSeekable.
6557 	 * Return: the offset from the beginning of the buffer.
6558 	 */
6559 	extern(C) long function(GSeekable* seekable) tell;
6560 	/**
6561 	 *
6562 	 * Params:
6563 	 *     seekable = a #GSeekable.
6564 	 * Return: %TRUE if @seekable can be seeked. %FALSE otherwise.
6565 	 */
6566 	extern(C) int function(GSeekable* seekable) canSeek;
6567 	/**
6568 	 *
6569 	 * Params:
6570 	 *     seekable = a #GSeekable.
6571 	 *     offset = a #goffset.
6572 	 *     type = a #GSeekType.
6573 	 *     cancellable = optional #GCancellable object, %NULL to ignore.
6574 	 * Return: %TRUE if successful. If an error
6575 	 *     has occurred, this function will return %FALSE and set @error
6576 	 *     appropriately if present.
6577 	 *
6578 	 * Throws: GException on failure.
6579 	 */
6580 	extern(C) int function(GSeekable* seekable, long offset, GSeekType type, GCancellable* cancellable, GError** err) seek;
6581 	/**
6582 	 *
6583 	 * Params:
6584 	 *     seekable = a #GSeekable.
6585 	 * Return: %TRUE if the stream can be truncated, %FALSE otherwise.
6586 	 */
6587 	extern(C) int function(GSeekable* seekable) canTruncate;
6588 	/**
6589 	 *
6590 	 * Params:
6591 	 *     seekable = a #GSeekable.
6592 	 *     offset = a #goffset.
6593 	 *     cancellable = optional #GCancellable object, %NULL to ignore.
6594 	 * Return: %TRUE if successful. If an error
6595 	 *     has occurred, this function will return %FALSE and set @error
6596 	 *     appropriately if present.
6597 	 *
6598 	 * Throws: GException on failure.
6599 	 */
6600 	extern(C) int function(GSeekable* seekable, long offset, GCancellable* cancellable, GError** err) truncateFn;
6601 }
6602 
6603 struct GSettings
6604 {
6605 	GObject parentInstance;
6606 	GSettingsPrivate* priv;
6607 }
6608 
6609 /**
6610  * The #GSettingsBackend interface defines a generic interface for
6611  * non-strictly-typed data that is stored in a hierarchy. To implement
6612  * an alternative storage backend for #GSettings, you need to implement
6613  * the #GSettingsBackend interface and then make it implement the
6614  * extension point #G_SETTINGS_BACKEND_EXTENSION_POINT_NAME.
6615  *
6616  * The interface defines methods for reading and writing values, a
6617  * method for determining if writing of certain values will fail
6618  * (lockdown) and a change notification mechanism.
6619  *
6620  * The semantics of the interface are very precisely defined and
6621  * implementations must carefully adhere to the expectations of
6622  * callers that are documented on each of the interface methods.
6623  *
6624  * Some of the GSettingsBackend functions accept or return a #GTree.
6625  * These trees always have strings as keys and #GVariant as values.
6626  * g_settings_backend_create_tree() is a convenience function to create
6627  * suitable trees.
6628  *
6629  * The GSettingsBackend API is exported to allow third-party
6630  * implementations, but does not carry the same stability guarantees
6631  * as the public GIO API. For this reason, you have to define the
6632  * C preprocessor symbol %G_SETTINGS_ENABLE_BACKEND before including
6633  * `gio/gsettingsbackend.h`.
6634  */
6635 struct GSettingsBackend;
6636 
6637 struct GSettingsClass
6638 {
6639 	GObjectClass parentClass;
6640 	extern(C) void function(GSettings* settings, const(char)* key) writableChanged;
6641 	extern(C) void function(GSettings* settings, const(char)* key) changed;
6642 	extern(C) int function(GSettings* settings, GQuark key) writableChangeEvent;
6643 	extern(C) int function(GSettings* settings, GQuark* keys, int nKeys) changeEvent;
6644 	void*[20] padding;
6645 }
6646 
6647 struct GSettingsPrivate;
6648 
6649 struct GSettingsSchema;
6650 
6651 struct GSettingsSchemaKey;
6652 
6653 struct GSettingsSchemaSource;
6654 
6655 struct GSimpleAction;
6656 
6657 struct GSimpleActionGroup
6658 {
6659 	GObject parentInstance;
6660 	GSimpleActionGroupPrivate* priv;
6661 }
6662 
6663 struct GSimpleActionGroupClass
6664 {
6665 	GObjectClass parentClass;
6666 	void*[12] padding;
6667 }
6668 
6669 struct GSimpleActionGroupPrivate;
6670 
6671 struct GSimpleAsyncResult;
6672 
6673 struct GSimpleAsyncResultClass;
6674 
6675 struct GSimplePermission;
6676 
6677 struct GSimpleProxyResolver
6678 {
6679 	GObject parentInstance;
6680 	GSimpleProxyResolverPrivate* priv;
6681 }
6682 
6683 struct GSimpleProxyResolverClass
6684 {
6685 	GObjectClass parentClass;
6686 	extern(C) void function() GReserved1;
6687 	extern(C) void function() GReserved2;
6688 	extern(C) void function() GReserved3;
6689 	extern(C) void function() GReserved4;
6690 	extern(C) void function() GReserved5;
6691 }
6692 
6693 struct GSimpleProxyResolverPrivate;
6694 
6695 struct GSocket
6696 {
6697 	GObject parentInstance;
6698 	GSocketPrivate* priv;
6699 }
6700 
6701 struct GSocketAddress
6702 {
6703 	GObject parentInstance;
6704 }
6705 
6706 struct GSocketAddressClass
6707 {
6708 	GObjectClass parentClass;
6709 	/**
6710 	 *
6711 	 * Params:
6712 	 *     address = a #GSocketAddress
6713 	 * Return: the socket family type of @address
6714 	 */
6715 	extern(C) GSocketFamily function(GSocketAddress* address) getFamily;
6716 	/**
6717 	 *
6718 	 * Params:
6719 	 *     address = a #GSocketAddress
6720 	 * Return: the size of the native struct sockaddr that
6721 	 *     @address represents
6722 	 */
6723 	extern(C) ptrdiff_t function(GSocketAddress* address) getNativeSize;
6724 	/**
6725 	 *
6726 	 * Params:
6727 	 *     address = a #GSocketAddress
6728 	 *     dest = a pointer to a memory location that will contain the native
6729 	 *         struct sockaddr
6730 	 *     destlen = the size of @dest. Must be at least as large as
6731 	 *         g_socket_address_get_native_size()
6732 	 * Return: %TRUE if @dest was filled in, %FALSE on error
6733 	 *
6734 	 * Throws: GException on failure.
6735 	 */
6736 	extern(C) int function(GSocketAddress* address, void* dest, size_t destlen, GError** err) toNative;
6737 }
6738 
6739 struct GSocketAddressEnumerator
6740 {
6741 	GObject parentInstance;
6742 }
6743 
6744 struct GSocketAddressEnumeratorClass
6745 {
6746 	GObjectClass parentClass;
6747 	/**
6748 	 *
6749 	 * Params:
6750 	 *     enumerator = a #GSocketAddressEnumerator
6751 	 *     cancellable = optional #GCancellable object, %NULL to ignore.
6752 	 * Return: a #GSocketAddress (owned by the caller), or %NULL on
6753 	 *     error (in which case *@error will be set) or if there are no
6754 	 *     more addresses.
6755 	 *
6756 	 * Throws: GException on failure.
6757 	 */
6758 	extern(C) GSocketAddress* function(GSocketAddressEnumerator* enumerator, GCancellable* cancellable, GError** err) next;
6759 	extern(C) void function(GSocketAddressEnumerator* enumerator, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) nextAsync;
6760 	/**
6761 	 *
6762 	 * Params:
6763 	 *     enumerator = a #GSocketAddressEnumerator
6764 	 *     result = a #GAsyncResult
6765 	 * Return: a #GSocketAddress (owned by the caller), or %NULL on
6766 	 *     error (in which case *@error will be set) or if there are no
6767 	 *     more addresses.
6768 	 *
6769 	 * Throws: GException on failure.
6770 	 */
6771 	extern(C) GSocketAddress* function(GSocketAddressEnumerator* enumerator, GAsyncResult* result, GError** err) nextFinish;
6772 }
6773 
6774 struct GSocketClass
6775 {
6776 	GObjectClass parentClass;
6777 	extern(C) void function() GReserved1;
6778 	extern(C) void function() GReserved2;
6779 	extern(C) void function() GReserved3;
6780 	extern(C) void function() GReserved4;
6781 	extern(C) void function() GReserved5;
6782 	extern(C) void function() GReserved6;
6783 	extern(C) void function() GReserved7;
6784 	extern(C) void function() GReserved8;
6785 	extern(C) void function() GReserved9;
6786 	extern(C) void function() GReserved10;
6787 }
6788 
6789 struct GSocketClient
6790 {
6791 	GObject parentInstance;
6792 	GSocketClientPrivate* priv;
6793 }
6794 
6795 struct GSocketClientClass
6796 {
6797 	GObjectClass parentClass;
6798 	extern(C) void function(GSocketClient* client, GSocketClientEvent event, GSocketConnectable* connectable, GIOStream* connection) event;
6799 	extern(C) void function() GReserved1;
6800 	extern(C) void function() GReserved2;
6801 	extern(C) void function() GReserved3;
6802 	extern(C) void function() GReserved4;
6803 }
6804 
6805 struct GSocketClientPrivate;
6806 
6807 struct GSocketConnectable;
6808 
6809 /**
6810  * Provides an interface for returning a #GSocketAddressEnumerator
6811  * and #GProxyAddressEnumerator
6812  */
6813 struct GSocketConnectableIface
6814 {
6815 	/**
6816 	 * The parent interface.
6817 	 */
6818 	GTypeInterface gIface;
6819 	/**
6820 	 *
6821 	 * Params:
6822 	 *     connectable = a #GSocketConnectable
6823 	 * Return: a new #GSocketAddressEnumerator.
6824 	 */
6825 	extern(C) GSocketAddressEnumerator* function(GSocketConnectable* connectable) enumerate;
6826 	/**
6827 	 *
6828 	 * Params:
6829 	 *     connectable = a #GSocketConnectable
6830 	 * Return: a new #GSocketAddressEnumerator.
6831 	 */
6832 	extern(C) GSocketAddressEnumerator* function(GSocketConnectable* connectable) proxyEnumerate;
6833 }
6834 
6835 struct GSocketConnection
6836 {
6837 	GIOStream parentInstance;
6838 	GSocketConnectionPrivate* priv;
6839 }
6840 
6841 struct GSocketConnectionClass
6842 {
6843 	GIOStreamClass parentClass;
6844 	extern(C) void function() GReserved1;
6845 	extern(C) void function() GReserved2;
6846 	extern(C) void function() GReserved3;
6847 	extern(C) void function() GReserved4;
6848 	extern(C) void function() GReserved5;
6849 	extern(C) void function() GReserved6;
6850 }
6851 
6852 struct GSocketConnectionPrivate;
6853 
6854 struct GSocketControlMessage
6855 {
6856 	GObject parentInstance;
6857 	GSocketControlMessagePrivate* priv;
6858 }
6859 
6860 struct GSocketControlMessageClass
6861 {
6862 	GObjectClass parentClass;
6863 	/**
6864 	 *
6865 	 * Params:
6866 	 *     message = a #GSocketControlMessage
6867 	 * Return: The number of bytes required.
6868 	 */
6869 	extern(C) size_t function(GSocketControlMessage* message) getSize;
6870 	/**
6871 	 *
6872 	 * Params:
6873 	 *     message = a #GSocketControlMessage
6874 	 * Return: an integer describing the level
6875 	 */
6876 	extern(C) int function(GSocketControlMessage* message) getLevel;
6877 	extern(C) int function(GSocketControlMessage* message) getType;
6878 	extern(C) void function(GSocketControlMessage* message, void* data) serialize;
6879 	extern(C) GSocketControlMessage* function(int level, int type, size_t size, void* data) deserialize;
6880 	extern(C) void function() GReserved1;
6881 	extern(C) void function() GReserved2;
6882 	extern(C) void function() GReserved3;
6883 	extern(C) void function() GReserved4;
6884 	extern(C) void function() GReserved5;
6885 }
6886 
6887 struct GSocketControlMessagePrivate;
6888 
6889 struct GSocketListener
6890 {
6891 	GObject parentInstance;
6892 	GSocketListenerPrivate* priv;
6893 }
6894 
6895 struct GSocketListenerClass
6896 {
6897 	GObjectClass parentClass;
6898 	extern(C) void function(GSocketListener* listener) changed;
6899 	extern(C) void function() GReserved1;
6900 	extern(C) void function() GReserved2;
6901 	extern(C) void function() GReserved3;
6902 	extern(C) void function() GReserved4;
6903 	extern(C) void function() GReserved5;
6904 	extern(C) void function() GReserved6;
6905 }
6906 
6907 struct GSocketListenerPrivate;
6908 
6909 struct GSocketPrivate;
6910 
6911 struct GSocketService
6912 {
6913 	GSocketListener parentInstance;
6914 	GSocketServicePrivate* priv;
6915 }
6916 
6917 struct GSocketServiceClass
6918 {
6919 	GSocketListenerClass parentClass;
6920 	extern(C) int function(GSocketService* service, GSocketConnection* connection, GObject* sourceObject) incoming;
6921 	extern(C) void function() GReserved1;
6922 	extern(C) void function() GReserved2;
6923 	extern(C) void function() GReserved3;
6924 	extern(C) void function() GReserved4;
6925 	extern(C) void function() GReserved5;
6926 	extern(C) void function() GReserved6;
6927 }
6928 
6929 struct GSocketServicePrivate;
6930 
6931 struct GSrvTarget;
6932 
6933 struct GStaticResource
6934 {
6935 	ubyte* data;
6936 	size_t dataLen;
6937 	GResource* resource;
6938 	GStaticResource* next;
6939 	void* padding;
6940 }
6941 
6942 struct GSubprocess;
6943 
6944 struct GSubprocessLauncher;
6945 
6946 struct GTask;
6947 
6948 struct GTaskClass;
6949 
6950 struct GTcpConnection
6951 {
6952 	GSocketConnection parentInstance;
6953 	GTcpConnectionPrivate* priv;
6954 }
6955 
6956 struct GTcpConnectionClass
6957 {
6958 	GSocketConnectionClass parentClass;
6959 }
6960 
6961 struct GTcpConnectionPrivate;
6962 
6963 struct GTcpWrapperConnection
6964 {
6965 	GTcpConnection parentInstance;
6966 	GTcpWrapperConnectionPrivate* priv;
6967 }
6968 
6969 struct GTcpWrapperConnectionClass
6970 {
6971 	GTcpConnectionClass parentClass;
6972 }
6973 
6974 struct GTcpWrapperConnectionPrivate;
6975 
6976 struct GTestDBus;
6977 
6978 struct GThemedIcon;
6979 
6980 struct GThemedIconClass;
6981 
6982 struct GThreadedSocketService
6983 {
6984 	GSocketService parentInstance;
6985 	GThreadedSocketServicePrivate* priv;
6986 }
6987 
6988 struct GThreadedSocketServiceClass
6989 {
6990 	GSocketServiceClass parentClass;
6991 	extern(C) int function(GThreadedSocketService* service, GSocketConnection* connection, GObject* sourceObject) run;
6992 	extern(C) void function() GReserved1;
6993 	extern(C) void function() GReserved2;
6994 	extern(C) void function() GReserved3;
6995 	extern(C) void function() GReserved4;
6996 	extern(C) void function() GReserved5;
6997 }
6998 
6999 struct GThreadedSocketServicePrivate;
7000 
7001 struct GTlsBackend;
7002 
7003 /**
7004  * Provides an interface for describing TLS-related types.
7005  *
7006  * Since: 2.28
7007  */
7008 struct GTlsBackendInterface
7009 {
7010 	/**
7011 	 * The parent interface.
7012 	 */
7013 	GTypeInterface gIface;
7014 	/**
7015 	 *
7016 	 * Params:
7017 	 *     backend = the #GTlsBackend
7018 	 * Return: whether or not TLS is supported
7019 	 */
7020 	extern(C) int function(GTlsBackend* backend) supportsTls;
7021 	extern(C) GType function() getCertificateType;
7022 	extern(C) GType function() getClientConnectionType;
7023 	extern(C) GType function() getServerConnectionType;
7024 	extern(C) GType function() getFileDatabaseType;
7025 	/**
7026 	 *
7027 	 * Params:
7028 	 *     backend = the #GTlsBackend
7029 	 * Return: the default database, which should be
7030 	 *     unreffed when done.
7031 	 */
7032 	extern(C) GTlsDatabase* function(GTlsBackend* backend) getDefaultDatabase;
7033 }
7034 
7035 struct GTlsCertificate
7036 {
7037 	GObject parentInstance;
7038 	GTlsCertificatePrivate* priv;
7039 }
7040 
7041 struct GTlsCertificateClass
7042 {
7043 	GObjectClass parentClass;
7044 	/**
7045 	 *
7046 	 * Params:
7047 	 *     cert = a #GTlsCertificate
7048 	 *     identity = the expected peer identity
7049 	 *     trustedCa = the certificate of a trusted authority
7050 	 * Return: the appropriate #GTlsCertificateFlags
7051 	 */
7052 	extern(C) GTlsCertificateFlags function(GTlsCertificate* cert, GSocketConnectable* identity, GTlsCertificate* trustedCa) verify;
7053 	void*[8] padding;
7054 }
7055 
7056 struct GTlsCertificatePrivate;
7057 
7058 struct GTlsClientConnection;
7059 
7060 struct GTlsClientConnectionInterface
7061 {
7062 	GTypeInterface gIface;
7063 }
7064 
7065 struct GTlsConnection
7066 {
7067 	GIOStream parentInstance;
7068 	GTlsConnectionPrivate* priv;
7069 }
7070 
7071 struct GTlsConnectionClass
7072 {
7073 	GIOStreamClass parentClass;
7074 	extern(C) int function(GTlsConnection* connection, GTlsCertificate* peerCert, GTlsCertificateFlags errors) acceptCertificate;
7075 	/**
7076 	 *
7077 	 * Params:
7078 	 *     conn = a #GTlsConnection
7079 	 *     cancellable = a #GCancellable, or %NULL
7080 	 * Return: success or failure
7081 	 *
7082 	 * Throws: GException on failure.
7083 	 */
7084 	extern(C) int function(GTlsConnection* conn, GCancellable* cancellable, GError** err) handshake;
7085 	extern(C) void function(GTlsConnection* conn, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) handshakeAsync;
7086 	/**
7087 	 *
7088 	 * Params:
7089 	 *     conn = a #GTlsConnection
7090 	 *     result = a #GAsyncResult.
7091 	 * Return: %TRUE on success, %FALSE on failure, in which
7092 	 *     case @error will be set.
7093 	 *
7094 	 * Throws: GException on failure.
7095 	 */
7096 	extern(C) int function(GTlsConnection* conn, GAsyncResult* result, GError** err) handshakeFinish;
7097 	void*[8] padding;
7098 }
7099 
7100 struct GTlsConnectionPrivate;
7101 
7102 struct GTlsDatabase
7103 {
7104 	GObject parentInstance;
7105 	GTlsDatabasePrivate* priv;
7106 }
7107 
7108 struct GTlsDatabaseClass
7109 {
7110 	GObjectClass parentClass;
7111 	/**
7112 	 *
7113 	 * Params:
7114 	 *     self = a #GTlsDatabase
7115 	 *     chain = a #GTlsCertificate chain
7116 	 *     purpose = the purpose that this certificate chain will be used for.
7117 	 *     identity = the expected peer identity
7118 	 *     interaction = used to interact with the user if necessary
7119 	 *     flags = additional verify flags
7120 	 *     cancellable = a #GCancellable, or %NULL
7121 	 * Return: the appropriate #GTlsCertificateFlags which represents the
7122 	 *     result of verification.
7123 	 *
7124 	 * Throws: GException on failure.
7125 	 */
7126 	extern(C) GTlsCertificateFlags function(GTlsDatabase* self, GTlsCertificate* chain, const(char)* purpose, GSocketConnectable* identity, GTlsInteraction* interaction, GTlsDatabaseVerifyFlags flags, GCancellable* cancellable, GError** err) verifyChain;
7127 	extern(C) void function(GTlsDatabase* self, GTlsCertificate* chain, const(char)* purpose, GSocketConnectable* identity, GTlsInteraction* interaction, GTlsDatabaseVerifyFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) verifyChainAsync;
7128 	/**
7129 	 *
7130 	 * Params:
7131 	 *     self = a #GTlsDatabase
7132 	 *     result = a #GAsyncResult.
7133 	 * Return: the appropriate #GTlsCertificateFlags which represents the
7134 	 *     result of verification.
7135 	 *
7136 	 * Throws: GException on failure.
7137 	 */
7138 	extern(C) GTlsCertificateFlags function(GTlsDatabase* self, GAsyncResult* result, GError** err) verifyChainFinish;
7139 	/**
7140 	 *
7141 	 * Params:
7142 	 *     self = a #GTlsDatabase
7143 	 *     certificate = certificate for which to create a handle.
7144 	 * Return: a newly allocated string containing the
7145 	 *     handle.
7146 	 */
7147 	extern(C) char* function(GTlsDatabase* self, GTlsCertificate* certificate) createCertificateHandle;
7148 	/**
7149 	 *
7150 	 * Params:
7151 	 *     self = a #GTlsDatabase
7152 	 *     handle = a certificate handle
7153 	 *     interaction = used to interact with the user if necessary
7154 	 *     flags = Flags which affect the lookup.
7155 	 *     cancellable = a #GCancellable, or %NULL
7156 	 * Return: a newly allocated
7157 	 *     #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate.
7158 	 *
7159 	 * Throws: GException on failure.
7160 	 */
7161 	extern(C) GTlsCertificate* function(GTlsDatabase* self, const(char)* handle, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GError** err) lookupCertificateForHandle;
7162 	extern(C) void function(GTlsDatabase* self, const(char)* handle, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupCertificateForHandleAsync;
7163 	/**
7164 	 *
7165 	 * Params:
7166 	 *     self = a #GTlsDatabase
7167 	 *     result = a #GAsyncResult.
7168 	 * Return: a newly allocated #GTlsCertificate object.
7169 	 *     Use g_object_unref() to release the certificate.
7170 	 *
7171 	 * Throws: GException on failure.
7172 	 */
7173 	extern(C) GTlsCertificate* function(GTlsDatabase* self, GAsyncResult* result, GError** err) lookupCertificateForHandleFinish;
7174 	/**
7175 	 *
7176 	 * Params:
7177 	 *     self = a #GTlsDatabase
7178 	 *     certificate = a #GTlsCertificate
7179 	 *     interaction = used to interact with the user if necessary
7180 	 *     flags = flags which affect the lookup operation
7181 	 *     cancellable = a #GCancellable, or %NULL
7182 	 * Return: a newly allocated issuer #GTlsCertificate,
7183 	 *     or %NULL. Use g_object_unref() to release the certificate.
7184 	 *
7185 	 * Throws: GException on failure.
7186 	 */
7187 	extern(C) GTlsCertificate* function(GTlsDatabase* self, GTlsCertificate* certificate, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GError** err) lookupCertificateIssuer;
7188 	extern(C) void function(GTlsDatabase* self, GTlsCertificate* certificate, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupCertificateIssuerAsync;
7189 	/**
7190 	 *
7191 	 * Params:
7192 	 *     self = a #GTlsDatabase
7193 	 *     result = a #GAsyncResult.
7194 	 * Return: a newly allocated issuer #GTlsCertificate,
7195 	 *     or %NULL. Use g_object_unref() to release the certificate.
7196 	 *
7197 	 * Throws: GException on failure.
7198 	 */
7199 	extern(C) GTlsCertificate* function(GTlsDatabase* self, GAsyncResult* result, GError** err) lookupCertificateIssuerFinish;
7200 	/**
7201 	 *
7202 	 * Params:
7203 	 *     self = a #GTlsDatabase
7204 	 *     issuerRawDn = a #GByteArray which holds the DER encoded issuer DN.
7205 	 *     interaction = used to interact with the user if necessary
7206 	 *     flags = Flags which affect the lookup operation.
7207 	 *     cancellable = a #GCancellable, or %NULL
7208 	 * Return: a newly allocated list of #GTlsCertificate
7209 	 *     objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list.
7210 	 *
7211 	 * Throws: GException on failure.
7212 	 */
7213 	extern(C) GList* function(GTlsDatabase* self, GByteArray* issuerRawDn, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GError** err) lookupCertificatesIssuedBy;
7214 	extern(C) void function(GTlsDatabase* self, GByteArray* issuerRawDn, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupCertificatesIssuedByAsync;
7215 	/**
7216 	 *
7217 	 * Params:
7218 	 *     self = a #GTlsDatabase
7219 	 *     result = a #GAsyncResult.
7220 	 * Return: a newly allocated list of #GTlsCertificate
7221 	 *     objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list.
7222 	 *
7223 	 * Throws: GException on failure.
7224 	 */
7225 	extern(C) GList* function(GTlsDatabase* self, GAsyncResult* result, GError** err) lookupCertificatesIssuedByFinish;
7226 	void*[16] padding;
7227 }
7228 
7229 struct GTlsDatabasePrivate;
7230 
7231 struct GTlsFileDatabase;
7232 
7233 /**
7234  * Provides an interface for #GTlsFileDatabase implementations.
7235  */
7236 struct GTlsFileDatabaseInterface
7237 {
7238 	/**
7239 	 * The parent interface.
7240 	 */
7241 	GTypeInterface gIface;
7242 	void*[8] padding;
7243 }
7244 
7245 struct GTlsInteraction
7246 {
7247 	GObject parentInstance;
7248 	GTlsInteractionPrivate* priv;
7249 }
7250 
7251 /**
7252  * The class for #GTlsInteraction. Derived classes implement the various
7253  * virtual interaction methods to handle TLS interactions.
7254  *
7255  * Derived classes can choose to implement whichever interactions methods they'd
7256  * like to support by overriding those virtual methods in their class
7257  * initialization function. If a derived class implements an async method,
7258  * it must also implement the corresponding finish method.
7259  *
7260  * The synchronous interaction methods should implement to display modal dialogs,
7261  * and the asynchronous methods to display modeless dialogs.
7262  *
7263  * If the user cancels an interaction, then the result should be
7264  * %G_TLS_INTERACTION_FAILED and the error should be set with a domain of
7265  * %G_IO_ERROR and code of %G_IO_ERROR_CANCELLED.
7266  *
7267  * Since: 2.30
7268  */
7269 struct GTlsInteractionClass
7270 {
7271 	GObjectClass parentClass;
7272 	/**
7273 	 *
7274 	 * Params:
7275 	 *     interaction = a #GTlsInteraction object
7276 	 *     password = a #GTlsPassword object
7277 	 *     cancellable = an optional #GCancellable cancellation object
7278 	 * Return: The status of the ask password interaction.
7279 	 *
7280 	 * Throws: GException on failure.
7281 	 */
7282 	extern(C) GTlsInteractionResult function(GTlsInteraction* interaction, GTlsPassword* password, GCancellable* cancellable, GError** err) askPassword;
7283 	extern(C) void function(GTlsInteraction* interaction, GTlsPassword* password, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) askPasswordAsync;
7284 	/**
7285 	 *
7286 	 * Params:
7287 	 *     interaction = a #GTlsInteraction object
7288 	 *     result = the result passed to the callback
7289 	 * Return: The status of the ask password interaction.
7290 	 *
7291 	 * Throws: GException on failure.
7292 	 */
7293 	extern(C) GTlsInteractionResult function(GTlsInteraction* interaction, GAsyncResult* result, GError** err) askPasswordFinish;
7294 	/**
7295 	 *
7296 	 * Params:
7297 	 *     interaction = a #GTlsInteraction object
7298 	 *     connection = a #GTlsConnection object
7299 	 *     flags = flags providing more information about the request
7300 	 *     cancellable = an optional #GCancellable cancellation object
7301 	 * Return: The status of the request certificate interaction.
7302 	 *
7303 	 * Throws: GException on failure.
7304 	 */
7305 	extern(C) GTlsInteractionResult function(GTlsInteraction* interaction, GTlsConnection* connection, GTlsCertificateRequestFlags flags, GCancellable* cancellable, GError** err) requestCertificate;
7306 	extern(C) void function(GTlsInteraction* interaction, GTlsConnection* connection, GTlsCertificateRequestFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) requestCertificateAsync;
7307 	/**
7308 	 *
7309 	 * Params:
7310 	 *     interaction = a #GTlsInteraction object
7311 	 *     result = the result passed to the callback
7312 	 * Return: The status of the request certificate interaction.
7313 	 *
7314 	 * Throws: GException on failure.
7315 	 */
7316 	extern(C) GTlsInteractionResult function(GTlsInteraction* interaction, GAsyncResult* result, GError** err) requestCertificateFinish;
7317 	void*[21] padding;
7318 }
7319 
7320 struct GTlsInteractionPrivate;
7321 
7322 struct GTlsPassword
7323 {
7324 	GObject parentInstance;
7325 	GTlsPasswordPrivate* priv;
7326 }
7327 
7328 struct GTlsPasswordClass
7329 {
7330 	GObjectClass parentClass;
7331 	/**
7332 	 *
7333 	 * Params:
7334 	 *     password = a #GTlsPassword object
7335 	 *     length = location to place the length of the password.
7336 	 * Return: The password value (owned by the password object).
7337 	 */
7338 	extern(C) char* function(GTlsPassword* password, size_t* length) getValue;
7339 	extern(C) void function(GTlsPassword* password, char* value, ptrdiff_t length, GDestroyNotify destroy) setValue;
7340 	extern(C) const(char)* function(GTlsPassword* password) getDefaultWarning;
7341 	void*[4] padding;
7342 }
7343 
7344 struct GTlsPasswordPrivate;
7345 
7346 struct GTlsServerConnection;
7347 
7348 struct GTlsServerConnectionInterface
7349 {
7350 	GTypeInterface gIface;
7351 }
7352 
7353 struct GUnixConnection
7354 {
7355 	GSocketConnection parentInstance;
7356 	GUnixConnectionPrivate* priv;
7357 }
7358 
7359 struct GUnixConnectionClass
7360 {
7361 	GSocketConnectionClass parentClass;
7362 }
7363 
7364 struct GUnixConnectionPrivate;
7365 
7366 struct GUnixCredentialsMessage
7367 {
7368 	GSocketControlMessage parentInstance;
7369 	GUnixCredentialsMessagePrivate* priv;
7370 }
7371 
7372 /**
7373  * Class structure for #GUnixCredentialsMessage.
7374  *
7375  * Since: 2.26
7376  */
7377 struct GUnixCredentialsMessageClass
7378 {
7379 	GSocketControlMessageClass parentClass;
7380 	extern(C) void function() GReserved1;
7381 	extern(C) void function() GReserved2;
7382 }
7383 
7384 struct GUnixCredentialsMessagePrivate;
7385 
7386 struct GUnixFDList
7387 {
7388 	GObject parentInstance;
7389 	GUnixFDListPrivate* priv;
7390 }
7391 
7392 struct GUnixFDListClass
7393 {
7394 	GObjectClass parentClass;
7395 	extern(C) void function() GReserved1;
7396 	extern(C) void function() GReserved2;
7397 	extern(C) void function() GReserved3;
7398 	extern(C) void function() GReserved4;
7399 	extern(C) void function() GReserved5;
7400 }
7401 
7402 struct GUnixFDListPrivate;
7403 
7404 struct GUnixFDMessage
7405 {
7406 	GSocketControlMessage parentInstance;
7407 	GUnixFDMessagePrivate* priv;
7408 }
7409 
7410 struct GUnixFDMessageClass
7411 {
7412 	GSocketControlMessageClass parentClass;
7413 	extern(C) void function() GReserved1;
7414 	extern(C) void function() GReserved2;
7415 }
7416 
7417 struct GUnixFDMessagePrivate;
7418 
7419 struct GUnixInputStream
7420 {
7421 	GInputStream parentInstance;
7422 	GUnixInputStreamPrivate* priv;
7423 }
7424 
7425 struct GUnixInputStreamClass
7426 {
7427 	GInputStreamClass parentClass;
7428 	extern(C) void function() GReserved1;
7429 	extern(C) void function() GReserved2;
7430 	extern(C) void function() GReserved3;
7431 	extern(C) void function() GReserved4;
7432 	extern(C) void function() GReserved5;
7433 }
7434 
7435 struct GUnixInputStreamPrivate;
7436 
7437 /**
7438  * Defines a Unix mount entry (e.g. <filename>/media/cdrom</filename>).
7439  * This corresponds roughly to a mtab entry.
7440  */
7441 struct GUnixMountEntry;
7442 
7443 struct GUnixMountMonitor;
7444 
7445 struct GUnixMountMonitorClass;
7446 
7447 struct GUnixMountPoint;
7448 
7449 struct GUnixOutputStream
7450 {
7451 	GOutputStream parentInstance;
7452 	GUnixOutputStreamPrivate* priv;
7453 }
7454 
7455 struct GUnixOutputStreamClass
7456 {
7457 	GOutputStreamClass parentClass;
7458 	extern(C) void function() GReserved1;
7459 	extern(C) void function() GReserved2;
7460 	extern(C) void function() GReserved3;
7461 	extern(C) void function() GReserved4;
7462 	extern(C) void function() GReserved5;
7463 }
7464 
7465 struct GUnixOutputStreamPrivate;
7466 
7467 struct GUnixSocketAddress
7468 {
7469 	GSocketAddress parentInstance;
7470 	GUnixSocketAddressPrivate* priv;
7471 }
7472 
7473 struct GUnixSocketAddressClass
7474 {
7475 	GSocketAddressClass parentClass;
7476 }
7477 
7478 struct GUnixSocketAddressPrivate;
7479 
7480 struct GVfs
7481 {
7482 	GObject parentInstance;
7483 }
7484 
7485 struct GVfsClass
7486 {
7487 	GObjectClass parentClass;
7488 	/**
7489 	 *
7490 	 * Params:
7491 	 *     vfs = a #GVfs.
7492 	 * Return: %TRUE if construction of the @vfs was successful
7493 	 *     and it is now active.
7494 	 */
7495 	extern(C) int function(GVfs* vfs) isActive;
7496 	/**
7497 	 *
7498 	 * Params:
7499 	 *     vfs = a #GVfs.
7500 	 *     path = a string containing a VFS path.
7501 	 * Return: a #GFile.
7502 	 *     Free the returned object with g_object_unref().
7503 	 */
7504 	extern(C) GFile* function(GVfs* vfs, const(char)* path) getFileForPath;
7505 	/**
7506 	 *
7507 	 * Params:
7508 	 *     vfs = a#GVfs.
7509 	 *     uri = a string containing a URI
7510 	 * Return: a #GFile.
7511 	 *     Free the returned object with g_object_unref().
7512 	 */
7513 	extern(C) GFile* function(GVfs* vfs, const(char)* uri) getFileForUri;
7514 	/**
7515 	 *
7516 	 * Params:
7517 	 *     vfs = a #GVfs.
7518 	 * Return: a %NULL-terminated array of strings.
7519 	 *     The returned array belongs to GIO and must
7520 	 *     not be freed or modified.
7521 	 */
7522 	extern(C) char** function(GVfs* vfs) getSupportedUriSchemes;
7523 	/**
7524 	 *
7525 	 * Params:
7526 	 *     vfs = a #GVfs.
7527 	 *     parseName = a string to be parsed by the VFS module.
7528 	 * Return: a #GFile for the given @parse_name.
7529 	 *     Free the returned object with g_object_unref().
7530 	 */
7531 	extern(C) GFile* function(GVfs* vfs, const(char)* parseName) parseName;
7532 	extern(C) void function(GVfs* vfs, const(char)* filename, ulong device, GFileAttributeMatcher* attributeMatcher, GFileInfo* info, GCancellable* cancellable, void** extraData, GDestroyNotify* freeExtraData) localFileAddInfo;
7533 	extern(C) void function(GVfs* vfs, GFileAttributeInfoList* list) addWritableNamespaces;
7534 	extern(C) int function(GVfs* vfs, const(char)* filename, GFileInfo* info, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) localFileSetAttributes;
7535 	extern(C) void function(GVfs* vfs, const(char)* filename) localFileRemoved;
7536 	extern(C) void function(GVfs* vfs, const(char)* source, const(char)* dest) localFileMoved;
7537 	extern(C) GIcon* function(GVfs* vfs, GVariant* value) deserializeIcon;
7538 	extern(C) void function() GReserved1;
7539 	extern(C) void function() GReserved2;
7540 	extern(C) void function() GReserved3;
7541 	extern(C) void function() GReserved4;
7542 	extern(C) void function() GReserved5;
7543 	extern(C) void function() GReserved6;
7544 }
7545 
7546 struct GVolume;
7547 
7548 /**
7549  * Interface for implementing operations for mountable volumes.
7550  */
7551 struct GVolumeIface
7552 {
7553 	/**
7554 	 * The parent interface.
7555 	 */
7556 	GTypeInterface gIface;
7557 	extern(C) void function(GVolume* volume) changed;
7558 	extern(C) void function(GVolume* volume) removed;
7559 	/**
7560 	 *
7561 	 * Params:
7562 	 *     volume = a #GVolume
7563 	 * Return: the name for the given @volume. The returned string should
7564 	 *     be freed with g_free() when no longer needed.
7565 	 */
7566 	extern(C) char* function(GVolume* volume) getName;
7567 	/**
7568 	 *
7569 	 * Params:
7570 	 *     volume = a #GVolume
7571 	 * Return: a #GIcon.
7572 	 *     The returned object should be unreffed with g_object_unref()
7573 	 *     when no longer needed.
7574 	 */
7575 	extern(C) GIcon* function(GVolume* volume) getIcon;
7576 	/**
7577 	 *
7578 	 * Params:
7579 	 *     volume = a #GVolume
7580 	 * Return: the UUID for @volume or %NULL if no UUID can be computed.
7581 	 *     The returned string should be freed with g_free()
7582 	 *     when no longer needed.
7583 	 */
7584 	extern(C) char* function(GVolume* volume) getUuid;
7585 	/**
7586 	 *
7587 	 * Params:
7588 	 *     volume = a #GVolume
7589 	 * Return: a #GDrive or %NULL if @volume is not
7590 	 *     associated with a drive. The returned object should be unreffed
7591 	 *     with g_object_unref() when no longer needed.
7592 	 */
7593 	extern(C) GDrive* function(GVolume* volume) getDrive;
7594 	/**
7595 	 *
7596 	 * Params:
7597 	 *     volume = a #GVolume
7598 	 * Return: a #GMount or %NULL if @volume isn't mounted.
7599 	 *     The returned object should be unreffed with g_object_unref()
7600 	 *     when no longer needed.
7601 	 */
7602 	extern(C) GMount* function(GVolume* volume) getMount;
7603 	/**
7604 	 *
7605 	 * Params:
7606 	 *     volume = a #GVolume
7607 	 * Return: %TRUE if the @volume can be mounted. %FALSE otherwise
7608 	 */
7609 	extern(C) int function(GVolume* volume) canMount;
7610 	/**
7611 	 *
7612 	 * Params:
7613 	 *     volume = a #GVolume
7614 	 * Return: %TRUE if the @volume can be ejected. %FALSE otherwise
7615 	 */
7616 	extern(C) int function(GVolume* volume) canEject;
7617 	extern(C) void function(GVolume* volume, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) mountFn;
7618 	/**
7619 	 *
7620 	 * Params:
7621 	 *     volume = a #GVolume
7622 	 *     result = a #GAsyncResult
7623 	 * Return: %TRUE, %FALSE if operation failed
7624 	 *
7625 	 * Throws: GException on failure.
7626 	 */
7627 	extern(C) int function(GVolume* volume, GAsyncResult* result, GError** err) mountFinish;
7628 	extern(C) void function(GVolume* volume, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) eject;
7629 	/**
7630 	 *
7631 	 * Params:
7632 	 *     volume = pointer to a #GVolume
7633 	 *     result = a #GAsyncResult
7634 	 * Return: %TRUE, %FALSE if operation failed
7635 	 *
7636 	 * Throws: GException on failure.
7637 	 */
7638 	extern(C) int function(GVolume* volume, GAsyncResult* result, GError** err) ejectFinish;
7639 	/**
7640 	 *
7641 	 * Params:
7642 	 *     volume = a #GVolume
7643 	 *     kind = the kind of identifier to return
7644 	 * Return: a newly allocated string containing the
7645 	 *     requested identfier, or %NULL if the #GVolume
7646 	 *     doesn't have this kind of identifier
7647 	 */
7648 	extern(C) char* function(GVolume* volume, const(char)* kind) getIdentifier;
7649 	/**
7650 	 *
7651 	 * Params:
7652 	 *     volume = a #GVolume
7653 	 * Return: a %NULL-terminated array
7654 	 *     of strings containing kinds of identifiers. Use g_strfreev() to free.
7655 	 */
7656 	extern(C) char** function(GVolume* volume) enumerateIdentifiers;
7657 	/**
7658 	 *
7659 	 * Params:
7660 	 *     volume = a #GVolume
7661 	 * Return: %TRUE if the volume should be automatically mounted
7662 	 */
7663 	extern(C) int function(GVolume* volume) shouldAutomount;
7664 	/**
7665 	 *
7666 	 * Params:
7667 	 *     volume = a #GVolume
7668 	 * Return: the activation root of @volume
7669 	 *     or %NULL. Use g_object_unref() to free.
7670 	 */
7671 	extern(C) GFile* function(GVolume* volume) getActivationRoot;
7672 	extern(C) void function(GVolume* volume, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectWithOperation;
7673 	/**
7674 	 *
7675 	 * Params:
7676 	 *     volume = a #GVolume
7677 	 *     result = a #GAsyncResult
7678 	 * Return: %TRUE if the volume was successfully ejected. %FALSE otherwise
7679 	 *
7680 	 * Throws: GException on failure.
7681 	 */
7682 	extern(C) int function(GVolume* volume, GAsyncResult* result, GError** err) ejectWithOperationFinish;
7683 	/**
7684 	 *
7685 	 * Params:
7686 	 *     volume = a #GVolume
7687 	 * Return: Sorting key for @volume or %NULL if no such key is available
7688 	 */
7689 	extern(C) const(char)* function(GVolume* volume) getSortKey;
7690 	/**
7691 	 *
7692 	 * Params:
7693 	 *     volume = a #GVolume
7694 	 * Return: a #GIcon.
7695 	 *     The returned object should be unreffed with g_object_unref()
7696 	 *     when no longer needed.
7697 	 */
7698 	extern(C) GIcon* function(GVolume* volume) getSymbolicIcon;
7699 }
7700 
7701 struct GVolumeMonitor
7702 {
7703 	GObject parentInstance;
7704 	void* priv;
7705 }
7706 
7707 struct GVolumeMonitorClass
7708 {
7709 	GObjectClass parentClass;
7710 	extern(C) void function(GVolumeMonitor* volumeMonitor, GVolume* volume) volumeAdded;
7711 	extern(C) void function(GVolumeMonitor* volumeMonitor, GVolume* volume) volumeRemoved;
7712 	extern(C) void function(GVolumeMonitor* volumeMonitor, GVolume* volume) volumeChanged;
7713 	extern(C) void function(GVolumeMonitor* volumeMonitor, GMount* mount) mountAdded;
7714 	extern(C) void function(GVolumeMonitor* volumeMonitor, GMount* mount) mountRemoved;
7715 	extern(C) void function(GVolumeMonitor* volumeMonitor, GMount* mount) mountPreUnmount;
7716 	extern(C) void function(GVolumeMonitor* volumeMonitor, GMount* mount) mountChanged;
7717 	extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveConnected;
7718 	extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveDisconnected;
7719 	extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveChanged;
7720 	extern(C) int function() isSupported;
7721 	/**
7722 	 *
7723 	 * Params:
7724 	 *     volumeMonitor = a #GVolumeMonitor.
7725 	 * Return: a #GList of connected #GDrive objects.
7726 	 */
7727 	extern(C) GList* function(GVolumeMonitor* volumeMonitor) getConnectedDrives;
7728 	/**
7729 	 *
7730 	 * Params:
7731 	 *     volumeMonitor = a #GVolumeMonitor.
7732 	 * Return: a #GList of #GVolume objects.
7733 	 */
7734 	extern(C) GList* function(GVolumeMonitor* volumeMonitor) getVolumes;
7735 	/**
7736 	 *
7737 	 * Params:
7738 	 *     volumeMonitor = a #GVolumeMonitor.
7739 	 * Return: a #GList of #GMount objects.
7740 	 */
7741 	extern(C) GList* function(GVolumeMonitor* volumeMonitor) getMounts;
7742 	/**
7743 	 *
7744 	 * Params:
7745 	 *     volumeMonitor = a #GVolumeMonitor.
7746 	 *     uuid = the UUID to look for
7747 	 * Return: a #GVolume or %NULL if no such volume is available.
7748 	 *     Free the returned object with g_object_unref().
7749 	 */
7750 	extern(C) GVolume* function(GVolumeMonitor* volumeMonitor, const(char)* uuid) getVolumeForUuid;
7751 	/**
7752 	 *
7753 	 * Params:
7754 	 *     volumeMonitor = a #GVolumeMonitor.
7755 	 *     uuid = the UUID to look for
7756 	 * Return: a #GMount or %NULL if no such mount is available.
7757 	 *     Free the returned object with g_object_unref().
7758 	 */
7759 	extern(C) GMount* function(GVolumeMonitor* volumeMonitor, const(char)* uuid) getMountForUuid;
7760 	extern(C) GVolume* function(GMount* mount, GVolumeMonitor* volumeMonitor) adoptOrphanMount;
7761 	extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveEjectButton;
7762 	extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveStopButton;
7763 	extern(C) void function() GReserved1;
7764 	extern(C) void function() GReserved2;
7765 	extern(C) void function() GReserved3;
7766 	extern(C) void function() GReserved4;
7767 	extern(C) void function() GReserved5;
7768 	extern(C) void function() GReserved6;
7769 }
7770 
7771 struct GZlibCompressor;
7772 
7773 struct GZlibCompressorClass
7774 {
7775 	GObjectClass parentClass;
7776 }
7777 
7778 struct GZlibDecompressor;
7779 
7780 struct GZlibDecompressorClass
7781 {
7782 	GObjectClass parentClass;
7783 }
7784 
7785 /**
7786  * Type definition for a function that will be called back when an asynchronous
7787  * operation within GIO has been completed.
7788  *
7789  * Params:
7790  *     sourceObject = the object the asynchronous operation was started with.
7791  *     res = a #GAsyncResult.
7792  *     userData = user data passed to the callback.
7793  */
7794 public alias extern(C) void function(GObject* sourceObject, GAsyncResult* res, void* userData) GAsyncReadyCallback;
7795 
7796 /**
7797  * Invoked when a connection to a message bus has been obtained.
7798  *
7799  * Params:
7800  *     connection = The #GDBusConnection to a message bus.
7801  *     name = The name that is requested to be owned.
7802  *     userData = User data passed to g_bus_own_name().
7803  *
7804  * Since: 2.26
7805  */
7806 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, void* userData) GBusAcquiredCallback;
7807 
7808 /**
7809  * Invoked when the name is acquired.
7810  *
7811  * Params:
7812  *     connection = The #GDBusConnection on which to acquired the name.
7813  *     name = The name being owned.
7814  *     userData = User data passed to g_bus_own_name() or g_bus_own_name_on_connection().
7815  *
7816  * Since: 2.26
7817  */
7818 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, void* userData) GBusNameAcquiredCallback;
7819 
7820 /**
7821  * Invoked when the name being watched is known to have to have a owner.
7822  *
7823  * Params:
7824  *     connection = The #GDBusConnection the name is being watched on.
7825  *     name = The name being watched.
7826  *     nameOwner = Unique name of the owner of the name being watched.
7827  *     userData = User data passed to g_bus_watch_name().
7828  *
7829  * Since: 2.26
7830  */
7831 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, const(char)* nameOwner, void* userData) GBusNameAppearedCallback;
7832 
7833 /**
7834  * Invoked when the name is lost or @connection has been closed.
7835  *
7836  * Params:
7837  *     connection = The #GDBusConnection on which to acquire the name or %NULL if
7838  *         the connection was disconnected.
7839  *     name = The name being owned.
7840  *     userData = User data passed to g_bus_own_name() or g_bus_own_name_on_connection().
7841  *
7842  * Since: 2.26
7843  */
7844 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, void* userData) GBusNameLostCallback;
7845 
7846 /**
7847  * Invoked when the name being watched is known not to have to have a owner.
7848  *
7849  * This is also invoked when the #GDBusConection on which the watch was
7850  * established has been closed.  In that case, @connection will be
7851  * %NULL.
7852  *
7853  * Params:
7854  *     connection = The #GDBusConnection the name is being watched on, or
7855  *         %NULL.
7856  *     name = The name being watched.
7857  *     userData = User data passed to g_bus_watch_name().
7858  *
7859  * Since: 2.26
7860  */
7861 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, void* userData) GBusNameVanishedCallback;
7862 
7863 /**
7864  * This is the function type of the callback used for the #GSource
7865  * returned by g_cancellable_source_new().
7866  *
7867  * Params:
7868  *     cancellable = the #GCancellable
7869  *     userData = data passed in by the user.
7870  *
7871  * Return: it should return %FALSE if the source should be removed.
7872  *
7873  * Since: 2.28
7874  */
7875 public alias extern(C) int function(GCancellable* cancellable, void* userData) GCancellableSourceFunc;
7876 
7877 /**
7878  * The type of the @get_property function in #GDBusInterfaceVTable.
7879  *
7880  * Params:
7881  *     connection = A #GDBusConnection.
7882  *     sender = The unique bus name of the remote caller.
7883  *     objectPath = The object path that the method was invoked on.
7884  *     interfaceName = The D-Bus interface name for the property.
7885  *     propertyName = The name of the property to get the value of.
7886  *     error = Return location for error.
7887  *     userData = The @user_data #gpointer passed to g_dbus_connection_register_object().
7888  *
7889  * Return: A #GVariant with the value for @property_name or %NULL if
7890  *     @error is set. If the returned #GVariant is floating, it is
7891  *     consumed - otherwise its reference count is decreased by one.
7892  *
7893  * Since: 2.26
7894  */
7895 public alias extern(C) GVariant* function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, const(char)* interfaceName, const(char)* propertyName, GError** error, void* userData) GDBusInterfaceGetPropertyFunc;
7896 
7897 /**
7898  * The type of the @method_call function in #GDBusInterfaceVTable.
7899  *
7900  * Params:
7901  *     connection = A #GDBusConnection.
7902  *     sender = The unique bus name of the remote caller.
7903  *     objectPath = The object path that the method was invoked on.
7904  *     interfaceName = The D-Bus interface name the method was invoked on.
7905  *     methodName = The name of the method that was invoked.
7906  *     parameters = A #GVariant tuple with parameters.
7907  *     invocation = A #GDBusMethodInvocation object that can be used to return a value or error.
7908  *     userData = The @user_data #gpointer passed to g_dbus_connection_register_object().
7909  *
7910  * Since: 2.26
7911  */
7912 public alias extern(C) void function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, const(char)* interfaceName, const(char)* methodName, GVariant* parameters, GDBusMethodInvocation* invocation, void* userData) GDBusInterfaceMethodCallFunc;
7913 
7914 /**
7915  * The type of the @set_property function in #GDBusInterfaceVTable.
7916  *
7917  * Params:
7918  *     connection = A #GDBusConnection.
7919  *     sender = The unique bus name of the remote caller.
7920  *     objectPath = The object path that the method was invoked on.
7921  *     interfaceName = The D-Bus interface name for the property.
7922  *     propertyName = The name of the property to get the value of.
7923  *     value = The value to set the property to.
7924  *     error = Return location for error.
7925  *     userData = The @user_data #gpointer passed to g_dbus_connection_register_object().
7926  *
7927  * Return: %TRUE if the property was set to @value, %FALSE if @error is set.
7928  *
7929  * Since: 2.26
7930  */
7931 public alias extern(C) int function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, const(char)* interfaceName, const(char)* propertyName, GVariant* value, GError** error, void* userData) GDBusInterfaceSetPropertyFunc;
7932 
7933 /**
7934  * Signature for function used in g_dbus_connection_add_filter().
7935  *
7936  * A filter function is passed a #GDBusMessage and expected to return
7937  * a #GDBusMessage too. Passive filter functions that don't modify the
7938  * message can simply return the @message object:
7939  * |[
7940  * static GDBusMessage *
7941  * passive_filter (GDBusConnection *connection
7942  * GDBusMessage    *message,
7943  * gboolean         incoming,
7944  * gpointer         user_data)
7945  * {
7946  * /<!-- -->* inspect @message *<!-- -->/
7947  * return message;
7948  * }
7949  * ]|
7950  * Filter functions that wants to drop a message can simply return %NULL:
7951  * |[
7952  * static GDBusMessage *
7953  * drop_filter (GDBusConnection *connection
7954  * GDBusMessage    *message,
7955  * gboolean         incoming,
7956  * gpointer         user_data)
7957  * {
7958  * if (should_drop_message)
7959  * {
7960  * g_object_unref (message);
7961  * message = NULL;
7962  * }
7963  * return message;
7964  * }
7965  * ]|
7966  * Finally, a filter function may modify a message by copying it:
7967  * |[
7968  * static GDBusMessage *
7969  * modifying_filter (GDBusConnection *connection
7970  * GDBusMessage    *message,
7971  * gboolean         incoming,
7972  * gpointer         user_data)
7973  * {
7974  * GDBusMessage *copy;
7975  * GError *error;
7976  *
7977  * error = NULL;
7978  * copy = g_dbus_message_copy (message, &error);
7979  * /<!-- -->* handle @error being is set *<!-- -->/
7980  * g_object_unref (message);
7981  *
7982  * /<!-- -->* modify @copy *<!-- -->/
7983  *
7984  * return copy;
7985  * }
7986  * ]|
7987  * If the returned #GDBusMessage is different from @message and cannot
7988  * be sent on @connection (it could use features, such as file
7989  * descriptors, not compatible with @connection), then a warning is
7990  * logged to <emphasis>standard error</emphasis>. Applications can
7991  * check this ahead of time using g_dbus_message_to_blob() passing a
7992  * #GDBusCapabilityFlags value obtained from @connection.
7993  *
7994  * Params:
7995  *     connection = A #GDBusConnection.
7996  *     message = A locked #GDBusMessage that the filter function takes ownership of.
7997  *     incoming = %TRUE if it is a message received from the other peer, %FALSE if it is
7998  *         a message to be sent to the other peer.
7999  *     userData = User data passed when adding the filter.
8000  *
8001  * Return: A #GDBusMessage that will be freed with
8002  *     g_object_unref() or %NULL to drop the message. Passive filter
8003  *     functions can simply return the passed @message object.
8004  *
8005  * Since: 2.26
8006  */
8007 public alias extern(C) GDBusMessage* function(GDBusConnection* connection, GDBusMessage* message, int incoming, void* userData) GDBusMessageFilterFunction;
8008 
8009 /**
8010  * Function signature for a function used to determine the #GType to
8011  * use for an interface proxy (if @interface_name is not %NULL) or
8012  * object proxy (if @interface_name is %NULL).
8013  *
8014  * This function is called in the
8015  * [thread-default main loop][g-main-context-push-thread-default]
8016  * that @manager was constructed in.
8017  *
8018  * Params:
8019  *     manager = A #GDBusObjectManagerClient.
8020  *     objectPath = The object path of the remote object.
8021  *     interfaceName = The interface name of the remote object or %NULL if a #GDBusObjectProxy #GType is requested.
8022  *     userData = User data.
8023  *
8024  * Return: A #GType to use for the remote object. The returned type
8025  *     must be a #GDBusProxy<!-- -->- or #GDBusObjectProxy<!-- -->-derived
8026  *     type.
8027  *
8028  * Since: 2.30
8029  */
8030 public alias extern(C) GType function(GDBusObjectManagerClient* manager, const(char)* objectPath, const(char)* interfaceName, void* userData) GDBusProxyTypeFunc;
8031 
8032 /**
8033  * Signature for callback function used in g_dbus_connection_signal_subscribe().
8034  *
8035  * Params:
8036  *     connection = A #GDBusConnection.
8037  *     senderName = The unique bus name of the sender of the signal.
8038  *     objectPath = The object path that the signal was emitted on.
8039  *     interfaceName = The name of the interface.
8040  *     signalName = The name of the signal.
8041  *     parameters = A #GVariant tuple with parameters for the signal.
8042  *     userData = User data passed when subscribing to the signal.
8043  *
8044  * Since: 2.26
8045  */
8046 public alias extern(C) void function(GDBusConnection* connection, const(char)* senderName, const(char)* objectPath, const(char)* interfaceName, const(char)* signalName, GVariant* parameters, void* userData) GDBusSignalCallback;
8047 
8048 /**
8049  * The type of the @dispatch function in #GDBusSubtreeVTable.
8050  *
8051  * Subtrees are flat.  @node, if non-%NULL, is always exactly one
8052  * segment of the object path (ie: it never contains a slash).
8053  *
8054  * Params:
8055  *     connection = A #GDBusConnection.
8056  *     sender = The unique bus name of the remote caller.
8057  *     objectPath = The object path that was registered with g_dbus_connection_register_subtree().
8058  *     interfaceName = The D-Bus interface name that the method call or property access is for.
8059  *     node = A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree.
8060  *     outUserData = Return location for user data to pass to functions in the returned #GDBusInterfaceVTable (never %NULL).
8061  *     userData = The @user_data #gpointer passed to g_dbus_connection_register_subtree().
8062  *
8063  * Return: A #GDBusInterfaceVTable or %NULL if you don't want to handle the methods.
8064  *
8065  * Since: 2.26
8066  */
8067 public alias extern(C) GDBusInterfaceVTable* function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, const(char)* interfaceName, const(char)* node, void** outUserData, void* userData) GDBusSubtreeDispatchFunc;
8068 
8069 /**
8070  * The type of the @enumerate function in #GDBusSubtreeVTable.
8071  *
8072  * This function is called when generating introspection data and also
8073  * when preparing to dispatch incoming messages in the event that the
8074  * %G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is not
8075  * specified (ie: to verify that the object path is valid).
8076  *
8077  * Hierarchies are not supported; the items that you return should not
8078  * contain the '/' character.
8079  *
8080  * The return value will be freed with g_strfreev().
8081  *
8082  * Params:
8083  *     connection = A #GDBusConnection.
8084  *     sender = The unique bus name of the remote caller.
8085  *     objectPath = The object path that was registered with g_dbus_connection_register_subtree().
8086  *     userData = The @user_data #gpointer passed to g_dbus_connection_register_subtree().
8087  *
8088  * Return: A newly allocated array of strings for node names that are children of @object_path.
8089  *
8090  * Since: 2.26
8091  */
8092 public alias extern(C) char** function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, void* userData) GDBusSubtreeEnumerateFunc;
8093 
8094 /**
8095  * The type of the @introspect function in #GDBusSubtreeVTable.
8096  *
8097  * Subtrees are flat.  @node, if non-%NULL, is always exactly one
8098  * segment of the object path (ie: it never contains a slash).
8099  *
8100  * This function should return %NULL to indicate that there is no object
8101  * at this node.
8102  *
8103  * If this function returns non-%NULL, the return value is expected to
8104  * be a %NULL-terminated array of pointers to #GDBusInterfaceInfo
8105  * structures describing the interfaces implemented by @node.  This
8106  * array will have g_dbus_interface_info_unref() called on each item
8107  * before being freed with g_free().
8108  *
8109  * The difference between returning %NULL and an array containing zero
8110  * items is that the standard DBus interfaces will returned to the
8111  * remote introspector in the empty array case, but not in the %NULL
8112  * case.
8113  *
8114  * Params:
8115  *     connection = A #GDBusConnection.
8116  *     sender = The unique bus name of the remote caller.
8117  *     objectPath = The object path that was registered with g_dbus_connection_register_subtree().
8118  *     node = A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree.
8119  *     userData = The @user_data #gpointer passed to g_dbus_connection_register_subtree().
8120  *
8121  * Return: A %NULL-terminated array of pointers to #GDBusInterfaceInfo, or %NULL.
8122  *
8123  * Since: 2.26
8124  */
8125 public alias extern(C) GDBusInterfaceInfo** function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, const(char)* node, void* userData) GDBusSubtreeIntrospectFunc;
8126 
8127 /**
8128  * During invocation, g_desktop_app_info_launch_uris_as_manager() may
8129  * create one or more child processes.  This callback is invoked once
8130  * for each, providing the process ID.
8131  *
8132  * Params:
8133  *     appinfo = a #GDesktopAppInfo
8134  *     pid = Process identifier
8135  *     userData = User data
8136  */
8137 public alias extern(C) void function(GDesktopAppInfo* appinfo, GPid pid, void* userData) GDesktopAppLaunchCallback;
8138 
8139 /**
8140  * This callback type is used by g_file_measure_disk_usage() to make
8141  * periodic progress reports when measuring the amount of disk spaced
8142  * used by a directory.
8143  *
8144  * These calls are made on a best-effort basis and not all types of
8145  * #GFile will support them.  At the minimum, however, one call will
8146  * always be made immediately.
8147  *
8148  * In the case that there is no support, @reporting will be set to
8149  * %FALSE (and the other values undefined) and no further calls will be
8150  * made.  Otherwise, the @reporting will be %TRUE and the other values
8151  * all-zeros during the first (immediate) call.  In this way, you can
8152  * know which type of progress UI to show without a delay.
8153  *
8154  * For g_file_measure_disk_usage() the callback is made directly.  For
8155  * g_file_measure_disk_usage_async() the callback is made via the
8156  * default main context of the calling thread (ie: the same way that the
8157  * final async result would be reported).
8158  *
8159  * @current_size is in the same units as requested by the operation (see
8160  * %G_FILE_DISK_USAGE_APPARENT_SIZE).
8161  *
8162  * The frequency of the updates is implementation defined, but is
8163  * ideally about once every 200ms.
8164  *
8165  * The last progress callback may or may not be equal to the final
8166  * result.  Always check the async result to get the final value.
8167  *
8168  * Params:
8169  *     reporting = %TRUE if more reports will come
8170  *     currentSize = the current cumulative size measurement
8171  *     numDirs = the number of directories visited so far
8172  *     numFiles = the number of non-directory files encountered
8173  *     userData = the data passed to the original request for this callback
8174  *
8175  * Since: 2.38
8176  */
8177 public alias extern(C) void function(int reporting, ulong currentSize, ulong numDirs, ulong numFiles, void* userData) GFileMeasureProgressCallback;
8178 
8179 /**
8180  * When doing file operations that may take a while, such as moving
8181  * a file or copying a file, a progress callback is used to pass how
8182  * far along that operation is to the application.
8183  *
8184  * Params:
8185  *     currentNumBytes = the current number of bytes in the operation.
8186  *     totalNumBytes = the total number of bytes in the operation.
8187  *     userData = user data passed to the callback.
8188  */
8189 public alias extern(C) void function(long currentNumBytes, long totalNumBytes, void* userData) GFileProgressCallback;
8190 
8191 /**
8192  * When loading the partial contents of a file with g_file_load_partial_contents_async(),
8193  * it may become necessary to determine if any more data from the file should be loaded.
8194  * A #GFileReadMoreCallback function facilitates this by returning %TRUE if more data
8195  * should be read, or %FALSE otherwise.
8196  *
8197  * Params:
8198  *     fileContents = the data as currently read.
8199  *     fileSize = the size of the data currently read.
8200  *     callbackData = data passed to the callback.
8201  *
8202  * Return: %TRUE if more data should be read back. %FALSE otherwise.
8203  */
8204 public alias extern(C) int function(const(char)* fileContents, long fileSize, void* callbackData) GFileReadMoreCallback;
8205 
8206 /**
8207  * I/O Job function.
8208  *
8209  * Long-running jobs should periodically check the @cancellable
8210  * to see if they have been cancelled.
8211  *
8212  * Params:
8213  *     job = a #GIOSchedulerJob.
8214  *     cancellable = optional #GCancellable object, %NULL to ignore.
8215  *     userData = the data to pass to callback function
8216  *
8217  * Return: %TRUE if this function should be called again to
8218  *     complete the job, %FALSE if the job is complete (or cancelled)
8219  */
8220 public alias extern(C) int function(GIOSchedulerJob* job, GCancellable* cancellable, void* userData) GIOSchedulerJobFunc;
8221 
8222 /**
8223  * This is the function type of the callback used for the #GSource
8224  * returned by g_pollable_input_stream_create_source() and
8225  * g_pollable_output_stream_create_source().
8226  *
8227  * Params:
8228  *     pollableStream = the #GPollableInputStream or #GPollableOutputStream
8229  *     userData = data passed in by the user.
8230  *
8231  * Return: it should return %FALSE if the source should be removed.
8232  *
8233  * Since: 2.28
8234  */
8235 public alias extern(C) int function(GObject* pollableStream, void* userData) GPollableSourceFunc;
8236 
8237 /**
8238  * Changes the size of the memory block pointed to by @data to
8239  * @size bytes.
8240  *
8241  * The function should have the same semantics as realloc().
8242  *
8243  * Params:
8244  *     data = memory block to reallocate
8245  *     size = size to reallocate @data to
8246  *
8247  * Return: a pointer to the reallocated memory
8248  */
8249 public alias extern(C) void* function(void* data, size_t size) GReallocFunc;
8250 
8251 /**
8252  * The type for the function that is used to convert from #GSettings to
8253  * an object property. The @value is already initialized to hold values
8254  * of the appropriate type.
8255  *
8256  * Params:
8257  *     value = return location for the property value
8258  *     variant = the #GVariant
8259  *     userData = user data that was specified when the binding was created
8260  *
8261  * Return: %TRUE if the conversion succeeded, %FALSE in case of an error
8262  */
8263 public alias extern(C) int function(GValue* value, GVariant* variant, void* userData) GSettingsBindGetMapping;
8264 
8265 /**
8266  * The type for the function that is used to convert an object property
8267  * value to a #GVariant for storing it in #GSettings.
8268  *
8269  * Params:
8270  *     value = a #GValue containing the property value to map
8271  *     expectedType = the #GVariantType to create
8272  *     userData = user data that was specified when the binding was created
8273  *
8274  * Return: a new #GVariant holding the data from @value,
8275  *     or %NULL in case of an error
8276  */
8277 public alias extern(C) GVariant* function(GValue* value, GVariantType* expectedType, void* userData) GSettingsBindSetMapping;
8278 
8279 /**
8280  * The type of the function that is used to convert from a value stored
8281  * in a #GSettings to a value that is useful to the application.
8282  *
8283  * If the value is successfully mapped, the result should be stored at
8284  * @result and %TRUE returned.  If mapping fails (for example, if @value
8285  * is not in the right format) then %FALSE should be returned.
8286  *
8287  * If @value is %NULL then it means that the mapping function is being
8288  * given a "last chance" to successfully return a valid value.  %TRUE
8289  * must be returned in this case.
8290  *
8291  * Params:
8292  *     value = the #GVariant to map, or %NULL
8293  *     result = the result of the mapping
8294  *     userData = the user data that was passed to
8295  *         g_settings_get_mapped()
8296  *
8297  * Return: %TRUE if the conversion succeeded, %FALSE in case of an error
8298  */
8299 public alias extern(C) int function(GVariant* value, void** result, void* userData) GSettingsGetMapping;
8300 
8301 /**
8302  * Simple thread function that runs an asynchronous operation and
8303  * checks for cancellation.
8304  *
8305  * Params:
8306  *     res = a #GSimpleAsyncResult.
8307  *     object = a #GObject.
8308  *     cancellable = optional #GCancellable object, %NULL to ignore.
8309  */
8310 public alias extern(C) void function(GSimpleAsyncResult* res, GObject* object, GCancellable* cancellable) GSimpleAsyncThreadFunc;
8311 
8312 /**
8313  * This is the function type of the callback used for the #GSource
8314  * returned by g_socket_create_source().
8315  *
8316  * Params:
8317  *     socket = the #GSocket
8318  *     condition = the current condition at the source fired.
8319  *     userData = data passed in by the user.
8320  *
8321  * Return: it should return %FALSE if the source should be removed.
8322  *
8323  * Since: 2.22
8324  */
8325 public alias extern(C) int function(GSocket* socket, GIOCondition condition, void* userData) GSocketSourceFunc;
8326 
8327 /**
8328  * The prototype for a task function to be run in a thread via
8329  * g_task_run_in_thread() or g_task_run_in_thread_sync().
8330  *
8331  * If the return-on-cancel flag is set on @task, and @cancellable gets
8332  * cancelled, then the #GTask will be completed immediately (as though
8333  * g_task_return_error_if_cancelled() had been called), without
8334  * waiting for the task function to complete. However, the task
8335  * function will continue running in its thread in the background. The
8336  * function therefore needs to be careful about how it uses
8337  * externally-visible state in this case. See
8338  * g_task_set_return_on_cancel() for more details.
8339  *
8340  * Other than in that case, @task will be completed when the
8341  * #GTaskThreadFunc returns, not when it calls a
8342  * `g_task_return_` function.
8343  *
8344  * Params:
8345  *     task = the #GTask
8346  *     sourceObject = @task's source object
8347  *     taskData = @task's task data
8348  *     cancellable = @task's #GCancellable, or %NULL
8349  *
8350  * Since: 2.36
8351  */
8352 public alias extern(C) void function(GTask* task, void* sourceObject, void* taskData, GCancellable* cancellable) GTaskThreadFunc;