gioenums.go RawHistoryFolder

1// Package gio was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package gio
3
4import (
5	"github.com/bnema/puregotk/v4/gobject/types"
6)
7
8// Flags used when creating a #GAppInfo.
9type AppInfoCreateFlags int
10
11var xAppInfoCreateFlagsGLibType func() types.GType
12
13func AppInfoCreateFlagsGLibType() types.GType {
14	return xAppInfoCreateFlagsGLibType()
15}
16
17const (
18
19	// No flags.
20	GAppInfoCreateNoneValue AppInfoCreateFlags = 0
21	// Application opens in a terminal window.
22	GAppInfoCreateNeedsTerminalValue AppInfoCreateFlags = 1
23	// Application supports URI arguments.
24	GAppInfoCreateSupportsUrisValue AppInfoCreateFlags = 2
25	// Application supports startup notification. Since 2.26
26	GAppInfoCreateSupportsStartupNotificationValue AppInfoCreateFlags = 4
27)
28
29// Flags used to define the behaviour of a #GApplication.
30type ApplicationFlags int
31
32var xApplicationFlagsGLibType func() types.GType
33
34func ApplicationFlagsGLibType() types.GType {
35	return xApplicationFlagsGLibType()
36}
37
38const (
39
40	// Default flags.
41	GApplicationFlagsNoneValue ApplicationFlags = 0
42	// Default flags.
43	GApplicationDefaultFlagsValue ApplicationFlags = 0
44	// Run as a service. In this mode, registration
45	//      fails if the service is already running, and the application
46	//      will initially wait up to 10 seconds for an initial activation
47	//      message to arrive.
48	GApplicationIsServiceValue ApplicationFlags = 1
49	// Don't try to become the primary instance.
50	GApplicationIsLauncherValue ApplicationFlags = 2
51	// This application handles opening files (in
52	//     the primary instance). Note that this flag only affects the default
53	//     implementation of local_command_line(), and has no effect if
54	//     %G_APPLICATION_HANDLES_COMMAND_LINE is given.
55	//     See g_application_run() for details.
56	GApplicationHandlesOpenValue ApplicationFlags = 4
57	// This application handles command line
58	//     arguments (in the primary instance). Note that this flag only affect
59	//     the default implementation of local_command_line().
60	//     See g_application_run() for details.
61	GApplicationHandlesCommandLineValue ApplicationFlags = 8
62	// Send the environment of the
63	//     launching process to the primary instance. Set this flag if your
64	//     application is expected to behave differently depending on certain
65	//     environment variables. For instance, an editor might be expected
66	//     to use the `GIT_COMMITTER_NAME` environment variable
67	//     when editing a git commit message. The environment is available
68	//     to the #GApplication::command-line signal handler, via
69	//     g_application_command_line_getenv().
70	GApplicationSendEnvironmentValue ApplicationFlags = 16
71	// Make no attempts to do any of the typical
72	//     single-instance application negotiation, even if the application
73	//     ID is given.  The application neither attempts to become the
74	//     owner of the application ID nor does it check if an existing
75	//     owner already exists.  Everything occurs in the local process.
76	//     Since: 2.30.
77	GApplicationNonUniqueValue ApplicationFlags = 32
78	// Allow users to override the
79	//     application ID from the command line with `--gapplication-app-id`.
80	//     Since: 2.48
81	GApplicationCanOverrideAppIdValue ApplicationFlags = 64
82	// Allow another instance to take over
83	//     the bus name. Since: 2.60
84	GApplicationAllowReplacementValue ApplicationFlags = 128
85	// Take over from another instance. This flag is
86	//     usually set by passing `--gapplication-replace` on the commandline.
87	//     Since: 2.60
88	GApplicationReplaceValue ApplicationFlags = 256
89)
90
91// #GAskPasswordFlags are used to request specific information from the
92// user, or to notify the user of their choices in an authentication
93// situation.
94type AskPasswordFlags int
95
96var xAskPasswordFlagsGLibType func() types.GType
97
98func AskPasswordFlagsGLibType() types.GType {
99	return xAskPasswordFlagsGLibType()
100}
101
102const (
103
104	// operation requires a password.
105	GAskPasswordNeedPasswordValue AskPasswordFlags = 1
106	// operation requires a username.
107	GAskPasswordNeedUsernameValue AskPasswordFlags = 2
108	// operation requires a domain.
109	GAskPasswordNeedDomainValue AskPasswordFlags = 4
110	// operation supports saving settings.
111	GAskPasswordSavingSupportedValue AskPasswordFlags = 8
112	// operation supports anonymous users.
113	GAskPasswordAnonymousSupportedValue AskPasswordFlags = 16
114	// operation takes TCRYPT parameters (Since: 2.58)
115	GAskPasswordTcryptValue AskPasswordFlags = 32
116)
117
118// Flags used in g_bus_own_name().
119type BusNameOwnerFlags int
120
121var xBusNameOwnerFlagsGLibType func() types.GType
122
123func BusNameOwnerFlagsGLibType() types.GType {
124	return xBusNameOwnerFlagsGLibType()
125}
126
127const (
128
129	// No flags set.
130	GBusNameOwnerFlagsNoneValue BusNameOwnerFlags = 0
131	// Allow another message bus connection to claim the name.
132	GBusNameOwnerFlagsAllowReplacementValue BusNameOwnerFlags = 1
133	// If another message bus connection owns the name and have
134	// specified %G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT, then take the name from the other connection.
135	GBusNameOwnerFlagsReplaceValue BusNameOwnerFlags = 2
136	// If another message bus connection owns the name, immediately return an error
137	// from [func@Gio.bus_own_name] rather than entering the waiting queue for that
138	// name.
139	GBusNameOwnerFlagsDoNotQueueValue BusNameOwnerFlags = 4
140)
141
142// Flags used in g_bus_watch_name().
143type BusNameWatcherFlags int
144
145var xBusNameWatcherFlagsGLibType func() types.GType
146
147func BusNameWatcherFlagsGLibType() types.GType {
148	return xBusNameWatcherFlagsGLibType()
149}
150
151const (
152
153	// No flags set.
154	GBusNameWatcherFlagsNoneValue BusNameWatcherFlags = 0
155	// If no-one owns the name when
156	// beginning to watch the name, ask the bus to launch an owner for the
157	// name.
158	GBusNameWatcherFlagsAutoStartValue BusNameWatcherFlags = 1
159)
160
161// Flags used when calling a g_converter_convert().
162type ConverterFlags int
163
164var xConverterFlagsGLibType func() types.GType
165
166func ConverterFlagsGLibType() types.GType {
167	return xConverterFlagsGLibType()
168}
169
170const (
171
172	// No flags.
173	GConverterNoFlagsValue ConverterFlags = 0
174	// At end of input data
175	GConverterInputAtEndValue ConverterFlags = 1
176	// Flush data
177	GConverterFlushValue ConverterFlags = 2
178)
179
180// Flags used in g_dbus_connection_call() and similar APIs.
181type DBusCallFlags int
182
183var xDBusCallFlagsGLibType func() types.GType
184
185func DBusCallFlagsGLibType() types.GType {
186	return xDBusCallFlagsGLibType()
187}
188
189const (
190
191	// No flags set.
192	GDbusCallFlagsNoneValue DBusCallFlags = 0
193	// The bus must not launch
194	// an owner for the destination name in response to this method
195	// invocation.
196	GDbusCallFlagsNoAutoStartValue DBusCallFlags = 1
197	// the caller is prepared to
198	// wait for interactive authorization. Since 2.46.
199	GDbusCallFlagsAllowInteractiveAuthorizationValue DBusCallFlags = 2
200)
201
202// Capabilities negotiated with the remote peer.
203type DBusCapabilityFlags int
204
205var xDBusCapabilityFlagsGLibType func() types.GType
206
207func DBusCapabilityFlagsGLibType() types.GType {
208	return xDBusCapabilityFlagsGLibType()
209}
210
211const (
212
213	// No flags set.
214	GDbusCapabilityFlagsNoneValue DBusCapabilityFlags = 0
215	// The connection
216	// supports exchanging UNIX file descriptors with the remote peer.
217	GDbusCapabilityFlagsUnixFdPassingValue DBusCapabilityFlags = 1
218)
219
220// Flags used when creating a new #GDBusConnection.
221type DBusConnectionFlags int
222
223var xDBusConnectionFlagsGLibType func() types.GType
224
225func DBusConnectionFlagsGLibType() types.GType {
226	return xDBusConnectionFlagsGLibType()
227}
228
229const (
230
231	// No flags set.
232	GDbusConnectionFlagsNoneValue DBusConnectionFlags = 0
233	// Perform authentication against server.
234	GDbusConnectionFlagsAuthenticationClientValue DBusConnectionFlags = 1
235	// Perform authentication against client.
236	GDbusConnectionFlagsAuthenticationServerValue DBusConnectionFlags = 2
237	// When
238	// authenticating as a server, allow the anonymous authentication
239	// method.
240	GDbusConnectionFlagsAuthenticationAllowAnonymousValue DBusConnectionFlags = 4
241	// Pass this flag if connecting to a peer that is a
242	// message bus. This means that the Hello() method will be invoked as part of the connection setup.
243	GDbusConnectionFlagsMessageBusConnectionValue DBusConnectionFlags = 8
244	// If set, processing of D-Bus messages is
245	// delayed until g_dbus_connection_start_message_processing() is called.
246	GDbusConnectionFlagsDelayMessageProcessingValue DBusConnectionFlags = 16
247	// When authenticating
248	// as a server, require the UID of the peer to be the same as the UID of the server. (Since: 2.68)
249	GDbusConnectionFlagsAuthenticationRequireSameUserValue DBusConnectionFlags = 32
250	// When authenticating, try to use
251	//  protocols that work across a Linux user namespace boundary, even if this
252	//  reduces interoperability with older D-Bus implementations. This currently
253	//  affects client-side `EXTERNAL` authentication, for which this flag makes
254	//  connections to a server in another user namespace succeed, but causes
255	//  a deadlock when connecting to a GDBus server older than 2.73.3. Since: 2.74
256	GDbusConnectionFlagsCrossNamespaceValue DBusConnectionFlags = 64
257)
258
259// Flags describing the behavior of a #GDBusInterfaceSkeleton instance.
260type DBusInterfaceSkeletonFlags int
261
262var xDBusInterfaceSkeletonFlagsGLibType func() types.GType
263
264func DBusInterfaceSkeletonFlagsGLibType() types.GType {
265	return xDBusInterfaceSkeletonFlagsGLibType()
266}
267
268const (
269
270	// No flags set.
271	GDbusInterfaceSkeletonFlagsNoneValue DBusInterfaceSkeletonFlags = 0
272	// Each method invocation is handled in
273	//   a thread dedicated to the invocation. This means that the method implementation can use blocking IO
274	//   without blocking any other part of the process. It also means that the method implementation must
275	//   use locking to access data structures used by other threads.
276	GDbusInterfaceSkeletonFlagsHandleMethodInvocationsInThreadValue DBusInterfaceSkeletonFlags = 1
277)
278
279// Message flags used in #GDBusMessage.
280type DBusMessageFlags int
281
282var xDBusMessageFlagsGLibType func() types.GType
283
284func DBusMessageFlagsGLibType() types.GType {
285	return xDBusMessageFlagsGLibType()
286}
287
288const (
289
290	// No flags set.
291	GDbusMessageFlagsNoneValue DBusMessageFlags = 0
292	// A reply is not expected.
293	GDbusMessageFlagsNoReplyExpectedValue DBusMessageFlags = 1
294	// The bus must not launch an
295	// owner for the destination name in response to this message.
296	GDbusMessageFlagsNoAutoStartValue DBusMessageFlags = 2
297	// If set on a method
298	// call, this flag means that the caller is prepared to wait for interactive
299	// authorization. Since 2.46.
300	GDbusMessageFlagsAllowInteractiveAuthorizationValue DBusMessageFlags = 4
301)
302
303// Flags used when constructing a #GDBusObjectManagerClient.
304type DBusObjectManagerClientFlags int
305
306var xDBusObjectManagerClientFlagsGLibType func() types.GType
307
308func DBusObjectManagerClientFlagsGLibType() types.GType {
309	return xDBusObjectManagerClientFlagsGLibType()
310}
311
312const (
313
314	// No flags set.
315	GDbusObjectManagerClientFlagsNoneValue DBusObjectManagerClientFlags = 0
316	// If not set and the
317	//   manager is for a well-known name, then request the bus to launch
318	//   an owner for the name if no-one owns the name. This flag can only
319	//   be used in managers for well-known names.
320	GDbusObjectManagerClientFlagsDoNotAutoStartValue DBusObjectManagerClientFlags = 1
321)
322
323// Flags describing the access control of a D-Bus property.
324type DBusPropertyInfoFlags int
325
326var xDBusPropertyInfoFlagsGLibType func() types.GType
327
328func DBusPropertyInfoFlagsGLibType() types.GType {
329	return xDBusPropertyInfoFlagsGLibType()
330}
331
332const (
333
334	// No flags set.
335	GDbusPropertyInfoFlagsNoneValue DBusPropertyInfoFlags = 0
336	// Property is readable.
337	GDbusPropertyInfoFlagsReadableValue DBusPropertyInfoFlags = 1
338	// Property is writable.
339	GDbusPropertyInfoFlagsWritableValue DBusPropertyInfoFlags = 2
340)
341
342// Flags used when constructing an instance of a #GDBusProxy derived class.
343type DBusProxyFlags int
344
345var xDBusProxyFlagsGLibType func() types.GType
346
347func DBusProxyFlagsGLibType() types.GType {
348	return xDBusProxyFlagsGLibType()
349}
350
351const (
352
353	// No flags set.
354	GDbusProxyFlagsNoneValue DBusProxyFlags = 0
355	// Don't load properties.
356	GDbusProxyFlagsDoNotLoadPropertiesValue DBusProxyFlags = 1
357	// Don't connect to signals on the remote object.
358	GDbusProxyFlagsDoNotConnectSignalsValue DBusProxyFlags = 2
359	// If the proxy is for a well-known name,
360	// do not ask the bus to launch an owner during proxy initialization or a method call.
361	// This flag is only meaningful in proxies for well-known names.
362	GDbusProxyFlagsDoNotAutoStartValue DBusProxyFlags = 4
363	// If set, the property value for any __invalidated property__ will be (asynchronously) retrieved upon receiving the [`PropertiesChanged`](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties) D-Bus signal and the property will not cause emission of the #GDBusProxy::g-properties-changed signal. When the value is received the #GDBusProxy::g-properties-changed signal is emitted for the property along with the retrieved value. Since 2.32.
364	GDbusProxyFlagsGetInvalidatedPropertiesValue DBusProxyFlags = 8
365	// If the proxy is for a well-known name,
366	// do not ask the bus to launch an owner during proxy initialization, but allow it to be
367	// autostarted by a method call. This flag is only meaningful in proxies for well-known names,
368	// and only if %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START is not also specified.
369	GDbusProxyFlagsDoNotAutoStartAtConstructionValue DBusProxyFlags = 16
370	// Don't actually send the AddMatch D-Bus
371	//    call for this signal subscription. This gives you more control
372	//    over which match rules you add (but you must add them manually). (Since: 2.72)
373	GDbusProxyFlagsNoMatchRuleValue DBusProxyFlags = 32
374)
375
376// Flags used when sending #GDBusMessages on a #GDBusConnection.
377type DBusSendMessageFlags int
378
379var xDBusSendMessageFlagsGLibType func() types.GType
380
381func DBusSendMessageFlagsGLibType() types.GType {
382	return xDBusSendMessageFlagsGLibType()
383}
384
385const (
386
387	// No flags set.
388	GDbusSendMessageFlagsNoneValue DBusSendMessageFlags = 0
389	// Do not automatically
390	// assign a serial number from the #GDBusConnection object when
391	// sending a message.
392	GDbusSendMessageFlagsPreserveSerialValue DBusSendMessageFlags = 1
393)
394
395// Flags used when creating a #GDBusServer.
396type DBusServerFlags int
397
398var xDBusServerFlagsGLibType func() types.GType
399
400func DBusServerFlagsGLibType() types.GType {
401	return xDBusServerFlagsGLibType()
402}
403
404const (
405
406	// No flags set.
407	GDbusServerFlagsNoneValue DBusServerFlags = 0
408	// All #GDBusServer::new-connection
409	// signals will run in separated dedicated threads (see signal for
410	// details).
411	GDbusServerFlagsRunInThreadValue DBusServerFlags = 1
412	// Allow the anonymous
413	// authentication method.
414	GDbusServerFlagsAuthenticationAllowAnonymousValue DBusServerFlags = 2
415	// Require the UID of the
416	// peer to be the same as the UID of the server when authenticating. (Since: 2.68)
417	GDbusServerFlagsAuthenticationRequireSameUserValue DBusServerFlags = 4
418)
419
420// Flags used when subscribing to signals via g_dbus_connection_signal_subscribe().
421type DBusSignalFlags int
422
423var xDBusSignalFlagsGLibType func() types.GType
424
425func DBusSignalFlagsGLibType() types.GType {
426	return xDBusSignalFlagsGLibType()
427}
428
429const (
430
431	// No flags set.
432	GDbusSignalFlagsNoneValue DBusSignalFlags = 0
433	// Don't actually send the AddMatch
434	// D-Bus call for this signal subscription.  This gives you more control
435	// over which match rules you add (but you must add them manually).
436	GDbusSignalFlagsNoMatchRuleValue DBusSignalFlags = 1
437	// Match first arguments that
438	// contain a bus or interface name with the given namespace.
439	GDbusSignalFlagsMatchArg0NamespaceValue DBusSignalFlags = 2
440	// Match first arguments that
441	// contain an object path that is either equivalent to the given path,
442	// or one of the paths is a subpath of the other.
443	GDbusSignalFlagsMatchArg0PathValue DBusSignalFlags = 4
444)
445
446// Flags passed to g_dbus_connection_register_subtree().
447type DBusSubtreeFlags int
448
449var xDBusSubtreeFlagsGLibType func() types.GType
450
451func DBusSubtreeFlagsGLibType() types.GType {
452	return xDBusSubtreeFlagsGLibType()
453}
454
455const (
456
457	// No flags set.
458	GDbusSubtreeFlagsNoneValue DBusSubtreeFlags = 0
459	// Method calls to objects not in the enumerated range
460	//                                                       will still be dispatched. This is useful if you want
461	//                                                       to dynamically spawn objects in the subtree.
462	GDbusSubtreeFlagsDispatchToUnenumeratedNodesValue DBusSubtreeFlags = 1
463)
464
465// Flags used when starting a drive.
466type DriveStartFlags int
467
468var xDriveStartFlagsGLibType func() types.GType
469
470func DriveStartFlagsGLibType() types.GType {
471	return xDriveStartFlagsGLibType()
472}
473
474const (
475
476	// No flags set.
477	GDriveStartNoneValue DriveStartFlags = 0
478)
479
480// Flags specifying the behaviour of an attribute.
481type FileAttributeInfoFlags int
482
483var xFileAttributeInfoFlagsGLibType func() types.GType
484
485func FileAttributeInfoFlagsGLibType() types.GType {
486	return xFileAttributeInfoFlagsGLibType()
487}
488
489const (
490
491	// no flags set.
492	GFileAttributeInfoNoneValue FileAttributeInfoFlags = 0
493	// copy the attribute values when the file is copied.
494	GFileAttributeInfoCopyWithFileValue FileAttributeInfoFlags = 1
495	// copy the attribute values when the file is moved.
496	GFileAttributeInfoCopyWhenMovedValue FileAttributeInfoFlags = 2
497)
498
499// Flags used when copying or moving files.
500type FileCopyFlags int
501
502var xFileCopyFlagsGLibType func() types.GType
503
504func FileCopyFlagsGLibType() types.GType {
505	return xFileCopyFlagsGLibType()
506}
507
508const (
509
510	// No flags set.
511	GFileCopyNoneValue FileCopyFlags = 0
512	// Overwrite any existing files
513	GFileCopyOverwriteValue FileCopyFlags = 1
514	// Make a backup of any existing files.
515	GFileCopyBackupValue FileCopyFlags = 2
516	// Don't follow symlinks.
517	GFileCopyNofollowSymlinksValue FileCopyFlags = 4
518	// Copy all file metadata instead of just default set used for copy (see #GFileInfo).
519	GFileCopyAllMetadataValue FileCopyFlags = 8
520	// Don't use copy and delete fallback if native move not supported.
521	GFileCopyNoFallbackForMoveValue FileCopyFlags = 16
522	// Leaves target file with default perms, instead of setting the source file perms.
523	GFileCopyTargetDefaultPermsValue FileCopyFlags = 32
524	// Use default modification
525	//     timestamps instead of copying them from the source file. Since 2.80
526	GFileCopyTargetDefaultModifiedTimeValue FileCopyFlags = 64
527)
528
529// Flags used when an operation may create a file.
530type FileCreateFlags int
531
532var xFileCreateFlagsGLibType func() types.GType
533
534func FileCreateFlagsGLibType() types.GType {
535	return xFileCreateFlagsGLibType()
536}
537
538const (
539
540	// No flags set.
541	GFileCreateNoneValue FileCreateFlags = 0
542	// Create a file that can only be
543	//    accessed by the current user.
544	GFileCreatePrivateValue FileCreateFlags = 1
545	// Replace the destination
546	//    as if it didn't exist before. Don't try to keep any old
547	//    permissions, replace instead of following links. This
548	//    is generally useful if you're doing a "copy over"
549	//    rather than a "save new version of" replace operation.
550	//    You can think of it as "unlink destination" before
551	//    writing to it, although the implementation may not
552	//    be exactly like that. This flag can only be used with
553	//    g_file_replace() and its variants, including g_file_replace_contents().
554	//    Since 2.20
555	GFileCreateReplaceDestinationValue FileCreateFlags = 2
556)
557
558// Flags that can be used with g_file_measure_disk_usage().
559type FileMeasureFlags int
560
561var xFileMeasureFlagsGLibType func() types.GType
562
563func FileMeasureFlagsGLibType() types.GType {
564	return xFileMeasureFlagsGLibType()
565}
566
567const (
568
569	// No flags set.
570	GFileMeasureNoneValue FileMeasureFlags = 0
571	// Report any error encountered
572	//   while traversing the directory tree.  Normally errors are only
573	//   reported for the toplevel file.
574	GFileMeasureReportAnyErrorValue FileMeasureFlags = 2
575	// Tally usage based on apparent file
576	//   sizes.  Normally, the block-size is used, if available, as this is a
577	//   more accurate representation of disk space used.
578	//   Compare with `du --apparent-size`.
579	//   Since GLib 2.78. and similarly to `du` since GNU Coreutils 9.2, this will
580	//   ignore the sizes of file types other than regular files and links, as the
581	//   sizes of other file types are not specified in a standard way.
582	GFileMeasureApparentSizeValue FileMeasureFlags = 4
583	// Do not cross mount point boundaries.
584	//   Compare with `du -x`.
585	GFileMeasureNoXdevValue FileMeasureFlags = 8
586)
587
588// Flags used to set what a #GFileMonitor will watch for.
589type FileMonitorFlags int
590
591var xFileMonitorFlagsGLibType func() types.GType
592
593func FileMonitorFlagsGLibType() types.GType {
594	return xFileMonitorFlagsGLibType()
595}
596
597const (
598
599	// No flags set.
600	GFileMonitorNoneValue FileMonitorFlags = 0
601	// Watch for mount events.
602	GFileMonitorWatchMountsValue FileMonitorFlags = 1
603	// Pair DELETED and CREATED events caused
604	//   by file renames (moves) and send a single G_FILE_MONITOR_EVENT_MOVED
605	//   event instead (NB: not supported on all backends; the default
606	//   behaviour -without specifying this flag- is to send single DELETED
607	//   and CREATED events).  Deprecated since 2.46: use
608	//   %G_FILE_MONITOR_WATCH_MOVES instead.
609	GFileMonitorSendMovedValue FileMonitorFlags = 2
610	// Watch for changes to the file made
611	//   via another hard link. Since 2.36.
612	GFileMonitorWatchHardLinksValue FileMonitorFlags = 4
613	// Watch for rename operations on a
614	//   monitored directory.  This causes %G_FILE_MONITOR_EVENT_RENAMED,
615	//   %G_FILE_MONITOR_EVENT_MOVED_IN and %G_FILE_MONITOR_EVENT_MOVED_OUT
616	//   events to be emitted when possible.  Since: 2.46.
617	GFileMonitorWatchMovesValue FileMonitorFlags = 8
618)
619
620// Flags used when querying a #GFileInfo.
621type FileQueryInfoFlags int
622
623var xFileQueryInfoFlagsGLibType func() types.GType
624
625func FileQueryInfoFlagsGLibType() types.GType {
626	return xFileQueryInfoFlagsGLibType()
627}
628
629const (
630
631	// No flags set.
632	GFileQueryInfoNoneValue FileQueryInfoFlags = 0
633	// Don't follow symlinks.
634	GFileQueryInfoNofollowSymlinksValue FileQueryInfoFlags = 1
635)
636
637// GIOStreamSpliceFlags determine how streams should be spliced.
638type IOStreamSpliceFlags int
639
640var xIOStreamSpliceFlagsGLibType func() types.GType
641
642func IOStreamSpliceFlagsGLibType() types.GType {
643	return xIOStreamSpliceFlagsGLibType()
644}
645
646const (
647
648	// Do not close either stream.
649	GIoStreamSpliceNoneValue IOStreamSpliceFlags = 0
650	// Close the first stream after
651	//     the splice.
652	GIoStreamSpliceCloseStream1Value IOStreamSpliceFlags = 1
653	// Close the second stream after
654	//     the splice.
655	GIoStreamSpliceCloseStream2Value IOStreamSpliceFlags = 2
656	// Wait for both splice operations to finish
657	//     before calling the callback.
658	GIoStreamSpliceWaitForBothValue IOStreamSpliceFlags = 4
659)
660
661// Flags used when mounting a mount.
662type MountMountFlags int
663
664var xMountMountFlagsGLibType func() types.GType
665
666func MountMountFlagsGLibType() types.GType {
667	return xMountMountFlagsGLibType()
668}
669
670const (
671
672	// No flags set.
673	GMountMountNoneValue MountMountFlags = 0
674)
675
676// Flags used when an unmounting a mount.
677type MountUnmountFlags int
678
679var xMountUnmountFlagsGLibType func() types.GType
680
681func MountUnmountFlagsGLibType() types.GType {
682	return xMountUnmountFlagsGLibType()
683}
684
685const (
686
687	// No flags set.
688	GMountUnmountNoneValue MountUnmountFlags = 0
689	// Unmount even if there are outstanding
690	//  file operations on the mount.
691	GMountUnmountForceValue MountUnmountFlags = 1
692)
693
694// GOutputStreamSpliceFlags determine how streams should be spliced.
695type OutputStreamSpliceFlags int
696
697var xOutputStreamSpliceFlagsGLibType func() types.GType
698
699func OutputStreamSpliceFlagsGLibType() types.GType {
700	return xOutputStreamSpliceFlagsGLibType()
701}
702
703const (
704
705	// Do not close either stream.
706	GOutputStreamSpliceNoneValue OutputStreamSpliceFlags = 0
707	// Close the source stream after
708	//     the splice.
709	GOutputStreamSpliceCloseSourceValue OutputStreamSpliceFlags = 1
710	// Close the target stream after
711	//     the splice.
712	GOutputStreamSpliceCloseTargetValue OutputStreamSpliceFlags = 2
713)
714
715// GResourceFlags give information about a particular file inside a resource
716// bundle.
717type ResourceFlags int
718
719var xResourceFlagsGLibType func() types.GType
720
721func ResourceFlagsGLibType() types.GType {
722	return xResourceFlagsGLibType()
723}
724
725const (
726
727	// No flags set.
728	GResourceFlagsNoneValue ResourceFlags = 0
729	// The file is compressed.
730	GResourceFlagsCompressedValue ResourceFlags = 1
731)
732
733// GResourceLookupFlags determine how resource path lookups are handled.
734type ResourceLookupFlags int
735
736var xResourceLookupFlagsGLibType func() types.GType
737
738func ResourceLookupFlagsGLibType() types.GType {
739	return xResourceLookupFlagsGLibType()
740}
741
742const (
743
744	// No flags set.
745	GResourceLookupFlagsNoneValue ResourceLookupFlags = 0
746)
747
748// Flags used in g_socket_receive_message() and g_socket_send_message().
749// The flags listed in the enum are some commonly available flags, but the
750// values used for them are the same as on the platform, and any other flags
751// are passed in/out as is. So to use a platform specific flag, just include
752// the right system header and pass in the flag.
753type SocketMsgFlags int
754
755var xSocketMsgFlagsGLibType func() types.GType
756
757func SocketMsgFlagsGLibType() types.GType {
758	return xSocketMsgFlagsGLibType()
759}
760
761const (
762
763	// No flags.
764	GSocketMsgNoneValue SocketMsgFlags = 0
765	// Request to send/receive out of band data.
766	GSocketMsgOobValue SocketMsgFlags = 1
767	// Read data from the socket without removing it from
768	//     the queue.
769	GSocketMsgPeekValue SocketMsgFlags = 2
770	// Don't use a gateway to send out the packet,
771	//     only send to hosts on directly connected networks.
772	GSocketMsgDontrouteValue SocketMsgFlags = 4
773)
774
775// Flags to define the behaviour of a #GSubprocess.
776//
777// Note that the default for stdin is to redirect from `/dev/null`.  For
778// stdout and stderr the default are for them to inherit the
779// corresponding descriptor from the calling process.
780//
781// Note that it is a programmer error to mix 'incompatible' flags.  For
782// example, you may not request both %G_SUBPROCESS_FLAGS_STDOUT_PIPE and
783// %G_SUBPROCESS_FLAGS_STDOUT_SILENCE.
784type SubprocessFlags int
785
786var xSubprocessFlagsGLibType func() types.GType
787
788func SubprocessFlagsGLibType() types.GType {
789	return xSubprocessFlagsGLibType()
790}
791
792const (
793
794	// No flags.
795	GSubprocessFlagsNoneValue SubprocessFlags = 0
796	// create a pipe for the stdin of the
797	//   spawned process that can be accessed with
798	//   g_subprocess_get_stdin_pipe().
799	GSubprocessFlagsStdinPipeValue SubprocessFlags = 1
800	// stdin is inherited from the
801	//   calling process.
802	GSubprocessFlagsStdinInheritValue SubprocessFlags = 2
803	// create a pipe for the stdout of the
804	//   spawned process that can be accessed with
805	//   g_subprocess_get_stdout_pipe().
806	GSubprocessFlagsStdoutPipeValue SubprocessFlags = 4
807	// silence the stdout of the spawned
808	//   process (ie: redirect to `/dev/null`).
809	GSubprocessFlagsStdoutSilenceValue SubprocessFlags = 8
810	// create a pipe for the stderr of the
811	//   spawned process that can be accessed with
812	//   g_subprocess_get_stderr_pipe().
813	GSubprocessFlagsStderrPipeValue SubprocessFlags = 16
814	// silence the stderr of the spawned
815	//   process (ie: redirect to `/dev/null`).
816	GSubprocessFlagsStderrSilenceValue SubprocessFlags = 32
817	// merge the stderr of the spawned
818	//   process with whatever the stdout happens to be.  This is a good way
819	//   of directing both streams to a common log file, for example.
820	GSubprocessFlagsStderrMergeValue SubprocessFlags = 64
821	// spawned processes will inherit the
822	//   file descriptors of their parent, unless those descriptors have
823	//   been explicitly marked as close-on-exec.  This flag has no effect
824	//   over the "standard" file descriptors (stdin, stdout, stderr).
825	GSubprocessFlagsInheritFdsValue SubprocessFlags = 128
826	// if path searching is
827	//   needed when spawning the subprocess, use the `PATH` in the launcher
828	//   environment. (Since: 2.72)
829	GSubprocessFlagsSearchPathFromEnvpValue SubprocessFlags = 256
830)
831
832// Flags to define future #GTestDBus behaviour.
833type TestDBusFlags int
834
835var xTestDBusFlagsGLibType func() types.GType
836
837func TestDBusFlagsGLibType() types.GType {
838	return xTestDBusFlagsGLibType()
839}
840
841const (
842
843	// No flags.
844	GTestDbusNoneValue TestDBusFlags = 0
845)
846
847// A set of flags describing TLS certification validation. This can be
848// used to describe why a particular certificate was rejected (for
849// example, in #GTlsConnection::accept-certificate).
850//
851// GLib guarantees that if certificate verification fails, at least one
852// flag will be set, but it does not guarantee that all possible flags
853// will be set. Accordingly, you may not safely decide to ignore any
854// particular type of error. For example, it would be incorrect to mask
855// %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
856// because this could potentially be the only error flag set even if
857// other problems exist with the certificate.
858type TlsCertificateFlags int
859
860var xTlsCertificateFlagsGLibType func() types.GType
861
862func TlsCertificateFlagsGLibType() types.GType {
863	return xTlsCertificateFlagsGLibType()
864}
865
866const (
867
868	// No flags set. Since: 2.74
869	GTlsCertificateNoFlagsValue TlsCertificateFlags = 0
870	// The signing certificate authority is
871	//   not known.
872	GTlsCertificateUnknownCaValue TlsCertificateFlags = 1
873	// The certificate does not match the
874	//   expected identity of the site that it was retrieved from.
875	GTlsCertificateBadIdentityValue TlsCertificateFlags = 2
876	// The certificate's activation time
877	//   is still in the future
878	GTlsCertificateNotActivatedValue TlsCertificateFlags = 4
879	// The certificate has expired
880	GTlsCertificateExpiredValue TlsCertificateFlags = 8
881	// The certificate has been revoked
882	//   according to the #GTlsConnection's certificate revocation list.
883	GTlsCertificateRevokedValue TlsCertificateFlags = 16
884	// The certificate's algorithm is
885	//   considered insecure.
886	GTlsCertificateInsecureValue TlsCertificateFlags = 32
887	// Some other error occurred validating
888	//   the certificate
889	GTlsCertificateGenericErrorValue TlsCertificateFlags = 64
890	// the combination of all of the above
891	//   flags
892	GTlsCertificateValidateAllValue TlsCertificateFlags = 127
893)
894
895// Flags for g_tls_database_verify_chain().
896type TlsDatabaseVerifyFlags int
897
898var xTlsDatabaseVerifyFlagsGLibType func() types.GType
899
900func TlsDatabaseVerifyFlagsGLibType() types.GType {
901	return xTlsDatabaseVerifyFlagsGLibType()
902}
903
904const (
905
906	// No verification flags
907	GTlsDatabaseVerifyNoneValue TlsDatabaseVerifyFlags = 0
908)
909
910// Various flags for the password.
911type TlsPasswordFlags int
912
913var xTlsPasswordFlagsGLibType func() types.GType
914
915func TlsPasswordFlagsGLibType() types.GType {
916	return xTlsPasswordFlagsGLibType()
917}
918
919const (
920
921	// No flags
922	GTlsPasswordNoneValue TlsPasswordFlags = 0
923	// The password was wrong, and the user should retry.
924	GTlsPasswordRetryValue TlsPasswordFlags = 2
925	// Hint to the user that the password has been
926	//    wrong many times, and the user may not have many chances left.
927	GTlsPasswordManyTriesValue TlsPasswordFlags = 4
928	// Hint to the user that this is the last try to get
929	//    this password right.
930	GTlsPasswordFinalTryValue TlsPasswordFlags = 8
931	// For PKCS #11, the user PIN is required.
932	//    Since: 2.70.
933	GTlsPasswordPkcs11UserValue TlsPasswordFlags = 16
934	// For PKCS #11, the security officer
935	//    PIN is required. Since: 2.70.
936	GTlsPasswordPkcs11SecurityOfficerValue TlsPasswordFlags = 32
937	// For PKCS #11, the context-specific
938	//    PIN is required. Since: 2.70.
939	GTlsPasswordPkcs11ContextSpecificValue TlsPasswordFlags = 64
940)
941
942// An enumeration for well-known message buses.
943type BusType int
944
945var xBusTypeGLibType func() types.GType
946
947func BusTypeGLibType() types.GType {
948	return xBusTypeGLibType()
949}
950
951const (
952
953	// An alias for the message bus that activated the process, if any.
954	GBusTypeStarterValue BusType = -1
955	// Not a message bus.
956	GBusTypeNoneValue BusType = 0
957	// The system-wide message bus.
958	GBusTypeSystemValue BusType = 1
959	// The login session message bus.
960	GBusTypeSessionValue BusType = 2
961)
962
963// Results returned from g_converter_convert().
964type ConverterResult int
965
966var xConverterResultGLibType func() types.GType
967
968func ConverterResultGLibType() types.GType {
969	return xConverterResultGLibType()
970}
971
972const (
973
974	// There was an error during conversion.
975	GConverterErrorValue ConverterResult = 0
976	// Some data was consumed or produced
977	GConverterConvertedValue ConverterResult = 1
978	// The conversion is finished
979	GConverterFinishedValue ConverterResult = 2
980	// Flushing is finished
981	GConverterFlushedValue ConverterResult = 3
982)
983
984// Enumeration describing different kinds of native credential types.
985type CredentialsType int
986
987var xCredentialsTypeGLibType func() types.GType
988
989func CredentialsTypeGLibType() types.GType {
990	return xCredentialsTypeGLibType()
991}
992
993const (
994
995	// Indicates an invalid native credential type.
996	GCredentialsTypeInvalidValue CredentialsType = 0
997	// The native credentials type is a `struct ucred`.
998	GCredentialsTypeLinuxUcredValue CredentialsType = 1
999	// The native credentials type is a `struct cmsgcred`.
1000	GCredentialsTypeFreebsdCmsgcredValue CredentialsType = 2
1001	// The native credentials type is a `struct sockpeercred`. Added in 2.30.
1002	GCredentialsTypeOpenbsdSockpeercredValue CredentialsType = 3
1003	// The native credentials type is a `ucred_t`. Added in 2.40.
1004	GCredentialsTypeSolarisUcredValue CredentialsType = 4
1005	// The native credentials type is a `struct unpcbid`. Added in 2.42.
1006	GCredentialsTypeNetbsdUnpcbidValue CredentialsType = 5
1007	// The native credentials type is a `struct xucred`. Added in 2.66.
1008	GCredentialsTypeAppleXucredValue CredentialsType = 6
1009	// The native credentials type is a PID `DWORD`. Added in 2.72.
1010	GCredentialsTypeWin32PidValue CredentialsType = 7
1011)
1012
1013// Error codes for the %G_DBUS_ERROR error domain.
1014type DBusError int
1015
1016var xDBusErrorGLibType func() types.GType
1017
1018func DBusErrorGLibType() types.GType {
1019	return xDBusErrorGLibType()
1020}
1021
1022const (
1023
1024	// A generic error; "something went wrong" - see the error message for
1025	// more.
1026	GDbusErrorFailedValue DBusError = 0
1027	// There was not enough memory to complete an operation.
1028	GDbusErrorNoMemoryValue DBusError = 1
1029	// The bus doesn't know how to launch a service to supply the bus name
1030	// you wanted.
1031	GDbusErrorServiceUnknownValue DBusError = 2
1032	// The bus name you referenced doesn't exist (i.e. no application owns
1033	// it).
1034	GDbusErrorNameHasNoOwnerValue DBusError = 3
1035	// No reply to a message expecting one, usually means a timeout occurred.
1036	GDbusErrorNoReplyValue DBusError = 4
1037	// Something went wrong reading or writing to a socket, for example.
1038	GDbusErrorIoErrorValue DBusError = 5
1039	// A D-Bus bus address was malformed.
1040	GDbusErrorBadAddressValue DBusError = 6
1041	// Requested operation isn't supported (like ENOSYS on UNIX).
1042	GDbusErrorNotSupportedValue DBusError = 7
1043	// Some limited resource is exhausted.
1044	GDbusErrorLimitsExceededValue DBusError = 8
1045	// Security restrictions don't allow doing what you're trying to do.
1046	GDbusErrorAccessDeniedValue DBusError = 9
1047	// Authentication didn't work.
1048	GDbusErrorAuthFailedValue DBusError = 10
1049	// Unable to connect to server (probably caused by ECONNREFUSED on a
1050	// socket).
1051	GDbusErrorNoServerValue DBusError = 11
1052	// Certain timeout errors, possibly ETIMEDOUT on a socket.  Note that
1053	// %G_DBUS_ERROR_NO_REPLY is used for message reply timeouts. Warning:
1054	// this is confusingly-named given that %G_DBUS_ERROR_TIMED_OUT also
1055	// exists. We can't fix it for compatibility reasons so just be
1056	// careful.
1057	GDbusErrorTimeoutValue DBusError = 12
1058	// No network access (probably ENETUNREACH on a socket).
1059	GDbusErrorNoNetworkValue DBusError = 13
1060	// Can't bind a socket since its address is in use (i.e. EADDRINUSE).
1061	GDbusErrorAddressInUseValue DBusError = 14
1062	// The connection is disconnected and you're trying to use it.
1063	GDbusErrorDisconnectedValue DBusError = 15
1064	// Invalid arguments passed to a method call.
1065	GDbusErrorInvalidArgsValue DBusError = 16
1066	// Missing file.
1067	GDbusErrorFileNotFoundValue DBusError = 17
1068	// Existing file and the operation you're using does not silently overwrite.
1069	GDbusErrorFileExistsValue DBusError = 18
1070	// Method name you invoked isn't known by the object you invoked it on.
1071	GDbusErrorUnknownMethodValue DBusError = 19
1072	// Certain timeout errors, e.g. while starting a service. Warning: this is
1073	// confusingly-named given that %G_DBUS_ERROR_TIMEOUT also exists. We
1074	// can't fix it for compatibility reasons so just be careful.
1075	GDbusErrorTimedOutValue DBusError = 20
1076	// Tried to remove or modify a match rule that didn't exist.
1077	GDbusErrorMatchRuleNotFoundValue DBusError = 21
1078	// The match rule isn't syntactically valid.
1079	GDbusErrorMatchRuleInvalidValue DBusError = 22
1080	// While starting a new process, the exec() call failed.
1081	GDbusErrorSpawnExecFailedValue DBusError = 23
1082	// While starting a new process, the fork() call failed.
1083	GDbusErrorSpawnForkFailedValue DBusError = 24
1084	// While starting a new process, the child exited with a status code.
1085	GDbusErrorSpawnChildExitedValue DBusError = 25
1086	// While starting a new process, the child exited on a signal.
1087	GDbusErrorSpawnChildSignaledValue DBusError = 26
1088	// While starting a new process, something went wrong.
1089	GDbusErrorSpawnFailedValue DBusError = 27
1090	// We failed to setup the environment correctly.
1091	GDbusErrorSpawnSetupFailedValue DBusError = 28
1092	// We failed to setup the config parser correctly.
1093	GDbusErrorSpawnConfigInvalidValue DBusError = 29
1094	// Bus name was not valid.
1095	GDbusErrorSpawnServiceInvalidValue DBusError = 30
1096	// Service file not found in system-services directory.
1097	GDbusErrorSpawnServiceNotFoundValue DBusError = 31
1098	// Permissions are incorrect on the setuid helper.
1099	GDbusErrorSpawnPermissionsInvalidValue DBusError = 32
1100	// Service file invalid (Name, User or Exec missing).
1101	GDbusErrorSpawnFileInvalidValue DBusError = 33
1102	// Tried to get a UNIX process ID and it wasn't available.
1103	GDbusErrorSpawnNoMemoryValue DBusError = 34
1104	// Tried to get a UNIX process ID and it wasn't available.
1105	GDbusErrorUnixProcessIdUnknownValue DBusError = 35
1106	// A type signature is not valid.
1107	GDbusErrorInvalidSignatureValue DBusError = 36
1108	// A file contains invalid syntax or is otherwise broken.
1109	GDbusErrorInvalidFileContentValue DBusError = 37
1110	// Asked for SELinux security context and it wasn't available.
1111	GDbusErrorSelinuxSecurityContextUnknownValue DBusError = 38
1112	// Asked for ADT audit data and it wasn't available.
1113	GDbusErrorAdtAuditDataUnknownValue DBusError = 39
1114	// There's already an object with the requested object path.
1115	GDbusErrorObjectPathInUseValue DBusError = 40
1116	// Object you invoked a method on isn't known. Since 2.42
1117	GDbusErrorUnknownObjectValue DBusError = 41
1118	// Interface you invoked a method on isn't known by the object. Since 2.42
1119	GDbusErrorUnknownInterfaceValue DBusError = 42
1120	// Property you tried to access isn't known by the object. Since 2.42
1121	GDbusErrorUnknownPropertyValue DBusError = 43
1122	// Property you tried to set is read-only. Since 2.42
1123	GDbusErrorPropertyReadOnlyValue DBusError = 44
1124)
1125
1126// Enumeration used to describe the byte order of a D-Bus message.
1127type DBusMessageByteOrder int
1128
1129var xDBusMessageByteOrderGLibType func() types.GType
1130
1131func DBusMessageByteOrderGLibType() types.GType {
1132	return xDBusMessageByteOrderGLibType()
1133}
1134
1135const (
1136
1137	// The byte order is big endian.
1138	GDbusMessageByteOrderBigEndianValue DBusMessageByteOrder = 66
1139	// The byte order is little endian.
1140	GDbusMessageByteOrderLittleEndianValue DBusMessageByteOrder = 108
1141)
1142
1143// Header fields used in #GDBusMessage.
1144type DBusMessageHeaderField int
1145
1146var xDBusMessageHeaderFieldGLibType func() types.GType
1147
1148func DBusMessageHeaderFieldGLibType() types.GType {
1149	return xDBusMessageHeaderFieldGLibType()
1150}
1151
1152const (
1153
1154	// Not a valid header field.
1155	GDbusMessageHeaderFieldInvalidValue DBusMessageHeaderField = 0
1156	// The object path.
1157	GDbusMessageHeaderFieldPathValue DBusMessageHeaderField = 1
1158	// The interface name.
1159	GDbusMessageHeaderFieldInterfaceValue DBusMessageHeaderField = 2
1160	// The method or signal name.
1161	GDbusMessageHeaderFieldMemberValue DBusMessageHeaderField = 3
1162	// The name of the error that occurred.
1163	GDbusMessageHeaderFieldErrorNameValue DBusMessageHeaderField = 4
1164	// The serial number the message is a reply to.
1165	GDbusMessageHeaderFieldReplySerialValue DBusMessageHeaderField = 5
1166	// The name the message is intended for.
1167	GDbusMessageHeaderFieldDestinationValue DBusMessageHeaderField = 6
1168	// Unique name of the sender of the message (filled in by the bus).
1169	GDbusMessageHeaderFieldSenderValue DBusMessageHeaderField = 7
1170	// The signature of the message body.
1171	GDbusMessageHeaderFieldSignatureValue DBusMessageHeaderField = 8
1172	// The number of UNIX file descriptors that accompany the message.
1173	GDbusMessageHeaderFieldNumUnixFdsValue DBusMessageHeaderField = 9
1174)
1175
1176// Message types used in #GDBusMessage.
1177type DBusMessageType int
1178
1179var xDBusMessageTypeGLibType func() types.GType
1180
1181func DBusMessageTypeGLibType() types.GType {
1182	return xDBusMessageTypeGLibType()
1183}
1184
1185const (
1186
1187	// Message is of invalid type.
1188	GDbusMessageTypeInvalidValue DBusMessageType = 0
1189	// Method call.
1190	GDbusMessageTypeMethodCallValue DBusMessageType = 1
1191	// Method reply.
1192	GDbusMessageTypeMethodReturnValue DBusMessageType = 2
1193	// Error reply.
1194	GDbusMessageTypeErrorValue DBusMessageType = 3
1195	// Signal emission.
1196	GDbusMessageTypeSignalValue DBusMessageType = 4
1197)
1198
1199// #GDataStreamByteOrder is used to ensure proper endianness of streaming data sources
1200// across various machine architectures.
1201type DataStreamByteOrder int
1202
1203var xDataStreamByteOrderGLibType func() types.GType
1204
1205func DataStreamByteOrderGLibType() types.GType {
1206	return xDataStreamByteOrderGLibType()
1207}
1208
1209const (
1210
1211	// Selects Big Endian byte order.
1212	GDataStreamByteOrderBigEndianValue DataStreamByteOrder = 0
1213	// Selects Little Endian byte order.
1214	GDataStreamByteOrderLittleEndianValue DataStreamByteOrder = 1
1215	// Selects endianness based on host machine's architecture.
1216	GDataStreamByteOrderHostEndianValue DataStreamByteOrder = 2
1217)
1218
1219// #GDataStreamNewlineType is used when checking for or setting the line endings for a given file.
1220type DataStreamNewlineType int
1221
1222var xDataStreamNewlineTypeGLibType func() types.GType
1223
1224func DataStreamNewlineTypeGLibType() types.GType {
1225	return xDataStreamNewlineTypeGLibType()
1226}
1227
1228const (
1229
1230	// Selects "LF" line endings, common on most modern UNIX platforms.
1231	GDataStreamNewlineTypeLfValue DataStreamNewlineType = 0
1232	// Selects "CR" line endings.
1233	GDataStreamNewlineTypeCrValue DataStreamNewlineType = 1
1234	// Selects "CR, LF" line ending, common on Microsoft Windows.
1235	GDataStreamNewlineTypeCrLfValue DataStreamNewlineType = 2
1236	// Automatically try to handle any line ending type.
1237	GDataStreamNewlineTypeAnyValue DataStreamNewlineType = 3
1238)
1239
1240// Enumeration describing how a drive can be started/stopped.
1241type DriveStartStopType int
1242
1243var xDriveStartStopTypeGLibType func() types.GType
1244
1245func DriveStartStopTypeGLibType() types.GType {
1246	return xDriveStartStopTypeGLibType()
1247}
1248
1249const (
1250
1251	// Unknown or drive doesn't support
1252	//    start/stop.
1253	GDriveStartStopTypeUnknownValue DriveStartStopType = 0
1254	// The stop method will physically
1255	//    shut down the drive and e.g. power down the port the drive is
1256	//    attached to.
1257	GDriveStartStopTypeShutdownValue DriveStartStopType = 1
1258	// The start/stop methods are used
1259	//    for connecting/disconnect to the drive over the network.
1260	GDriveStartStopTypeNetworkValue DriveStartStopType = 2
1261	// The start/stop methods will
1262	//    assemble/disassemble a virtual drive from several physical
1263	//    drives.
1264	GDriveStartStopTypeMultidiskValue DriveStartStopType = 3
1265	// The start/stop methods will
1266	//    unlock/lock the disk (for example using the ATA `SECURITY UNLOCK
1267	//    DEVICE` command)
1268	GDriveStartStopTypePasswordValue DriveStartStopType = 4
1269)
1270
1271// GEmblemOrigin is used to add information about the origin of the emblem
1272// to #GEmblem.
1273type EmblemOrigin int
1274
1275var xEmblemOriginGLibType func() types.GType
1276
1277func EmblemOriginGLibType() types.GType {
1278	return xEmblemOriginGLibType()
1279}
1280
1281const (
1282
1283	// Emblem of unknown origin
1284	GEmblemOriginUnknownValue EmblemOrigin = 0
1285	// Emblem adds device-specific information
1286	GEmblemOriginDeviceValue EmblemOrigin = 1
1287	// Emblem depicts live metadata, such as "readonly"
1288	GEmblemOriginLivemetadataValue EmblemOrigin = 2
1289	// Emblem comes from a user-defined tag, e.g. set by nautilus (in the future)
1290	GEmblemOriginTagValue EmblemOrigin = 3
1291)
1292
1293// Used by g_file_set_attributes_from_info() when setting file attributes.
1294type FileAttributeStatus int
1295
1296var xFileAttributeStatusGLibType func() types.GType
1297
1298func FileAttributeStatusGLibType() types.GType {
1299	return xFileAttributeStatusGLibType()
1300}
1301
1302const (
1303
1304	// Attribute value is unset (empty).
1305	GFileAttributeStatusUnsetValue FileAttributeStatus = 0
1306	// Attribute value is set.
1307	GFileAttributeStatusSetValue FileAttributeStatus = 1
1308	// Indicates an error in setting the value.
1309	GFileAttributeStatusErrorSettingValue FileAttributeStatus = 2
1310)
1311
1312// The data types for file attributes.
1313type FileAttributeType int
1314
1315var xFileAttributeTypeGLibType func() types.GType
1316
1317func FileAttributeTypeGLibType() types.GType {
1318	return xFileAttributeTypeGLibType()
1319}
1320
1321const (
1322
1323	// indicates an invalid or uninitialized type.
1324	GFileAttributeTypeInvalidValue FileAttributeType = 0
1325	// a null terminated UTF8 string.
1326	GFileAttributeTypeStringValue FileAttributeType = 1
1327	// a zero terminated string of non-zero bytes.
1328	GFileAttributeTypeByteStringValue FileAttributeType = 2
1329	// a boolean value.
1330	GFileAttributeTypeBooleanValue FileAttributeType = 3
1331	// an unsigned 4-byte/32-bit integer.
1332	GFileAttributeTypeUint32Value FileAttributeType = 4
1333	// a signed 4-byte/32-bit integer.
1334	GFileAttributeTypeInt32Value FileAttributeType = 5
1335	// an unsigned 8-byte/64-bit integer.
1336	GFileAttributeTypeUint64Value FileAttributeType = 6
1337	// a signed 8-byte/64-bit integer.
1338	GFileAttributeTypeInt64Value FileAttributeType = 7
1339	// a #GObject.
1340	GFileAttributeTypeObjectValue FileAttributeType = 8
1341	// a %NULL terminated char **. Since 2.22
1342	GFileAttributeTypeStringvValue FileAttributeType = 9
1343)
1344
1345// Specifies what type of event a monitor event is.
1346type FileMonitorEvent int
1347
1348var xFileMonitorEventGLibType func() types.GType
1349
1350func FileMonitorEventGLibType() types.GType {
1351	return xFileMonitorEventGLibType()
1352}
1353
1354const (
1355
1356	// a file changed.
1357	GFileMonitorEventChangedValue FileMonitorEvent = 0
1358	// a hint that this was probably the last change in a set of changes.
1359	GFileMonitorEventChangesDoneHintValue FileMonitorEvent = 1
1360	// a file was deleted.
1361	GFileMonitorEventDeletedValue FileMonitorEvent = 2
1362	// a file was created.
1363	GFileMonitorEventCreatedValue FileMonitorEvent = 3
1364	// a file attribute was changed.
1365	GFileMonitorEventAttributeChangedValue FileMonitorEvent = 4
1366	// the file location will soon be unmounted.
1367	GFileMonitorEventPreUnmountValue FileMonitorEvent = 5
1368	// the file location was unmounted.
1369	GFileMonitorEventUnmountedValue FileMonitorEvent = 6
1370	// the file was moved -- only sent if the
1371	//   (deprecated) %G_FILE_MONITOR_SEND_MOVED flag is set
1372	GFileMonitorEventMovedValue FileMonitorEvent = 7
1373	// the file was renamed within the
1374	//   current directory -- only sent if the %G_FILE_MONITOR_WATCH_MOVES
1375	//   flag is set.  Since: 2.46.
1376	GFileMonitorEventRenamedValue FileMonitorEvent = 8
1377	// the file was moved into the
1378	//   monitored directory from another location -- only sent if the
1379	//   %G_FILE_MONITOR_WATCH_MOVES flag is set.  Since: 2.46.
1380	GFileMonitorEventMovedInValue FileMonitorEvent = 9
1381	// the file was moved out of the
1382	//   monitored directory to another location -- only sent if the
1383	//   %G_FILE_MONITOR_WATCH_MOVES flag is set.  Since: 2.46
1384	GFileMonitorEventMovedOutValue FileMonitorEvent = 10
1385)
1386
1387// Indicates the file's on-disk type.
1388//
1389// On Windows systems a file will never have %G_FILE_TYPE_SYMBOLIC_LINK type;
1390// use #GFileInfo and %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK to determine
1391// whether a file is a symlink or not. This is due to the fact that NTFS does
1392// not have a single filesystem object type for symbolic links - it has
1393// files that symlink to files, and directories that symlink to directories.
1394// #GFileType enumeration cannot precisely represent this important distinction,
1395// which is why all Windows symlinks will continue to be reported as
1396// %G_FILE_TYPE_REGULAR or %G_FILE_TYPE_DIRECTORY.
1397type FileType int
1398
1399var xFileTypeGLibType func() types.GType
1400
1401func FileTypeGLibType() types.GType {
1402	return xFileTypeGLibType()
1403}
1404
1405const (
1406
1407	// File's type is unknown.
1408	GFileTypeUnknownValue FileType = 0
1409	// File handle represents a regular file.
1410	GFileTypeRegularValue FileType = 1
1411	// File handle represents a directory.
1412	GFileTypeDirectoryValue FileType = 2
1413	// File handle represents a symbolic link
1414	//    (Unix systems).
1415	GFileTypeSymbolicLinkValue FileType = 3
1416	// File is a "special" file, such as a socket, fifo,
1417	//    block device, or character device.
1418	GFileTypeSpecialValue FileType = 4
1419	// File is a shortcut (Windows systems).
1420	GFileTypeShortcutValue FileType = 5
1421	// File is a mountable location.
1422	GFileTypeMountableValue FileType = 6
1423)
1424
1425// Indicates a hint from the file system whether files should be
1426// previewed in a file manager. Returned as the value of the key
1427// %G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW.
1428type FilesystemPreviewType int
1429
1430var xFilesystemPreviewTypeGLibType func() types.GType
1431
1432func FilesystemPreviewTypeGLibType() types.GType {
1433	return xFilesystemPreviewTypeGLibType()
1434}
1435
1436const (
1437
1438	// Only preview files if user has explicitly requested it.
1439	GFilesystemPreviewTypeIfAlwaysValue FilesystemPreviewType = 0
1440	// Preview files if user has requested preview of "local" files.
1441	GFilesystemPreviewTypeIfLocalValue FilesystemPreviewType = 1
1442	// Never preview files.
1443	GFilesystemPreviewTypeNeverValue FilesystemPreviewType = 2
1444)
1445
1446// Error codes returned by GIO functions.
1447//
1448// Note that this domain may be extended in future GLib releases. In
1449// general, new error codes either only apply to new APIs, or else
1450// replace %G_IO_ERROR_FAILED in cases that were not explicitly
1451// distinguished before. You should therefore avoid writing code like
1452// |[<!-- language="C" -->
1453// if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED))
1454//
1455//	{
1456//	  // Assume that this is EPRINTERONFIRE
1457//	  ...
1458//	}
1459//
1460// ]|
1461// but should instead treat all unrecognized error codes the same as
1462// %G_IO_ERROR_FAILED.
1463//
1464// See also #GPollableReturn for a cheaper way of returning
1465// %G_IO_ERROR_WOULD_BLOCK to callers without allocating a #GError.
1466type IOErrorEnum int
1467
1468var xIOErrorEnumGLibType func() types.GType
1469
1470func IOErrorEnumGLibType() types.GType {
1471	return xIOErrorEnumGLibType()
1472}
1473
1474const (
1475
1476	// Generic error condition for when an operation fails
1477	//     and no more specific #GIOErrorEnum value is defined.
1478	GIoErrorFailedValue IOErrorEnum = 0
1479	// File not found.
1480	GIoErrorNotFoundValue IOErrorEnum = 1
1481	// File already exists.
1482	GIoErrorExistsValue IOErrorEnum = 2
1483	// File is a directory.
1484	GIoErrorIsDirectoryValue IOErrorEnum = 3
1485	// File is not a directory.
1486	GIoErrorNotDirectoryValue IOErrorEnum = 4
1487	// File is a directory that isn't empty.
1488	GIoErrorNotEmptyValue IOErrorEnum = 5
1489	// File is not a regular file.
1490	GIoErrorNotRegularFileValue IOErrorEnum = 6
1491	// File is not a symbolic link.
1492	GIoErrorNotSymbolicLinkValue IOErrorEnum = 7
1493	// File cannot be mounted.
1494	GIoErrorNotMountableFileValue IOErrorEnum = 8
1495	// Filename is too many characters.
1496	GIoErrorFilenameTooLongValue IOErrorEnum = 9
1497	// Filename is invalid or contains invalid characters.
1498	GIoErrorInvalidFilenameValue IOErrorEnum = 10
1499	// File contains too many symbolic links.
1500	GIoErrorTooManyLinksValue IOErrorEnum = 11
1501	// No space left on drive.
1502	GIoErrorNoSpaceValue IOErrorEnum = 12
1503	// Invalid argument.
1504	GIoErrorInvalidArgumentValue IOErrorEnum = 13
1505	// Permission denied.
1506	GIoErrorPermissionDeniedValue IOErrorEnum = 14
1507	// Operation (or one of its parameters) not supported
1508	GIoErrorNotSupportedValue IOErrorEnum = 15
1509	// File isn't mounted.
1510	GIoErrorNotMountedValue IOErrorEnum = 16
1511	// File is already mounted.
1512	GIoErrorAlreadyMountedValue IOErrorEnum = 17
1513	// File was closed.
1514	GIoErrorClosedValue IOErrorEnum = 18
1515	// Operation was cancelled. See #GCancellable.
1516	GIoErrorCancelledValue IOErrorEnum = 19
1517	// Operations are still pending.
1518	GIoErrorPendingValue IOErrorEnum = 20
1519	// File is read only.
1520	GIoErrorReadOnlyValue IOErrorEnum = 21
1521	// Backup couldn't be created.
1522	GIoErrorCantCreateBackupValue IOErrorEnum = 22
1523	// File's Entity Tag was incorrect.
1524	GIoErrorWrongEtagValue IOErrorEnum = 23
1525	// Operation timed out.
1526	GIoErrorTimedOutValue IOErrorEnum = 24
1527	// Operation would be recursive.
1528	GIoErrorWouldRecurseValue IOErrorEnum = 25
1529	// File is busy.
1530	GIoErrorBusyValue IOErrorEnum = 26
1531	// Operation would block.
1532	GIoErrorWouldBlockValue IOErrorEnum = 27
1533	// Host couldn't be found (remote operations).
1534	GIoErrorHostNotFoundValue IOErrorEnum = 28
1535	// Operation would merge files.
1536	GIoErrorWouldMergeValue IOErrorEnum = 29
1537	// Operation failed and a helper program has
1538	//     already interacted with the user. Do not display any error dialog.
1539	GIoErrorFailedHandledValue IOErrorEnum = 30
1540	// The current process has too many files
1541	//     open and can't open any more. Duplicate descriptors do count toward
1542	//     this limit. Since 2.20
1543	GIoErrorTooManyOpenFilesValue IOErrorEnum = 31
1544	// The object has not been initialized. Since 2.22
1545	GIoErrorNotInitializedValue IOErrorEnum = 32
1546	// The requested address is already in use. Since 2.22
1547	GIoErrorAddressInUseValue IOErrorEnum = 33
1548	// Need more input to finish operation. Since 2.24
1549	GIoErrorPartialInputValue IOErrorEnum = 34
1550	// The input data was invalid. Since 2.24
1551	GIoErrorInvalidDataValue IOErrorEnum = 35
1552	// A remote object generated an error that
1553	//     doesn't correspond to a locally registered #GError error
1554	//     domain. Use g_dbus_error_get_remote_error() to extract the D-Bus
1555	//     error name and g_dbus_error_strip_remote_error() to fix up the
1556	//     message so it matches what was received on the wire. Since 2.26.
1557	GIoErrorDbusErrorValue IOErrorEnum = 36
1558	// Host unreachable. Since 2.26
1559	GIoErrorHostUnreachableValue IOErrorEnum = 37
1560	// Network unreachable. Since 2.26
1561	GIoErrorNetworkUnreachableValue IOErrorEnum = 38
1562	// Connection refused. Since 2.26
1563	GIoErrorConnectionRefusedValue IOErrorEnum = 39
1564	// Connection to proxy server failed. Since 2.26
1565	GIoErrorProxyFailedValue IOErrorEnum = 40
1566	// Proxy authentication failed. Since 2.26
1567	GIoErrorProxyAuthFailedValue IOErrorEnum = 41
1568	// Proxy server needs authentication. Since 2.26
1569	GIoErrorProxyNeedAuthValue IOErrorEnum = 42
1570	// Proxy connection is not allowed by ruleset.
1571	//     Since 2.26
1572	GIoErrorProxyNotAllowedValue IOErrorEnum = 43
1573	// Broken pipe. Since 2.36
1574	GIoErrorBrokenPipeValue IOErrorEnum = 44
1575	// Connection closed by peer. Note that this
1576	//     is the same code as %G_IO_ERROR_BROKEN_PIPE; before 2.44 some
1577	//     "connection closed" errors returned %G_IO_ERROR_BROKEN_PIPE, but others
1578	//     returned %G_IO_ERROR_FAILED. Now they should all return the same
1579	//     value, which has this more logical name. Since 2.44.
1580	GIoErrorConnectionClosedValue IOErrorEnum = 44
1581	// Transport endpoint is not connected. Since 2.44
1582	GIoErrorNotConnectedValue IOErrorEnum = 45
1583	// Message too large. Since 2.48.
1584	GIoErrorMessageTooLargeValue IOErrorEnum = 46
1585	// No such device found. Since 2.74
1586	GIoErrorNoSuchDeviceValue IOErrorEnum = 47
1587	// Destination address unset. Since 2.80
1588	GIoErrorDestinationUnsetValue IOErrorEnum = 48
1589)
1590
1591// Flags for use with g_io_module_scope_new().
1592type IOModuleScopeFlags int
1593
1594var xIOModuleScopeFlagsGLibType func() types.GType
1595
1596func IOModuleScopeFlagsGLibType() types.GType {
1597	return xIOModuleScopeFlagsGLibType()
1598}
1599
1600const (
1601
1602	// No module scan flags
1603	GIoModuleScopeNoneValue IOModuleScopeFlags = 0
1604	// When using this scope to load or
1605	//     scan modules, automatically block a modules which has the same base
1606	//     basename as previously loaded module.
1607	GIoModuleScopeBlockDuplicatesValue IOModuleScopeFlags = 1
1608)
1609
1610// Memory availability warning levels.
1611//
1612// Note that because new values might be added, it is recommended that applications check
1613// #GMemoryMonitorWarningLevel as ranges, for example:
1614// |[<!-- language="C" -->
1615// if (warning_level > G_MEMORY_MONITOR_WARNING_LEVEL_LOW)
1616//
1617//	drop_caches ();
1618//
1619// ]|
1620type MemoryMonitorWarningLevel int
1621
1622var xMemoryMonitorWarningLevelGLibType func() types.GType
1623
1624func MemoryMonitorWarningLevelGLibType() types.GType {
1625	return xMemoryMonitorWarningLevelGLibType()
1626}
1627
1628const (
1629
1630	// Memory on the device is low, processes
1631	//   should free up unneeded resources (for example, in-memory caches) so they can
1632	//   be used elsewhere.
1633	GMemoryMonitorWarningLevelLowValue MemoryMonitorWarningLevel = 50
1634	// Same as @G_MEMORY_MONITOR_WARNING_LEVEL_LOW
1635	//   but the device has even less free memory, so processes should try harder to free
1636	//   up unneeded resources. If your process does not need to stay running, it is a
1637	//   good time for it to quit.
1638	GMemoryMonitorWarningLevelMediumValue MemoryMonitorWarningLevel = 100
1639	// The system will soon start terminating
1640	//   processes to reclaim memory, including background processes.
1641	GMemoryMonitorWarningLevelCriticalValue MemoryMonitorWarningLevel = 255
1642)
1643
1644// #GMountOperationResult is returned as a result when a request for
1645// information is send by the mounting operation.
1646type MountOperationResult int
1647
1648var xMountOperationResultGLibType func() types.GType
1649
1650func MountOperationResultGLibType() types.GType {
1651	return xMountOperationResultGLibType()
1652}
1653
1654const (
1655
1656	// The request was fulfilled and the
1657	//     user specified data is now available
1658	GMountOperationHandledValue MountOperationResult = 0
1659	// The user requested the mount operation
1660	//     to be aborted
1661	GMountOperationAbortedValue MountOperationResult = 1
1662	// The request was unhandled (i.e. not
1663	//     implemented)
1664	GMountOperationUnhandledValue MountOperationResult = 2
1665)
1666
1667// The host's network connectivity state, as reported by #GNetworkMonitor.
1668type NetworkConnectivity int
1669
1670var xNetworkConnectivityGLibType func() types.GType
1671
1672func NetworkConnectivityGLibType() types.GType {
1673	return xNetworkConnectivityGLibType()
1674}
1675
1676const (
1677
1678	// The host is not configured with a
1679	//   route to the Internet; it may or may not be connected to a local
1680	//   network.
1681	GNetworkConnectivityLocalValue NetworkConnectivity = 1
1682	// The host is connected to a network, but
1683	//   does not appear to be able to reach the full Internet, perhaps
1684	//   due to upstream network problems.
1685	GNetworkConnectivityLimitedValue NetworkConnectivity = 2
1686	// The host is behind a captive portal and
1687	//   cannot reach the full Internet.
1688	GNetworkConnectivityPortalValue NetworkConnectivity = 3
1689	// The host is connected to a network, and
1690	//   appears to be able to reach the full Internet.
1691	GNetworkConnectivityFullValue NetworkConnectivity = 4
1692)
1693
1694// Priority levels for #GNotifications.
1695type NotificationPriority int
1696
1697var xNotificationPriorityGLibType func() types.GType
1698
1699func NotificationPriorityGLibType() types.GType {
1700	return xNotificationPriorityGLibType()
1701}
1702
1703const (
1704
1705	// the default priority, to be used for the
1706	//   majority of notifications (for example email messages, software updates,
1707	//   completed download/sync operations)
1708	GNotificationPriorityNormalValue NotificationPriority = 0
1709	// for notifications that do not require
1710	//   immediate attention - typically used for contextual background
1711	//   information, such as contact birthdays or local weather
1712	GNotificationPriorityLowValue NotificationPriority = 1
1713	// for events that require more attention,
1714	//   usually because responses are time-sensitive (for example chat and SMS
1715	//   messages or alarms)
1716	GNotificationPriorityHighValue NotificationPriority = 2
1717	// for urgent notifications, or notifications
1718	//   that require a response in a short space of time (for example phone calls
1719	//   or emergency warnings)
1720	GNotificationPriorityUrgentValue NotificationPriority = 3
1721)
1722
1723// #GPasswordSave is used to indicate the lifespan of a saved password.
1724//
1725// #Gvfs stores passwords in the Gnome keyring when this flag allows it
1726// to, and later retrieves it again from there.
1727type PasswordSave int
1728
1729var xPasswordSaveGLibType func() types.GType
1730
1731func PasswordSaveGLibType() types.GType {
1732	return xPasswordSaveGLibType()
1733}
1734
1735const (
1736
1737	// never save a password.
1738	GPasswordSaveNeverValue PasswordSave = 0
1739	// save a password for the session.
1740	GPasswordSaveForSessionValue PasswordSave = 1
1741	// save a password permanently.
1742	GPasswordSavePermanentlyValue PasswordSave = 2
1743)
1744
1745// Return value for various IO operations that signal errors via the
1746// return value and not necessarily via a #GError.
1747//
1748// This enum exists to be able to return errors to callers without having to
1749// allocate a #GError. Allocating #GErrors can be quite expensive for
1750// regularly happening errors like %G_IO_ERROR_WOULD_BLOCK.
1751//
1752// In case of %G_POLLABLE_RETURN_FAILED a #GError should be set for the
1753// operation to give details about the error that happened.
1754type PollableReturn int
1755
1756var xPollableReturnGLibType func() types.GType
1757
1758func PollableReturnGLibType() types.GType {
1759	return xPollableReturnGLibType()
1760}
1761
1762const (
1763
1764	// Generic error condition for when an operation fails.
1765	GPollableReturnFailedValue PollableReturn = 0
1766	// The operation was successfully finished.
1767	GPollableReturnOkValue PollableReturn = 1
1768	// The operation would block.
1769	GPollableReturnWouldBlockValue PollableReturn = -27
1770)
1771
1772// An error code used with %G_RESOLVER_ERROR in a #GError returned
1773// from a #GResolver routine.
1774type ResolverError int
1775
1776var xResolverErrorGLibType func() types.GType
1777
1778func ResolverErrorGLibType() types.GType {
1779	return xResolverErrorGLibType()
1780}
1781
1782const (
1783
1784	// the requested name/address/service was not
1785	//     found
1786	GResolverErrorNotFoundValue ResolverError = 0
1787	// the requested information could not
1788	//     be looked up due to a network error or similar problem
1789	GResolverErrorTemporaryFailureValue ResolverError = 1
1790	// unknown error
1791	GResolverErrorInternalValue ResolverError = 2
1792)
1793
1794// The type of record that g_resolver_lookup_records() or
1795// g_resolver_lookup_records_async() should retrieve. The records are returned
1796// as lists of #GVariant tuples. Each record type has different values in
1797// the variant tuples returned.
1798//
1799// %G_RESOLVER_RECORD_SRV records are returned as variants with the signature
1800// `(qqqs)`, containing a `guint16` with the priority, a `guint16` with the
1801// weight, a `guint16` with the port, and a string of the hostname.
1802//
1803// %G_RESOLVER_RECORD_MX records are returned as variants with the signature
1804// `(qs)`, representing a `guint16` with the preference, and a string containing
1805// the mail exchanger hostname.
1806//
1807// %G_RESOLVER_RECORD_TXT records are returned as variants with the signature
1808// `(as)`, representing an array of the strings in the text record. Note: Most TXT
1809// records only contain a single string, but
1810// [RFC 1035](https://tools.ietf.org/html/rfc1035#section-3.3.14) does allow a
1811// record to contain multiple strings. The RFC which defines the interpretation
1812// of a specific TXT record will likely require concatenation of multiple
1813// strings if they are present, as with
1814// [RFC 7208](https://tools.ietf.org/html/rfc7208#section-3.3).
1815//
1816// %G_RESOLVER_RECORD_SOA records are returned as variants with the signature
1817// `(ssuuuuu)`, representing a string containing the primary name server, a
1818// string containing the administrator, the serial as a `guint32`, the refresh
1819// interval as a `guint32`, the retry interval as a `guint32`, the expire timeout
1820// as a `guint32`, and the TTL as a `guint32`.
1821//
1822// %G_RESOLVER_RECORD_NS records are returned as variants with the signature
1823// `(s)`, representing a string of the hostname of the name server.
1824type ResolverRecordType int
1825
1826var xResolverRecordTypeGLibType func() types.GType
1827
1828func ResolverRecordTypeGLibType() types.GType {
1829	return xResolverRecordTypeGLibType()
1830}
1831
1832const (
1833
1834	// look up DNS SRV records for a domain
1835	GResolverRecordSrvValue ResolverRecordType = 1
1836	// look up DNS MX records for a domain
1837	GResolverRecordMxValue ResolverRecordType = 2
1838	// look up DNS TXT records for a name
1839	GResolverRecordTxtValue ResolverRecordType = 3
1840	// look up DNS SOA records for a zone
1841	GResolverRecordSoaValue ResolverRecordType = 4
1842	// look up DNS NS records for a domain
1843	GResolverRecordNsValue ResolverRecordType = 5
1844)
1845
1846// An error code used with %G_RESOURCE_ERROR in a #GError returned
1847// from a #GResource routine.
1848type ResourceError int
1849
1850var xResourceErrorGLibType func() types.GType
1851
1852func ResourceErrorGLibType() types.GType {
1853	return xResourceErrorGLibType()
1854}
1855
1856const (
1857
1858	// no file was found at the requested path
1859	GResourceErrorNotFoundValue ResourceError = 0
1860	// unknown error
1861	GResourceErrorInternalValue ResourceError = 1
1862)
1863
1864// Describes an event occurring on a #GSocketClient. See the
1865// #GSocketClient::event signal for more details.
1866//
1867// Additional values may be added to this type in the future.
1868type SocketClientEvent int
1869
1870var xSocketClientEventGLibType func() types.GType
1871
1872func SocketClientEventGLibType() types.GType {
1873	return xSocketClientEventGLibType()
1874}
1875
1876const (
1877
1878	// The client is doing a DNS lookup.
1879	GSocketClientResolvingValue SocketClientEvent = 0
1880	// The client has completed a DNS lookup.
1881	GSocketClientResolvedValue SocketClientEvent = 1
1882	// The client is connecting to a remote
1883	//   host (either a proxy or the destination server).
1884	GSocketClientConnectingValue SocketClientEvent = 2
1885	// The client has connected to a remote
1886	//   host.
1887	GSocketClientConnectedValue SocketClientEvent = 3
1888	// The client is negotiating
1889	//   with a proxy to connect to the destination server.
1890	GSocketClientProxyNegotiatingValue SocketClientEvent = 4
1891	// The client has negotiated
1892	//   with the proxy server.
1893	GSocketClientProxyNegotiatedValue SocketClientEvent = 5
1894	// The client is performing a
1895	//   TLS handshake.
1896	GSocketClientTlsHandshakingValue SocketClientEvent = 6
1897	// The client has performed a
1898	//   TLS handshake.
1899	GSocketClientTlsHandshakedValue SocketClientEvent = 7
1900	// The client is done with a particular
1901	//   #GSocketConnectable.
1902	GSocketClientCompleteValue SocketClientEvent = 8
1903)
1904
1905// The protocol family of a #GSocketAddress. (These values are
1906// identical to the system defines %AF_INET, %AF_INET6 and %AF_UNIX,
1907// if available.)
1908type SocketFamily int
1909
1910var xSocketFamilyGLibType func() types.GType
1911
1912func SocketFamilyGLibType() types.GType {
1913	return xSocketFamilyGLibType()
1914}
1915
1916const (
1917
1918	// no address family
1919	GSocketFamilyInvalidValue SocketFamily = 0
1920	// the UNIX domain family
1921	GSocketFamilyUnixValue SocketFamily = 1
1922	// the IPv4 family
1923	GSocketFamilyIpv4Value SocketFamily = 2
1924	// the IPv6 family
1925	GSocketFamilyIpv6Value SocketFamily = 10
1926)
1927
1928// Describes an event occurring on a #GSocketListener. See the
1929// #GSocketListener::event signal for more details.
1930//
1931// Additional values may be added to this type in the future.
1932type SocketListenerEvent int
1933
1934var xSocketListenerEventGLibType func() types.GType
1935
1936func SocketListenerEventGLibType() types.GType {
1937	return xSocketListenerEventGLibType()
1938}
1939
1940const (
1941
1942	// The listener is about to bind a socket.
1943	GSocketListenerBindingValue SocketListenerEvent = 0
1944	// The listener has bound a socket.
1945	GSocketListenerBoundValue SocketListenerEvent = 1
1946	// The listener is about to start
1947	//    listening on this socket.
1948	GSocketListenerListeningValue SocketListenerEvent = 2
1949	// The listener is now listening on
1950	//   this socket.
1951	GSocketListenerListenedValue SocketListenerEvent = 3
1952)
1953
1954// A protocol identifier is specified when creating a #GSocket, which is a
1955// family/type specific identifier, where 0 means the default protocol for
1956// the particular family/type.
1957//
1958// This enum contains a set of commonly available and used protocols. You
1959// can also pass any other identifiers handled by the platform in order to
1960// use protocols not listed here.
1961type SocketProtocol int
1962
1963var xSocketProtocolGLibType func() types.GType
1964
1965func SocketProtocolGLibType() types.GType {
1966	return xSocketProtocolGLibType()
1967}
1968
1969const (
1970
1971	// The protocol type is unknown
1972	GSocketProtocolUnknownValue SocketProtocol = -1
1973	// The default protocol for the family/type
1974	GSocketProtocolDefaultValue SocketProtocol = 0
1975	// TCP over IP
1976	GSocketProtocolTcpValue SocketProtocol = 6
1977	// UDP over IP
1978	GSocketProtocolUdpValue SocketProtocol = 17
1979	// SCTP over IP
1980	GSocketProtocolSctpValue SocketProtocol = 132
1981)
1982
1983// Flags used when creating a #GSocket. Some protocols may not implement
1984// all the socket types.
1985type SocketType int
1986
1987var xSocketTypeGLibType func() types.GType
1988
1989func SocketTypeGLibType() types.GType {
1990	return xSocketTypeGLibType()
1991}
1992
1993const (
1994
1995	// Type unknown or wrong
1996	GSocketTypeInvalidValue SocketType = 0
1997	// Reliable connection-based byte streams (e.g. TCP).
1998	GSocketTypeStreamValue SocketType = 1
1999	// Connectionless, unreliable datagram passing.
2000	//     (e.g. UDP)
2001	GSocketTypeDatagramValue SocketType = 2
2002	// Reliable connection-based passing of datagrams
2003	//     of fixed maximum length (e.g. SCTP).
2004	GSocketTypeSeqpacketValue SocketType = 3
2005)
2006
2007// The client authentication mode for a #GTlsServerConnection.
2008type TlsAuthenticationMode int
2009
2010var xTlsAuthenticationModeGLibType func() types.GType
2011
2012func TlsAuthenticationModeGLibType() types.GType {
2013	return xTlsAuthenticationModeGLibType()
2014}
2015
2016const (
2017
2018	// client authentication not required
2019	GTlsAuthenticationNoneValue TlsAuthenticationMode = 0
2020	// client authentication is requested
2021	GTlsAuthenticationRequestedValue TlsAuthenticationMode = 1
2022	// client authentication is required
2023	GTlsAuthenticationRequiredValue TlsAuthenticationMode = 2
2024)
2025
2026// Flags for g_tls_interaction_request_certificate(),
2027// g_tls_interaction_request_certificate_async(), and
2028// g_tls_interaction_invoke_request_certificate().
2029type TlsCertificateRequestFlags int
2030
2031var xTlsCertificateRequestFlagsGLibType func() types.GType
2032
2033func TlsCertificateRequestFlagsGLibType() types.GType {
2034	return xTlsCertificateRequestFlagsGLibType()
2035}
2036
2037const (
2038
2039	// No flags
2040	GTlsCertificateRequestNoneValue TlsCertificateRequestFlags = 0
2041)
2042
2043// An error code used with %G_TLS_CHANNEL_BINDING_ERROR in a #GError to
2044// indicate a TLS channel binding retrieval error.
2045type TlsChannelBindingError int
2046
2047var xTlsChannelBindingErrorGLibType func() types.GType
2048
2049func TlsChannelBindingErrorGLibType() types.GType {
2050	return xTlsChannelBindingErrorGLibType()
2051}
2052
2053const (
2054
2055	// Either entire binding
2056	//    retrieval facility or specific binding type is not implemented in the
2057	//    TLS backend.
2058	GTlsChannelBindingErrorNotImplementedValue TlsChannelBindingError = 0
2059	// The handshake is not yet
2060	//    complete on the connection which is a strong requirement for any existing
2061	//    binding type.
2062	GTlsChannelBindingErrorInvalidStateValue TlsChannelBindingError = 1
2063	// Handshake is complete but
2064	//    binding data is not available. That normally indicates the TLS
2065	//    implementation failed to provide the binding data. For example, some
2066	//    implementations do not provide a peer certificate for resumed connections.
2067	GTlsChannelBindingErrorNotAvailableValue TlsChannelBindingError = 2
2068	// Binding type is not supported
2069	//    on the current connection. This error could be triggered when requesting
2070	//    `tls-server-end-point` binding data for a certificate which has no hash
2071	//    function or uses multiple hash functions.
2072	GTlsChannelBindingErrorNotSupportedValue TlsChannelBindingError = 3
2073	// Any other backend error
2074	//    preventing binding data retrieval.
2075	GTlsChannelBindingErrorGeneralErrorValue TlsChannelBindingError = 4
2076)
2077
2078// The type of TLS channel binding data to retrieve from #GTlsConnection
2079// or #GDtlsConnection, as documented by RFC 5929 or RFC 9266. The
2080// [`tls-unique-for-telnet`](https://tools.ietf.org/html/rfc5929#section-5)
2081// binding type is not currently implemented.
2082type TlsChannelBindingType int
2083
2084var xTlsChannelBindingTypeGLibType func() types.GType
2085
2086func TlsChannelBindingTypeGLibType() types.GType {
2087	return xTlsChannelBindingTypeGLibType()
2088}
2089
2090const (
2091
2092	// [`tls-unique`](https://tools.ietf.org/html/rfc5929#section-3) binding
2093	//    type
2094	GTlsChannelBindingTlsUniqueValue TlsChannelBindingType = 0
2095	// [`tls-server-end-point`](https://tools.ietf.org/html/rfc5929#section-4)
2096	//    binding type
2097	GTlsChannelBindingTlsServerEndPointValue TlsChannelBindingType = 1
2098	// [`tls-exporter`](https://www.rfc-editor.org/rfc/rfc9266.html) binding
2099	//    type. Since: 2.74
2100	GTlsChannelBindingTlsExporterValue TlsChannelBindingType = 2
2101)
2102
2103// Flags for g_tls_database_lookup_certificate_for_handle(),
2104// g_tls_database_lookup_certificate_issuer(),
2105// and g_tls_database_lookup_certificates_issued_by().
2106type TlsDatabaseLookupFlags int
2107
2108var xTlsDatabaseLookupFlagsGLibType func() types.GType
2109
2110func TlsDatabaseLookupFlagsGLibType() types.GType {
2111	return xTlsDatabaseLookupFlagsGLibType()
2112}
2113
2114const (
2115
2116	// No lookup flags
2117	GTlsDatabaseLookupNoneValue TlsDatabaseLookupFlags = 0
2118	// Restrict lookup to certificates that have
2119	//     a private key.
2120	GTlsDatabaseLookupKeypairValue TlsDatabaseLookupFlags = 1
2121)
2122
2123// An error code used with %G_TLS_ERROR in a #GError returned from a
2124// TLS-related routine.
2125type TlsError int
2126
2127var xTlsErrorGLibType func() types.GType
2128
2129func TlsErrorGLibType() types.GType {
2130	return xTlsErrorGLibType()
2131}
2132
2133const (
2134
2135	// No TLS provider is available
2136	GTlsErrorUnavailableValue TlsError = 0
2137	// Miscellaneous TLS error
2138	GTlsErrorMiscValue TlsError = 1
2139	// The certificate presented could not
2140	//   be parsed or failed validation.
2141	GTlsErrorBadCertificateValue TlsError = 2
2142	// The TLS handshake failed because the
2143	//   peer does not seem to be a TLS server.
2144	GTlsErrorNotTlsValue TlsError = 3
2145	// The TLS handshake failed because the
2146	//   peer's certificate was not acceptable.
2147	GTlsErrorHandshakeValue TlsError = 4
2148	// The TLS handshake failed because
2149	//   the server requested a client-side certificate, but none was
2150	//   provided. See g_tls_connection_set_certificate().
2151	GTlsErrorCertificateRequiredValue TlsError = 5
2152	// The TLS connection was closed without proper
2153	//   notice, which may indicate an attack. See
2154	//   g_tls_connection_set_require_close_notify().
2155	GTlsErrorEofValue TlsError = 6
2156	// The TLS handshake failed
2157	//   because the client sent the fallback SCSV, indicating a protocol
2158	//   downgrade attack. Since: 2.60
2159	GTlsErrorInappropriateFallbackValue TlsError = 7
2160	// The certificate failed
2161	//   to load because a password was incorrect. Since: 2.72
2162	GTlsErrorBadCertificatePasswordValue TlsError = 8
2163)
2164
2165// #GTlsInteractionResult is returned by various functions in #GTlsInteraction
2166// when finishing an interaction request.
2167type TlsInteractionResult int
2168
2169var xTlsInteractionResultGLibType func() types.GType
2170
2171func TlsInteractionResultGLibType() types.GType {
2172	return xTlsInteractionResultGLibType()
2173}
2174
2175const (
2176
2177	// The interaction was unhandled (i.e. not
2178	//     implemented).
2179	GTlsInteractionUnhandledValue TlsInteractionResult = 0
2180	// The interaction completed, and resulting data
2181	//     is available.
2182	GTlsInteractionHandledValue TlsInteractionResult = 1
2183	// The interaction has failed, or was cancelled.
2184	//     and the operation should be aborted.
2185	GTlsInteractionFailedValue TlsInteractionResult = 2
2186)
2187
2188// The TLS or DTLS protocol version used by a #GTlsConnection or
2189// #GDtlsConnection. The integer values of these versions are sequential
2190// to ensure newer known protocol versions compare greater than older
2191// known versions. Any known DTLS protocol version will compare greater
2192// than any SSL or TLS protocol version. The protocol version may be
2193// %G_TLS_PROTOCOL_VERSION_UNKNOWN if the TLS backend supports a newer
2194// protocol version that GLib does not yet know about. This means that
2195// it's possible for an unknown DTLS protocol version to compare less
2196// than the TLS protocol versions.
2197type TlsProtocolVersion int
2198
2199var xTlsProtocolVersionGLibType func() types.GType
2200
2201func TlsProtocolVersionGLibType() types.GType {
2202	return xTlsProtocolVersionGLibType()
2203}
2204
2205const (
2206
2207	// No protocol version or unknown protocol version
2208	GTlsProtocolVersionUnknownValue TlsProtocolVersion = 0
2209	// SSL 3.0, which is insecure and should not be used
2210	GTlsProtocolVersionSsl30Value TlsProtocolVersion = 1
2211	// TLS 1.0, which is insecure and should not be used
2212	GTlsProtocolVersionTls10Value TlsProtocolVersion = 2
2213	// TLS 1.1, which is insecure and should not be used
2214	GTlsProtocolVersionTls11Value TlsProtocolVersion = 3
2215	// TLS 1.2, defined by [RFC 5246](https://datatracker.ietf.org/doc/html/rfc5246)
2216	GTlsProtocolVersionTls12Value TlsProtocolVersion = 4
2217	// TLS 1.3, defined by [RFC 8446](https://datatracker.ietf.org/doc/html/rfc8446)
2218	GTlsProtocolVersionTls13Value TlsProtocolVersion = 5
2219	// DTLS 1.0, which is insecure and should not be used
2220	GTlsProtocolVersionDtls10Value TlsProtocolVersion = 201
2221	// DTLS 1.2, defined by [RFC 6347](https://datatracker.ietf.org/doc/html/rfc6347)
2222	GTlsProtocolVersionDtls12Value TlsProtocolVersion = 202
2223)
2224
2225// When to allow rehandshaking. See
2226// g_tls_connection_set_rehandshake_mode().
2227type TlsRehandshakeMode int
2228
2229var xTlsRehandshakeModeGLibType func() types.GType
2230
2231func TlsRehandshakeModeGLibType() types.GType {
2232	return xTlsRehandshakeModeGLibType()
2233}
2234
2235const (
2236
2237	// Never allow rehandshaking
2238	GTlsRehandshakeNeverValue TlsRehandshakeMode = 0
2239	// Allow safe rehandshaking only
2240	GTlsRehandshakeSafelyValue TlsRehandshakeMode = 1
2241	// Allow unsafe rehandshaking
2242	GTlsRehandshakeUnsafelyValue TlsRehandshakeMode = 2
2243)
2244
2245// The type of name used by a #GUnixSocketAddress.
2246// %G_UNIX_SOCKET_ADDRESS_PATH indicates a traditional unix domain
2247// socket bound to a filesystem path. %G_UNIX_SOCKET_ADDRESS_ANONYMOUS
2248// indicates a socket not bound to any name (eg, a client-side socket,
2249// or a socket created with socketpair()).
2250//
2251// For abstract sockets, there are two incompatible ways of naming
2252// them; the man pages suggest using the entire `struct sockaddr_un`
2253// as the name, padding the unused parts of the %sun_path field with
2254// zeroes; this corresponds to %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED.
2255// However, many programs instead just use a portion of %sun_path, and
2256// pass an appropriate smaller length to bind() or connect(). This is
2257// %G_UNIX_SOCKET_ADDRESS_ABSTRACT.
2258type UnixSocketAddressType int
2259
2260var xUnixSocketAddressTypeGLibType func() types.GType
2261
2262func UnixSocketAddressTypeGLibType() types.GType {
2263	return xUnixSocketAddressTypeGLibType()
2264}
2265
2266const (
2267
2268	// invalid
2269	GUnixSocketAddressInvalidValue UnixSocketAddressType = 0
2270	// anonymous
2271	GUnixSocketAddressAnonymousValue UnixSocketAddressType = 1
2272	// a filesystem path
2273	GUnixSocketAddressPathValue UnixSocketAddressType = 2
2274	// an abstract name
2275	GUnixSocketAddressAbstractValue UnixSocketAddressType = 3
2276	// an abstract name, 0-padded
2277	//   to the full length of a unix socket name
2278	GUnixSocketAddressAbstractPaddedValue UnixSocketAddressType = 4
2279)
2280
2281// Used to select the type of data format to use for #GZlibDecompressor
2282// and #GZlibCompressor.
2283type ZlibCompressorFormat int
2284
2285var xZlibCompressorFormatGLibType func() types.GType
2286
2287func ZlibCompressorFormatGLibType() types.GType {
2288	return xZlibCompressorFormatGLibType()
2289}
2290
2291const (
2292
2293	// deflate compression with zlib header
2294	GZlibCompressorFormatZlibValue ZlibCompressorFormat = 0
2295	// gzip file format
2296	GZlibCompressorFormatGzipValue ZlibCompressorFormat = 1
2297	// deflate compression with no header
2298	GZlibCompressorFormatRawValue ZlibCompressorFormat = 2
2299)