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