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

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

Initial release

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