// Package gio was automatically generated by github.com/bnema/puregotk DO NOT EDIT
package gio

import (
	"github.com/bnema/puregotk/v4/gobject/types"
)

// Flags used when creating a #GAppInfo.
type AppInfoCreateFlags int

var xAppInfoCreateFlagsGLibType func() types.GType

func AppInfoCreateFlagsGLibType() types.GType {
	return xAppInfoCreateFlagsGLibType()
}

const (

	// No flags.
	GAppInfoCreateNoneValue AppInfoCreateFlags = 0
	// Application opens in a terminal window.
	GAppInfoCreateNeedsTerminalValue AppInfoCreateFlags = 1
	// Application supports URI arguments.
	GAppInfoCreateSupportsUrisValue AppInfoCreateFlags = 2
	// Application supports startup notification. Since 2.26
	GAppInfoCreateSupportsStartupNotificationValue AppInfoCreateFlags = 4
)

// Flags used to define the behaviour of a #GApplication.
type ApplicationFlags int

var xApplicationFlagsGLibType func() types.GType

func ApplicationFlagsGLibType() types.GType {
	return xApplicationFlagsGLibType()
}

const (

	// Default flags.
	GApplicationFlagsNoneValue ApplicationFlags = 0
	// Default flags.
	GApplicationDefaultFlagsValue ApplicationFlags = 0
	// Run as a service. In this mode, registration
	//      fails if the service is already running, and the application
	//      will initially wait up to 10 seconds for an initial activation
	//      message to arrive.
	GApplicationIsServiceValue ApplicationFlags = 1
	// Don't try to become the primary instance.
	GApplicationIsLauncherValue ApplicationFlags = 2
	// This application handles opening files (in
	//     the primary instance). Note that this flag only affects the default
	//     implementation of local_command_line(), and has no effect if
	//     %G_APPLICATION_HANDLES_COMMAND_LINE is given.
	//     See g_application_run() for details.
	GApplicationHandlesOpenValue ApplicationFlags = 4
	// This application handles command line
	//     arguments (in the primary instance). Note that this flag only affect
	//     the default implementation of local_command_line().
	//     See g_application_run() for details.
	GApplicationHandlesCommandLineValue ApplicationFlags = 8
	// Send the environment of the
	//     launching process to the primary instance. Set this flag if your
	//     application is expected to behave differently depending on certain
	//     environment variables. For instance, an editor might be expected
	//     to use the `GIT_COMMITTER_NAME` environment variable
	//     when editing a git commit message. The environment is available
	//     to the #GApplication::command-line signal handler, via
	//     g_application_command_line_getenv().
	GApplicationSendEnvironmentValue ApplicationFlags = 16
	// Make no attempts to do any of the typical
	//     single-instance application negotiation, even if the application
	//     ID is given.  The application neither attempts to become the
	//     owner of the application ID nor does it check if an existing
	//     owner already exists.  Everything occurs in the local process.
	//     Since: 2.30.
	GApplicationNonUniqueValue ApplicationFlags = 32
	// Allow users to override the
	//     application ID from the command line with `--gapplication-app-id`.
	//     Since: 2.48
	GApplicationCanOverrideAppIdValue ApplicationFlags = 64
	// Allow another instance to take over
	//     the bus name. Since: 2.60
	GApplicationAllowReplacementValue ApplicationFlags = 128
	// Take over from another instance. This flag is
	//     usually set by passing `--gapplication-replace` on the commandline.
	//     Since: 2.60
	GApplicationReplaceValue ApplicationFlags = 256
)

// #GAskPasswordFlags are used to request specific information from the
// user, or to notify the user of their choices in an authentication
// situation.
type AskPasswordFlags int

var xAskPasswordFlagsGLibType func() types.GType

func AskPasswordFlagsGLibType() types.GType {
	return xAskPasswordFlagsGLibType()
}

const (

	// operation requires a password.
	GAskPasswordNeedPasswordValue AskPasswordFlags = 1
	// operation requires a username.
	GAskPasswordNeedUsernameValue AskPasswordFlags = 2
	// operation requires a domain.
	GAskPasswordNeedDomainValue AskPasswordFlags = 4
	// operation supports saving settings.
	GAskPasswordSavingSupportedValue AskPasswordFlags = 8
	// operation supports anonymous users.
	GAskPasswordAnonymousSupportedValue AskPasswordFlags = 16
	// operation takes TCRYPT parameters (Since: 2.58)
	GAskPasswordTcryptValue AskPasswordFlags = 32
)

// Flags used in g_bus_own_name().
type BusNameOwnerFlags int

var xBusNameOwnerFlagsGLibType func() types.GType

func BusNameOwnerFlagsGLibType() types.GType {
	return xBusNameOwnerFlagsGLibType()
}

const (

	// No flags set.
	GBusNameOwnerFlagsNoneValue BusNameOwnerFlags = 0
	// Allow another message bus connection to claim the name.
	GBusNameOwnerFlagsAllowReplacementValue BusNameOwnerFlags = 1
	// If another message bus connection owns the name and have
	// specified %G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT, then take the name from the other connection.
	GBusNameOwnerFlagsReplaceValue BusNameOwnerFlags = 2
	// If another message bus connection owns the name, immediately return an error
	// from [func@Gio.bus_own_name] rather than entering the waiting queue for that
	// name.
	GBusNameOwnerFlagsDoNotQueueValue BusNameOwnerFlags = 4
)

// Flags used in g_bus_watch_name().
type BusNameWatcherFlags int

var xBusNameWatcherFlagsGLibType func() types.GType

func BusNameWatcherFlagsGLibType() types.GType {
	return xBusNameWatcherFlagsGLibType()
}

const (

	// No flags set.
	GBusNameWatcherFlagsNoneValue BusNameWatcherFlags = 0
	// If no-one owns the name when
	// beginning to watch the name, ask the bus to launch an owner for the
	// name.
	GBusNameWatcherFlagsAutoStartValue BusNameWatcherFlags = 1
)

// Flags used when calling a g_converter_convert().
type ConverterFlags int

var xConverterFlagsGLibType func() types.GType

func ConverterFlagsGLibType() types.GType {
	return xConverterFlagsGLibType()
}

const (

	// No flags.
	GConverterNoFlagsValue ConverterFlags = 0
	// At end of input data
	GConverterInputAtEndValue ConverterFlags = 1
	// Flush data
	GConverterFlushValue ConverterFlags = 2
)

// Flags used in g_dbus_connection_call() and similar APIs.
type DBusCallFlags int

var xDBusCallFlagsGLibType func() types.GType

func DBusCallFlagsGLibType() types.GType {
	return xDBusCallFlagsGLibType()
}

const (

	// No flags set.
	GDbusCallFlagsNoneValue DBusCallFlags = 0
	// The bus must not launch
	// an owner for the destination name in response to this method
	// invocation.
	GDbusCallFlagsNoAutoStartValue DBusCallFlags = 1
	// the caller is prepared to
	// wait for interactive authorization. Since 2.46.
	GDbusCallFlagsAllowInteractiveAuthorizationValue DBusCallFlags = 2
)

// Capabilities negotiated with the remote peer.
type DBusCapabilityFlags int

var xDBusCapabilityFlagsGLibType func() types.GType

func DBusCapabilityFlagsGLibType() types.GType {
	return xDBusCapabilityFlagsGLibType()
}

const (

	// No flags set.
	GDbusCapabilityFlagsNoneValue DBusCapabilityFlags = 0
	// The connection
	// supports exchanging UNIX file descriptors with the remote peer.
	GDbusCapabilityFlagsUnixFdPassingValue DBusCapabilityFlags = 1
)

// Flags used when creating a new #GDBusConnection.
type DBusConnectionFlags int

var xDBusConnectionFlagsGLibType func() types.GType

func DBusConnectionFlagsGLibType() types.GType {
	return xDBusConnectionFlagsGLibType()
}

const (

	// No flags set.
	GDbusConnectionFlagsNoneValue DBusConnectionFlags = 0
	// Perform authentication against server.
	GDbusConnectionFlagsAuthenticationClientValue DBusConnectionFlags = 1
	// Perform authentication against client.
	GDbusConnectionFlagsAuthenticationServerValue DBusConnectionFlags = 2
	// When
	// authenticating as a server, allow the anonymous authentication
	// method.
	GDbusConnectionFlagsAuthenticationAllowAnonymousValue DBusConnectionFlags = 4
	// Pass this flag if connecting to a peer that is a
	// message bus. This means that the Hello() method will be invoked as part of the connection setup.
	GDbusConnectionFlagsMessageBusConnectionValue DBusConnectionFlags = 8
	// If set, processing of D-Bus messages is
	// delayed until g_dbus_connection_start_message_processing() is called.
	GDbusConnectionFlagsDelayMessageProcessingValue DBusConnectionFlags = 16
	// When authenticating
	// as a server, require the UID of the peer to be the same as the UID of the server. (Since: 2.68)
	GDbusConnectionFlagsAuthenticationRequireSameUserValue DBusConnectionFlags = 32
	// When authenticating, try to use
	//  protocols that work across a Linux user namespace boundary, even if this
	//  reduces interoperability with older D-Bus implementations. This currently
	//  affects client-side `EXTERNAL` authentication, for which this flag makes
	//  connections to a server in another user namespace succeed, but causes
	//  a deadlock when connecting to a GDBus server older than 2.73.3. Since: 2.74
	GDbusConnectionFlagsCrossNamespaceValue DBusConnectionFlags = 64
)

// Flags describing the behavior of a #GDBusInterfaceSkeleton instance.
type DBusInterfaceSkeletonFlags int

var xDBusInterfaceSkeletonFlagsGLibType func() types.GType

func DBusInterfaceSkeletonFlagsGLibType() types.GType {
	return xDBusInterfaceSkeletonFlagsGLibType()
}

const (

	// No flags set.
	GDbusInterfaceSkeletonFlagsNoneValue DBusInterfaceSkeletonFlags = 0
	// Each method invocation is handled in
	//   a thread dedicated to the invocation. This means that the method implementation can use blocking IO
	//   without blocking any other part of the process. It also means that the method implementation must
	//   use locking to access data structures used by other threads.
	GDbusInterfaceSkeletonFlagsHandleMethodInvocationsInThreadValue DBusInterfaceSkeletonFlags = 1
)

// Message flags used in #GDBusMessage.
type DBusMessageFlags int

var xDBusMessageFlagsGLibType func() types.GType

func DBusMessageFlagsGLibType() types.GType {
	return xDBusMessageFlagsGLibType()
}

const (

	// No flags set.
	GDbusMessageFlagsNoneValue DBusMessageFlags = 0
	// A reply is not expected.
	GDbusMessageFlagsNoReplyExpectedValue DBusMessageFlags = 1
	// The bus must not launch an
	// owner for the destination name in response to this message.
	GDbusMessageFlagsNoAutoStartValue DBusMessageFlags = 2
	// If set on a method
	// call, this flag means that the caller is prepared to wait for interactive
	// authorization. Since 2.46.
	GDbusMessageFlagsAllowInteractiveAuthorizationValue DBusMessageFlags = 4
)

// Flags used when constructing a #GDBusObjectManagerClient.
type DBusObjectManagerClientFlags int

var xDBusObjectManagerClientFlagsGLibType func() types.GType

func DBusObjectManagerClientFlagsGLibType() types.GType {
	return xDBusObjectManagerClientFlagsGLibType()
}

const (

	// No flags set.
	GDbusObjectManagerClientFlagsNoneValue DBusObjectManagerClientFlags = 0
	// If not set and the
	//   manager is for a well-known name, then request the bus to launch
	//   an owner for the name if no-one owns the name. This flag can only
	//   be used in managers for well-known names.
	GDbusObjectManagerClientFlagsDoNotAutoStartValue DBusObjectManagerClientFlags = 1
)

// Flags describing the access control of a D-Bus property.
type DBusPropertyInfoFlags int

var xDBusPropertyInfoFlagsGLibType func() types.GType

func DBusPropertyInfoFlagsGLibType() types.GType {
	return xDBusPropertyInfoFlagsGLibType()
}

const (

	// No flags set.
	GDbusPropertyInfoFlagsNoneValue DBusPropertyInfoFlags = 0
	// Property is readable.
	GDbusPropertyInfoFlagsReadableValue DBusPropertyInfoFlags = 1
	// Property is writable.
	GDbusPropertyInfoFlagsWritableValue DBusPropertyInfoFlags = 2
)

// Flags used when constructing an instance of a #GDBusProxy derived class.
type DBusProxyFlags int

var xDBusProxyFlagsGLibType func() types.GType

func DBusProxyFlagsGLibType() types.GType {
	return xDBusProxyFlagsGLibType()
}

const (

	// No flags set.
	GDbusProxyFlagsNoneValue DBusProxyFlags = 0
	// Don't load properties.
	GDbusProxyFlagsDoNotLoadPropertiesValue DBusProxyFlags = 1
	// Don't connect to signals on the remote object.
	GDbusProxyFlagsDoNotConnectSignalsValue DBusProxyFlags = 2
	// If the proxy is for a well-known name,
	// do not ask the bus to launch an owner during proxy initialization or a method call.
	// This flag is only meaningful in proxies for well-known names.
	GDbusProxyFlagsDoNotAutoStartValue DBusProxyFlags = 4
	// 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.
	GDbusProxyFlagsGetInvalidatedPropertiesValue DBusProxyFlags = 8
	// If the proxy is for a well-known name,
	// do not ask the bus to launch an owner during proxy initialization, but allow it to be
	// autostarted by a method call. This flag is only meaningful in proxies for well-known names,
	// and only if %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START is not also specified.
	GDbusProxyFlagsDoNotAutoStartAtConstructionValue DBusProxyFlags = 16
	// Don't actually send the AddMatch D-Bus
	//    call for this signal subscription. This gives you more control
	//    over which match rules you add (but you must add them manually). (Since: 2.72)
	GDbusProxyFlagsNoMatchRuleValue DBusProxyFlags = 32
)

// Flags used when sending #GDBusMessages on a #GDBusConnection.
type DBusSendMessageFlags int

var xDBusSendMessageFlagsGLibType func() types.GType

func DBusSendMessageFlagsGLibType() types.GType {
	return xDBusSendMessageFlagsGLibType()
}

const (

	// No flags set.
	GDbusSendMessageFlagsNoneValue DBusSendMessageFlags = 0
	// Do not automatically
	// assign a serial number from the #GDBusConnection object when
	// sending a message.
	GDbusSendMessageFlagsPreserveSerialValue DBusSendMessageFlags = 1
)

// Flags used when creating a #GDBusServer.
type DBusServerFlags int

var xDBusServerFlagsGLibType func() types.GType

func DBusServerFlagsGLibType() types.GType {
	return xDBusServerFlagsGLibType()
}

const (

	// No flags set.
	GDbusServerFlagsNoneValue DBusServerFlags = 0
	// All #GDBusServer::new-connection
	// signals will run in separated dedicated threads (see signal for
	// details).
	GDbusServerFlagsRunInThreadValue DBusServerFlags = 1
	// Allow the anonymous
	// authentication method.
	GDbusServerFlagsAuthenticationAllowAnonymousValue DBusServerFlags = 2
	// Require the UID of the
	// peer to be the same as the UID of the server when authenticating. (Since: 2.68)
	GDbusServerFlagsAuthenticationRequireSameUserValue DBusServerFlags = 4
)

// Flags used when subscribing to signals via g_dbus_connection_signal_subscribe().
type DBusSignalFlags int

var xDBusSignalFlagsGLibType func() types.GType

func DBusSignalFlagsGLibType() types.GType {
	return xDBusSignalFlagsGLibType()
}

const (

	// No flags set.
	GDbusSignalFlagsNoneValue DBusSignalFlags = 0
	// Don't actually send the AddMatch
	// D-Bus call for this signal subscription.  This gives you more control
	// over which match rules you add (but you must add them manually).
	GDbusSignalFlagsNoMatchRuleValue DBusSignalFlags = 1
	// Match first arguments that
	// contain a bus or interface name with the given namespace.
	GDbusSignalFlagsMatchArg0NamespaceValue DBusSignalFlags = 2
	// Match first arguments that
	// contain an object path that is either equivalent to the given path,
	// or one of the paths is a subpath of the other.
	GDbusSignalFlagsMatchArg0PathValue DBusSignalFlags = 4
)

// Flags passed to g_dbus_connection_register_subtree().
type DBusSubtreeFlags int

var xDBusSubtreeFlagsGLibType func() types.GType

func DBusSubtreeFlagsGLibType() types.GType {
	return xDBusSubtreeFlagsGLibType()
}

const (

	// No flags set.
	GDbusSubtreeFlagsNoneValue DBusSubtreeFlags = 0
	// Method calls to objects not in the enumerated range
	//                                                       will still be dispatched. This is useful if you want
	//                                                       to dynamically spawn objects in the subtree.
	GDbusSubtreeFlagsDispatchToUnenumeratedNodesValue DBusSubtreeFlags = 1
)

// Flags used when starting a drive.
type DriveStartFlags int

var xDriveStartFlagsGLibType func() types.GType

func DriveStartFlagsGLibType() types.GType {
	return xDriveStartFlagsGLibType()
}

const (

	// No flags set.
	GDriveStartNoneValue DriveStartFlags = 0
)

// Flags specifying the behaviour of an attribute.
type FileAttributeInfoFlags int

var xFileAttributeInfoFlagsGLibType func() types.GType

func FileAttributeInfoFlagsGLibType() types.GType {
	return xFileAttributeInfoFlagsGLibType()
}

const (

	// no flags set.
	GFileAttributeInfoNoneValue FileAttributeInfoFlags = 0
	// copy the attribute values when the file is copied.
	GFileAttributeInfoCopyWithFileValue FileAttributeInfoFlags = 1
	// copy the attribute values when the file is moved.
	GFileAttributeInfoCopyWhenMovedValue FileAttributeInfoFlags = 2
)

// Flags used when copying or moving files.
type FileCopyFlags int

var xFileCopyFlagsGLibType func() types.GType

func FileCopyFlagsGLibType() types.GType {
	return xFileCopyFlagsGLibType()
}

const (

	// No flags set.
	GFileCopyNoneValue FileCopyFlags = 0
	// Overwrite any existing files
	GFileCopyOverwriteValue FileCopyFlags = 1
	// Make a backup of any existing files.
	GFileCopyBackupValue FileCopyFlags = 2
	// Don't follow symlinks.
	GFileCopyNofollowSymlinksValue FileCopyFlags = 4
	// Copy all file metadata instead of just default set used for copy (see #GFileInfo).
	GFileCopyAllMetadataValue FileCopyFlags = 8
	// Don't use copy and delete fallback if native move not supported.
	GFileCopyNoFallbackForMoveValue FileCopyFlags = 16
	// Leaves target file with default perms, instead of setting the source file perms.
	GFileCopyTargetDefaultPermsValue FileCopyFlags = 32
	// Use default modification
	//     timestamps instead of copying them from the source file. Since 2.80
	GFileCopyTargetDefaultModifiedTimeValue FileCopyFlags = 64
)

// Flags used when an operation may create a file.
type FileCreateFlags int

var xFileCreateFlagsGLibType func() types.GType

func FileCreateFlagsGLibType() types.GType {
	return xFileCreateFlagsGLibType()
}

const (

	// No flags set.
	GFileCreateNoneValue FileCreateFlags = 0
	// Create a file that can only be
	//    accessed by the current user.
	GFileCreatePrivateValue FileCreateFlags = 1
	// Replace the destination
	//    as if it didn't exist before. Don't try to keep any old
	//    permissions, replace instead of following links. This
	//    is generally useful if you're doing a "copy over"
	//    rather than a "save new version of" replace operation.
	//    You can think of it as "unlink destination" before
	//    writing to it, although the implementation may not
	//    be exactly like that. This flag can only be used with
	//    g_file_replace() and its variants, including g_file_replace_contents().
	//    Since 2.20
	GFileCreateReplaceDestinationValue FileCreateFlags = 2
)

// Flags that can be used with g_file_measure_disk_usage().
type FileMeasureFlags int

var xFileMeasureFlagsGLibType func() types.GType

func FileMeasureFlagsGLibType() types.GType {
	return xFileMeasureFlagsGLibType()
}

const (

	// No flags set.
	GFileMeasureNoneValue FileMeasureFlags = 0
	// Report any error encountered
	//   while traversing the directory tree.  Normally errors are only
	//   reported for the toplevel file.
	GFileMeasureReportAnyErrorValue FileMeasureFlags = 2
	// Tally usage based on apparent file
	//   sizes.  Normally, the block-size is used, if available, as this is a
	//   more accurate representation of disk space used.
	//   Compare with `du --apparent-size`.
	//   Since GLib 2.78. and similarly to `du` since GNU Coreutils 9.2, this will
	//   ignore the sizes of file types other than regular files and links, as the
	//   sizes of other file types are not specified in a standard way.
	GFileMeasureApparentSizeValue FileMeasureFlags = 4
	// Do not cross mount point boundaries.
	//   Compare with `du -x`.
	GFileMeasureNoXdevValue FileMeasureFlags = 8
)

// Flags used to set what a #GFileMonitor will watch for.
type FileMonitorFlags int

var xFileMonitorFlagsGLibType func() types.GType

func FileMonitorFlagsGLibType() types.GType {
	return xFileMonitorFlagsGLibType()
}

const (

	// No flags set.
	GFileMonitorNoneValue FileMonitorFlags = 0
	// Watch for mount events.
	GFileMonitorWatchMountsValue FileMonitorFlags = 1
	// Pair DELETED and CREATED events caused
	//   by file renames (moves) and send a single G_FILE_MONITOR_EVENT_MOVED
	//   event instead (NB: not supported on all backends; the default
	//   behaviour -without specifying this flag- is to send single DELETED
	//   and CREATED events).  Deprecated since 2.46: use
	//   %G_FILE_MONITOR_WATCH_MOVES instead.
	GFileMonitorSendMovedValue FileMonitorFlags = 2
	// Watch for changes to the file made
	//   via another hard link. Since 2.36.
	GFileMonitorWatchHardLinksValue FileMonitorFlags = 4
	// Watch for rename operations on a
	//   monitored directory.  This causes %G_FILE_MONITOR_EVENT_RENAMED,
	//   %G_FILE_MONITOR_EVENT_MOVED_IN and %G_FILE_MONITOR_EVENT_MOVED_OUT
	//   events to be emitted when possible.  Since: 2.46.
	GFileMonitorWatchMovesValue FileMonitorFlags = 8
)

// Flags used when querying a #GFileInfo.
type FileQueryInfoFlags int

var xFileQueryInfoFlagsGLibType func() types.GType

func FileQueryInfoFlagsGLibType() types.GType {
	return xFileQueryInfoFlagsGLibType()
}

const (

	// No flags set.
	GFileQueryInfoNoneValue FileQueryInfoFlags = 0
	// Don't follow symlinks.
	GFileQueryInfoNofollowSymlinksValue FileQueryInfoFlags = 1
)

// GIOStreamSpliceFlags determine how streams should be spliced.
type IOStreamSpliceFlags int

var xIOStreamSpliceFlagsGLibType func() types.GType

func IOStreamSpliceFlagsGLibType() types.GType {
	return xIOStreamSpliceFlagsGLibType()
}

const (

	// Do not close either stream.
	GIoStreamSpliceNoneValue IOStreamSpliceFlags = 0
	// Close the first stream after
	//     the splice.
	GIoStreamSpliceCloseStream1Value IOStreamSpliceFlags = 1
	// Close the second stream after
	//     the splice.
	GIoStreamSpliceCloseStream2Value IOStreamSpliceFlags = 2
	// Wait for both splice operations to finish
	//     before calling the callback.
	GIoStreamSpliceWaitForBothValue IOStreamSpliceFlags = 4
)

// Flags used when mounting a mount.
type MountMountFlags int

var xMountMountFlagsGLibType func() types.GType

func MountMountFlagsGLibType() types.GType {
	return xMountMountFlagsGLibType()
}

const (

	// No flags set.
	GMountMountNoneValue MountMountFlags = 0
)

// Flags used when an unmounting a mount.
type MountUnmountFlags int

var xMountUnmountFlagsGLibType func() types.GType

func MountUnmountFlagsGLibType() types.GType {
	return xMountUnmountFlagsGLibType()
}

const (

	// No flags set.
	GMountUnmountNoneValue MountUnmountFlags = 0
	// Unmount even if there are outstanding
	//  file operations on the mount.
	GMountUnmountForceValue MountUnmountFlags = 1
)

// GOutputStreamSpliceFlags determine how streams should be spliced.
type OutputStreamSpliceFlags int

var xOutputStreamSpliceFlagsGLibType func() types.GType

func OutputStreamSpliceFlagsGLibType() types.GType {
	return xOutputStreamSpliceFlagsGLibType()
}

const (

	// Do not close either stream.
	GOutputStreamSpliceNoneValue OutputStreamSpliceFlags = 0
	// Close the source stream after
	//     the splice.
	GOutputStreamSpliceCloseSourceValue OutputStreamSpliceFlags = 1
	// Close the target stream after
	//     the splice.
	GOutputStreamSpliceCloseTargetValue OutputStreamSpliceFlags = 2
)

// GResourceFlags give information about a particular file inside a resource
// bundle.
type ResourceFlags int

var xResourceFlagsGLibType func() types.GType

func ResourceFlagsGLibType() types.GType {
	return xResourceFlagsGLibType()
}

const (

	// No flags set.
	GResourceFlagsNoneValue ResourceFlags = 0
	// The file is compressed.
	GResourceFlagsCompressedValue ResourceFlags = 1
)

// GResourceLookupFlags determine how resource path lookups are handled.
type ResourceLookupFlags int

var xResourceLookupFlagsGLibType func() types.GType

func ResourceLookupFlagsGLibType() types.GType {
	return xResourceLookupFlagsGLibType()
}

const (

	// No flags set.
	GResourceLookupFlagsNoneValue ResourceLookupFlags = 0
)

// Flags used in g_socket_receive_message() and g_socket_send_message().
// The flags listed in the enum are some commonly available flags, but the
// values used for them are the same as on the platform, and any other flags
// are passed in/out as is. So to use a platform specific flag, just include
// the right system header and pass in the flag.
type SocketMsgFlags int

var xSocketMsgFlagsGLibType func() types.GType

func SocketMsgFlagsGLibType() types.GType {
	return xSocketMsgFlagsGLibType()
}

const (

	// No flags.
	GSocketMsgNoneValue SocketMsgFlags = 0
	// Request to send/receive out of band data.
	GSocketMsgOobValue SocketMsgFlags = 1
	// Read data from the socket without removing it from
	//     the queue.
	GSocketMsgPeekValue SocketMsgFlags = 2
	// Don't use a gateway to send out the packet,
	//     only send to hosts on directly connected networks.
	GSocketMsgDontrouteValue SocketMsgFlags = 4
)

// Flags to define the behaviour of a #GSubprocess.
//
// Note that the default for stdin is to redirect from `/dev/null`.  For
// stdout and stderr the default are for them to inherit the
// corresponding descriptor from the calling process.
//
// Note that it is a programmer error to mix 'incompatible' flags.  For
// example, you may not request both %G_SUBPROCESS_FLAGS_STDOUT_PIPE and
// %G_SUBPROCESS_FLAGS_STDOUT_SILENCE.
type SubprocessFlags int

var xSubprocessFlagsGLibType func() types.GType

func SubprocessFlagsGLibType() types.GType {
	return xSubprocessFlagsGLibType()
}

const (

	// No flags.
	GSubprocessFlagsNoneValue SubprocessFlags = 0
	// create a pipe for the stdin of the
	//   spawned process that can be accessed with
	//   g_subprocess_get_stdin_pipe().
	GSubprocessFlagsStdinPipeValue SubprocessFlags = 1
	// stdin is inherited from the
	//   calling process.
	GSubprocessFlagsStdinInheritValue SubprocessFlags = 2
	// create a pipe for the stdout of the
	//   spawned process that can be accessed with
	//   g_subprocess_get_stdout_pipe().
	GSubprocessFlagsStdoutPipeValue SubprocessFlags = 4
	// silence the stdout of the spawned
	//   process (ie: redirect to `/dev/null`).
	GSubprocessFlagsStdoutSilenceValue SubprocessFlags = 8
	// create a pipe for the stderr of the
	//   spawned process that can be accessed with
	//   g_subprocess_get_stderr_pipe().
	GSubprocessFlagsStderrPipeValue SubprocessFlags = 16
	// silence the stderr of the spawned
	//   process (ie: redirect to `/dev/null`).
	GSubprocessFlagsStderrSilenceValue SubprocessFlags = 32
	// merge the stderr of the spawned
	//   process with whatever the stdout happens to be.  This is a good way
	//   of directing both streams to a common log file, for example.
	GSubprocessFlagsStderrMergeValue SubprocessFlags = 64
	// spawned processes will inherit the
	//   file descriptors of their parent, unless those descriptors have
	//   been explicitly marked as close-on-exec.  This flag has no effect
	//   over the "standard" file descriptors (stdin, stdout, stderr).
	GSubprocessFlagsInheritFdsValue SubprocessFlags = 128
	// if path searching is
	//   needed when spawning the subprocess, use the `PATH` in the launcher
	//   environment. (Since: 2.72)
	GSubprocessFlagsSearchPathFromEnvpValue SubprocessFlags = 256
)

// Flags to define future #GTestDBus behaviour.
type TestDBusFlags int

var xTestDBusFlagsGLibType func() types.GType

func TestDBusFlagsGLibType() types.GType {
	return xTestDBusFlagsGLibType()
}

const (

	// No flags.
	GTestDbusNoneValue TestDBusFlags = 0
)

// A set of flags describing TLS certification validation. This can be
// used to describe why a particular certificate was rejected (for
// example, in #GTlsConnection::accept-certificate).
//
// GLib guarantees that if certificate verification fails, at least one
// flag will be set, but it does not guarantee that all possible flags
// will be set. Accordingly, you may not safely decide to ignore any
// particular type of error. For example, it would be incorrect to mask
// %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
// because this could potentially be the only error flag set even if
// other problems exist with the certificate.
type TlsCertificateFlags int

var xTlsCertificateFlagsGLibType func() types.GType

func TlsCertificateFlagsGLibType() types.GType {
	return xTlsCertificateFlagsGLibType()
}

const (

	// No flags set. Since: 2.74
	GTlsCertificateNoFlagsValue TlsCertificateFlags = 0
	// The signing certificate authority is
	//   not known.
	GTlsCertificateUnknownCaValue TlsCertificateFlags = 1
	// The certificate does not match the
	//   expected identity of the site that it was retrieved from.
	GTlsCertificateBadIdentityValue TlsCertificateFlags = 2
	// The certificate's activation time
	//   is still in the future
	GTlsCertificateNotActivatedValue TlsCertificateFlags = 4
	// The certificate has expired
	GTlsCertificateExpiredValue TlsCertificateFlags = 8
	// The certificate has been revoked
	//   according to the #GTlsConnection's certificate revocation list.
	GTlsCertificateRevokedValue TlsCertificateFlags = 16
	// The certificate's algorithm is
	//   considered insecure.
	GTlsCertificateInsecureValue TlsCertificateFlags = 32
	// Some other error occurred validating
	//   the certificate
	GTlsCertificateGenericErrorValue TlsCertificateFlags = 64
	// the combination of all of the above
	//   flags
	GTlsCertificateValidateAllValue TlsCertificateFlags = 127
)

// Flags for g_tls_database_verify_chain().
type TlsDatabaseVerifyFlags int

var xTlsDatabaseVerifyFlagsGLibType func() types.GType

func TlsDatabaseVerifyFlagsGLibType() types.GType {
	return xTlsDatabaseVerifyFlagsGLibType()
}

const (

	// No verification flags
	GTlsDatabaseVerifyNoneValue TlsDatabaseVerifyFlags = 0
)

// Various flags for the password.
type TlsPasswordFlags int

var xTlsPasswordFlagsGLibType func() types.GType

func TlsPasswordFlagsGLibType() types.GType {
	return xTlsPasswordFlagsGLibType()
}

const (

	// No flags
	GTlsPasswordNoneValue TlsPasswordFlags = 0
	// The password was wrong, and the user should retry.
	GTlsPasswordRetryValue TlsPasswordFlags = 2
	// Hint to the user that the password has been
	//    wrong many times, and the user may not have many chances left.
	GTlsPasswordManyTriesValue TlsPasswordFlags = 4
	// Hint to the user that this is the last try to get
	//    this password right.
	GTlsPasswordFinalTryValue TlsPasswordFlags = 8
	// For PKCS #11, the user PIN is required.
	//    Since: 2.70.
	GTlsPasswordPkcs11UserValue TlsPasswordFlags = 16
	// For PKCS #11, the security officer
	//    PIN is required. Since: 2.70.
	GTlsPasswordPkcs11SecurityOfficerValue TlsPasswordFlags = 32
	// For PKCS #11, the context-specific
	//    PIN is required. Since: 2.70.
	GTlsPasswordPkcs11ContextSpecificValue TlsPasswordFlags = 64
)

// An enumeration for well-known message buses.
type BusType int

var xBusTypeGLibType func() types.GType

func BusTypeGLibType() types.GType {
	return xBusTypeGLibType()
}

const (

	// An alias for the message bus that activated the process, if any.
	GBusTypeStarterValue BusType = -1
	// Not a message bus.
	GBusTypeNoneValue BusType = 0
	// The system-wide message bus.
	GBusTypeSystemValue BusType = 1
	// The login session message bus.
	GBusTypeSessionValue BusType = 2
)

// Results returned from g_converter_convert().
type ConverterResult int

var xConverterResultGLibType func() types.GType

func ConverterResultGLibType() types.GType {
	return xConverterResultGLibType()
}

const (

	// There was an error during conversion.
	GConverterErrorValue ConverterResult = 0
	// Some data was consumed or produced
	GConverterConvertedValue ConverterResult = 1
	// The conversion is finished
	GConverterFinishedValue ConverterResult = 2
	// Flushing is finished
	GConverterFlushedValue ConverterResult = 3
)

// Enumeration describing different kinds of native credential types.
type CredentialsType int

var xCredentialsTypeGLibType func() types.GType

func CredentialsTypeGLibType() types.GType {
	return xCredentialsTypeGLibType()
}

const (

	// Indicates an invalid native credential type.
	GCredentialsTypeInvalidValue CredentialsType = 0
	// The native credentials type is a `struct ucred`.
	GCredentialsTypeLinuxUcredValue CredentialsType = 1
	// The native credentials type is a `struct cmsgcred`.
	GCredentialsTypeFreebsdCmsgcredValue CredentialsType = 2
	// The native credentials type is a `struct sockpeercred`. Added in 2.30.
	GCredentialsTypeOpenbsdSockpeercredValue CredentialsType = 3
	// The native credentials type is a `ucred_t`. Added in 2.40.
	GCredentialsTypeSolarisUcredValue CredentialsType = 4
	// The native credentials type is a `struct unpcbid`. Added in 2.42.
	GCredentialsTypeNetbsdUnpcbidValue CredentialsType = 5
	// The native credentials type is a `struct xucred`. Added in 2.66.
	GCredentialsTypeAppleXucredValue CredentialsType = 6
	// The native credentials type is a PID `DWORD`. Added in 2.72.
	GCredentialsTypeWin32PidValue CredentialsType = 7
)

// Error codes for the %G_DBUS_ERROR error domain.
type DBusError int

var xDBusErrorGLibType func() types.GType

func DBusErrorGLibType() types.GType {
	return xDBusErrorGLibType()
}

const (

	// A generic error; "something went wrong" - see the error message for
	// more.
	GDbusErrorFailedValue DBusError = 0
	// There was not enough memory to complete an operation.
	GDbusErrorNoMemoryValue DBusError = 1
	// The bus doesn't know how to launch a service to supply the bus name
	// you wanted.
	GDbusErrorServiceUnknownValue DBusError = 2
	// The bus name you referenced doesn't exist (i.e. no application owns
	// it).
	GDbusErrorNameHasNoOwnerValue DBusError = 3
	// No reply to a message expecting one, usually means a timeout occurred.
	GDbusErrorNoReplyValue DBusError = 4
	// Something went wrong reading or writing to a socket, for example.
	GDbusErrorIoErrorValue DBusError = 5
	// A D-Bus bus address was malformed.
	GDbusErrorBadAddressValue DBusError = 6
	// Requested operation isn't supported (like ENOSYS on UNIX).
	GDbusErrorNotSupportedValue DBusError = 7
	// Some limited resource is exhausted.
	GDbusErrorLimitsExceededValue DBusError = 8
	// Security restrictions don't allow doing what you're trying to do.
	GDbusErrorAccessDeniedValue DBusError = 9
	// Authentication didn't work.
	GDbusErrorAuthFailedValue DBusError = 10
	// Unable to connect to server (probably caused by ECONNREFUSED on a
	// socket).
	GDbusErrorNoServerValue DBusError = 11
	// Certain timeout errors, possibly ETIMEDOUT on a socket.  Note that
	// %G_DBUS_ERROR_NO_REPLY is used for message reply timeouts. Warning:
	// this is confusingly-named given that %G_DBUS_ERROR_TIMED_OUT also
	// exists. We can't fix it for compatibility reasons so just be
	// careful.
	GDbusErrorTimeoutValue DBusError = 12
	// No network access (probably ENETUNREACH on a socket).
	GDbusErrorNoNetworkValue DBusError = 13
	// Can't bind a socket since its address is in use (i.e. EADDRINUSE).
	GDbusErrorAddressInUseValue DBusError = 14
	// The connection is disconnected and you're trying to use it.
	GDbusErrorDisconnectedValue DBusError = 15
	// Invalid arguments passed to a method call.
	GDbusErrorInvalidArgsValue DBusError = 16
	// Missing file.
	GDbusErrorFileNotFoundValue DBusError = 17
	// Existing file and the operation you're using does not silently overwrite.
	GDbusErrorFileExistsValue DBusError = 18
	// Method name you invoked isn't known by the object you invoked it on.
	GDbusErrorUnknownMethodValue DBusError = 19
	// Certain timeout errors, e.g. while starting a service. Warning: this is
	// confusingly-named given that %G_DBUS_ERROR_TIMEOUT also exists. We
	// can't fix it for compatibility reasons so just be careful.
	GDbusErrorTimedOutValue DBusError = 20
	// Tried to remove or modify a match rule that didn't exist.
	GDbusErrorMatchRuleNotFoundValue DBusError = 21
	// The match rule isn't syntactically valid.
	GDbusErrorMatchRuleInvalidValue DBusError = 22
	// While starting a new process, the exec() call failed.
	GDbusErrorSpawnExecFailedValue DBusError = 23
	// While starting a new process, the fork() call failed.
	GDbusErrorSpawnForkFailedValue DBusError = 24
	// While starting a new process, the child exited with a status code.
	GDbusErrorSpawnChildExitedValue DBusError = 25
	// While starting a new process, the child exited on a signal.
	GDbusErrorSpawnChildSignaledValue DBusError = 26
	// While starting a new process, something went wrong.
	GDbusErrorSpawnFailedValue DBusError = 27
	// We failed to setup the environment correctly.
	GDbusErrorSpawnSetupFailedValue DBusError = 28
	// We failed to setup the config parser correctly.
	GDbusErrorSpawnConfigInvalidValue DBusError = 29
	// Bus name was not valid.
	GDbusErrorSpawnServiceInvalidValue DBusError = 30
	// Service file not found in system-services directory.
	GDbusErrorSpawnServiceNotFoundValue DBusError = 31
	// Permissions are incorrect on the setuid helper.
	GDbusErrorSpawnPermissionsInvalidValue DBusError = 32
	// Service file invalid (Name, User or Exec missing).
	GDbusErrorSpawnFileInvalidValue DBusError = 33
	// Tried to get a UNIX process ID and it wasn't available.
	GDbusErrorSpawnNoMemoryValue DBusError = 34
	// Tried to get a UNIX process ID and it wasn't available.
	GDbusErrorUnixProcessIdUnknownValue DBusError = 35
	// A type signature is not valid.
	GDbusErrorInvalidSignatureValue DBusError = 36
	// A file contains invalid syntax or is otherwise broken.
	GDbusErrorInvalidFileContentValue DBusError = 37
	// Asked for SELinux security context and it wasn't available.
	GDbusErrorSelinuxSecurityContextUnknownValue DBusError = 38
	// Asked for ADT audit data and it wasn't available.
	GDbusErrorAdtAuditDataUnknownValue DBusError = 39
	// There's already an object with the requested object path.
	GDbusErrorObjectPathInUseValue DBusError = 40
	// Object you invoked a method on isn't known. Since 2.42
	GDbusErrorUnknownObjectValue DBusError = 41
	// Interface you invoked a method on isn't known by the object. Since 2.42
	GDbusErrorUnknownInterfaceValue DBusError = 42
	// Property you tried to access isn't known by the object. Since 2.42
	GDbusErrorUnknownPropertyValue DBusError = 43
	// Property you tried to set is read-only. Since 2.42
	GDbusErrorPropertyReadOnlyValue DBusError = 44
)

// Enumeration used to describe the byte order of a D-Bus message.
type DBusMessageByteOrder int

var xDBusMessageByteOrderGLibType func() types.GType

func DBusMessageByteOrderGLibType() types.GType {
	return xDBusMessageByteOrderGLibType()
}

const (

	// The byte order is big endian.
	GDbusMessageByteOrderBigEndianValue DBusMessageByteOrder = 66
	// The byte order is little endian.
	GDbusMessageByteOrderLittleEndianValue DBusMessageByteOrder = 108
)

// Header fields used in #GDBusMessage.
type DBusMessageHeaderField int

var xDBusMessageHeaderFieldGLibType func() types.GType

func DBusMessageHeaderFieldGLibType() types.GType {
	return xDBusMessageHeaderFieldGLibType()
}

const (

	// Not a valid header field.
	GDbusMessageHeaderFieldInvalidValue DBusMessageHeaderField = 0
	// The object path.
	GDbusMessageHeaderFieldPathValue DBusMessageHeaderField = 1
	// The interface name.
	GDbusMessageHeaderFieldInterfaceValue DBusMessageHeaderField = 2
	// The method or signal name.
	GDbusMessageHeaderFieldMemberValue DBusMessageHeaderField = 3
	// The name of the error that occurred.
	GDbusMessageHeaderFieldErrorNameValue DBusMessageHeaderField = 4
	// The serial number the message is a reply to.
	GDbusMessageHeaderFieldReplySerialValue DBusMessageHeaderField = 5
	// The name the message is intended for.
	GDbusMessageHeaderFieldDestinationValue DBusMessageHeaderField = 6
	// Unique name of the sender of the message (filled in by the bus).
	GDbusMessageHeaderFieldSenderValue DBusMessageHeaderField = 7
	// The signature of the message body.
	GDbusMessageHeaderFieldSignatureValue DBusMessageHeaderField = 8
	// The number of UNIX file descriptors that accompany the message.
	GDbusMessageHeaderFieldNumUnixFdsValue DBusMessageHeaderField = 9
)

// Message types used in #GDBusMessage.
type DBusMessageType int

var xDBusMessageTypeGLibType func() types.GType

func DBusMessageTypeGLibType() types.GType {
	return xDBusMessageTypeGLibType()
}

const (

	// Message is of invalid type.
	GDbusMessageTypeInvalidValue DBusMessageType = 0
	// Method call.
	GDbusMessageTypeMethodCallValue DBusMessageType = 1
	// Method reply.
	GDbusMessageTypeMethodReturnValue DBusMessageType = 2
	// Error reply.
	GDbusMessageTypeErrorValue DBusMessageType = 3
	// Signal emission.
	GDbusMessageTypeSignalValue DBusMessageType = 4
)

// #GDataStreamByteOrder is used to ensure proper endianness of streaming data sources
// across various machine architectures.
type DataStreamByteOrder int

var xDataStreamByteOrderGLibType func() types.GType

func DataStreamByteOrderGLibType() types.GType {
	return xDataStreamByteOrderGLibType()
}

const (

	// Selects Big Endian byte order.
	GDataStreamByteOrderBigEndianValue DataStreamByteOrder = 0
	// Selects Little Endian byte order.
	GDataStreamByteOrderLittleEndianValue DataStreamByteOrder = 1
	// Selects endianness based on host machine's architecture.
	GDataStreamByteOrderHostEndianValue DataStreamByteOrder = 2
)

// #GDataStreamNewlineType is used when checking for or setting the line endings for a given file.
type DataStreamNewlineType int

var xDataStreamNewlineTypeGLibType func() types.GType

func DataStreamNewlineTypeGLibType() types.GType {
	return xDataStreamNewlineTypeGLibType()
}

const (

	// Selects "LF" line endings, common on most modern UNIX platforms.
	GDataStreamNewlineTypeLfValue DataStreamNewlineType = 0
	// Selects "CR" line endings.
	GDataStreamNewlineTypeCrValue DataStreamNewlineType = 1
	// Selects "CR, LF" line ending, common on Microsoft Windows.
	GDataStreamNewlineTypeCrLfValue DataStreamNewlineType = 2
	// Automatically try to handle any line ending type.
	GDataStreamNewlineTypeAnyValue DataStreamNewlineType = 3
)

// Enumeration describing how a drive can be started/stopped.
type DriveStartStopType int

var xDriveStartStopTypeGLibType func() types.GType

func DriveStartStopTypeGLibType() types.GType {
	return xDriveStartStopTypeGLibType()
}

const (

	// Unknown or drive doesn't support
	//    start/stop.
	GDriveStartStopTypeUnknownValue DriveStartStopType = 0
	// The stop method will physically
	//    shut down the drive and e.g. power down the port the drive is
	//    attached to.
	GDriveStartStopTypeShutdownValue DriveStartStopType = 1
	// The start/stop methods are used
	//    for connecting/disconnect to the drive over the network.
	GDriveStartStopTypeNetworkValue DriveStartStopType = 2
	// The start/stop methods will
	//    assemble/disassemble a virtual drive from several physical
	//    drives.
	GDriveStartStopTypeMultidiskValue DriveStartStopType = 3
	// The start/stop methods will
	//    unlock/lock the disk (for example using the ATA `SECURITY UNLOCK
	//    DEVICE` command)
	GDriveStartStopTypePasswordValue DriveStartStopType = 4
)

// GEmblemOrigin is used to add information about the origin of the emblem
// to #GEmblem.
type EmblemOrigin int

var xEmblemOriginGLibType func() types.GType

func EmblemOriginGLibType() types.GType {
	return xEmblemOriginGLibType()
}

const (

	// Emblem of unknown origin
	GEmblemOriginUnknownValue EmblemOrigin = 0
	// Emblem adds device-specific information
	GEmblemOriginDeviceValue EmblemOrigin = 1
	// Emblem depicts live metadata, such as "readonly"
	GEmblemOriginLivemetadataValue EmblemOrigin = 2
	// Emblem comes from a user-defined tag, e.g. set by nautilus (in the future)
	GEmblemOriginTagValue EmblemOrigin = 3
)

// Used by g_file_set_attributes_from_info() when setting file attributes.
type FileAttributeStatus int

var xFileAttributeStatusGLibType func() types.GType

func FileAttributeStatusGLibType() types.GType {
	return xFileAttributeStatusGLibType()
}

const (

	// Attribute value is unset (empty).
	GFileAttributeStatusUnsetValue FileAttributeStatus = 0
	// Attribute value is set.
	GFileAttributeStatusSetValue FileAttributeStatus = 1
	// Indicates an error in setting the value.
	GFileAttributeStatusErrorSettingValue FileAttributeStatus = 2
)

// The data types for file attributes.
type FileAttributeType int

var xFileAttributeTypeGLibType func() types.GType

func FileAttributeTypeGLibType() types.GType {
	return xFileAttributeTypeGLibType()
}

const (

	// indicates an invalid or uninitialized type.
	GFileAttributeTypeInvalidValue FileAttributeType = 0
	// a null terminated UTF8 string.
	GFileAttributeTypeStringValue FileAttributeType = 1
	// a zero terminated string of non-zero bytes.
	GFileAttributeTypeByteStringValue FileAttributeType = 2
	// a boolean value.
	GFileAttributeTypeBooleanValue FileAttributeType = 3
	// an unsigned 4-byte/32-bit integer.
	GFileAttributeTypeUint32Value FileAttributeType = 4
	// a signed 4-byte/32-bit integer.
	GFileAttributeTypeInt32Value FileAttributeType = 5
	// an unsigned 8-byte/64-bit integer.
	GFileAttributeTypeUint64Value FileAttributeType = 6
	// a signed 8-byte/64-bit integer.
	GFileAttributeTypeInt64Value FileAttributeType = 7
	// a #GObject.
	GFileAttributeTypeObjectValue FileAttributeType = 8
	// a %NULL terminated char **. Since 2.22
	GFileAttributeTypeStringvValue FileAttributeType = 9
)

// Specifies what type of event a monitor event is.
type FileMonitorEvent int

var xFileMonitorEventGLibType func() types.GType

func FileMonitorEventGLibType() types.GType {
	return xFileMonitorEventGLibType()
}

const (

	// a file changed.
	GFileMonitorEventChangedValue FileMonitorEvent = 0
	// a hint that this was probably the last change in a set of changes.
	GFileMonitorEventChangesDoneHintValue FileMonitorEvent = 1
	// a file was deleted.
	GFileMonitorEventDeletedValue FileMonitorEvent = 2
	// a file was created.
	GFileMonitorEventCreatedValue FileMonitorEvent = 3
	// a file attribute was changed.
	GFileMonitorEventAttributeChangedValue FileMonitorEvent = 4
	// the file location will soon be unmounted.
	GFileMonitorEventPreUnmountValue FileMonitorEvent = 5
	// the file location was unmounted.
	GFileMonitorEventUnmountedValue FileMonitorEvent = 6
	// the file was moved -- only sent if the
	//   (deprecated) %G_FILE_MONITOR_SEND_MOVED flag is set
	GFileMonitorEventMovedValue FileMonitorEvent = 7
	// the file was renamed within the
	//   current directory -- only sent if the %G_FILE_MONITOR_WATCH_MOVES
	//   flag is set.  Since: 2.46.
	GFileMonitorEventRenamedValue FileMonitorEvent = 8
	// the file was moved into the
	//   monitored directory from another location -- only sent if the
	//   %G_FILE_MONITOR_WATCH_MOVES flag is set.  Since: 2.46.
	GFileMonitorEventMovedInValue FileMonitorEvent = 9
	// the file was moved out of the
	//   monitored directory to another location -- only sent if the
	//   %G_FILE_MONITOR_WATCH_MOVES flag is set.  Since: 2.46
	GFileMonitorEventMovedOutValue FileMonitorEvent = 10
)

// Indicates the file's on-disk type.
//
// On Windows systems a file will never have %G_FILE_TYPE_SYMBOLIC_LINK type;
// use #GFileInfo and %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK to determine
// whether a file is a symlink or not. This is due to the fact that NTFS does
// not have a single filesystem object type for symbolic links - it has
// files that symlink to files, and directories that symlink to directories.
// #GFileType enumeration cannot precisely represent this important distinction,
// which is why all Windows symlinks will continue to be reported as
// %G_FILE_TYPE_REGULAR or %G_FILE_TYPE_DIRECTORY.
type FileType int

var xFileTypeGLibType func() types.GType

func FileTypeGLibType() types.GType {
	return xFileTypeGLibType()
}

const (

	// File's type is unknown.
	GFileTypeUnknownValue FileType = 0
	// File handle represents a regular file.
	GFileTypeRegularValue FileType = 1
	// File handle represents a directory.
	GFileTypeDirectoryValue FileType = 2
	// File handle represents a symbolic link
	//    (Unix systems).
	GFileTypeSymbolicLinkValue FileType = 3
	// File is a "special" file, such as a socket, fifo,
	//    block device, or character device.
	GFileTypeSpecialValue FileType = 4
	// File is a shortcut (Windows systems).
	GFileTypeShortcutValue FileType = 5
	// File is a mountable location.
	GFileTypeMountableValue FileType = 6
)

// Indicates a hint from the file system whether files should be
// previewed in a file manager. Returned as the value of the key
// %G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW.
type FilesystemPreviewType int

var xFilesystemPreviewTypeGLibType func() types.GType

func FilesystemPreviewTypeGLibType() types.GType {
	return xFilesystemPreviewTypeGLibType()
}

const (

	// Only preview files if user has explicitly requested it.
	GFilesystemPreviewTypeIfAlwaysValue FilesystemPreviewType = 0
	// Preview files if user has requested preview of "local" files.
	GFilesystemPreviewTypeIfLocalValue FilesystemPreviewType = 1
	// Never preview files.
	GFilesystemPreviewTypeNeverValue FilesystemPreviewType = 2
)

// Error codes returned by GIO functions.
//
// Note that this domain may be extended in future GLib releases. In
// general, new error codes either only apply to new APIs, or else
// replace %G_IO_ERROR_FAILED in cases that were not explicitly
// distinguished before. You should therefore avoid writing code like
// |[<!-- language="C" -->
// if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED))
//
//	{
//	  // Assume that this is EPRINTERONFIRE
//	  ...
//	}
//
// ]|
// but should instead treat all unrecognized error codes the same as
// %G_IO_ERROR_FAILED.
//
// See also #GPollableReturn for a cheaper way of returning
// %G_IO_ERROR_WOULD_BLOCK to callers without allocating a #GError.
type IOErrorEnum int

var xIOErrorEnumGLibType func() types.GType

func IOErrorEnumGLibType() types.GType {
	return xIOErrorEnumGLibType()
}

const (

	// Generic error condition for when an operation fails
	//     and no more specific #GIOErrorEnum value is defined.
	GIoErrorFailedValue IOErrorEnum = 0
	// File not found.
	GIoErrorNotFoundValue IOErrorEnum = 1
	// File already exists.
	GIoErrorExistsValue IOErrorEnum = 2
	// File is a directory.
	GIoErrorIsDirectoryValue IOErrorEnum = 3
	// File is not a directory.
	GIoErrorNotDirectoryValue IOErrorEnum = 4
	// File is a directory that isn't empty.
	GIoErrorNotEmptyValue IOErrorEnum = 5
	// File is not a regular file.
	GIoErrorNotRegularFileValue IOErrorEnum = 6
	// File is not a symbolic link.
	GIoErrorNotSymbolicLinkValue IOErrorEnum = 7
	// File cannot be mounted.
	GIoErrorNotMountableFileValue IOErrorEnum = 8
	// Filename is too many characters.
	GIoErrorFilenameTooLongValue IOErrorEnum = 9
	// Filename is invalid or contains invalid characters.
	GIoErrorInvalidFilenameValue IOErrorEnum = 10
	// File contains too many symbolic links.
	GIoErrorTooManyLinksValue IOErrorEnum = 11
	// No space left on drive.
	GIoErrorNoSpaceValue IOErrorEnum = 12
	// Invalid argument.
	GIoErrorInvalidArgumentValue IOErrorEnum = 13
	// Permission denied.
	GIoErrorPermissionDeniedValue IOErrorEnum = 14
	// Operation (or one of its parameters) not supported
	GIoErrorNotSupportedValue IOErrorEnum = 15
	// File isn't mounted.
	GIoErrorNotMountedValue IOErrorEnum = 16
	// File is already mounted.
	GIoErrorAlreadyMountedValue IOErrorEnum = 17
	// File was closed.
	GIoErrorClosedValue IOErrorEnum = 18
	// Operation was cancelled. See #GCancellable.
	GIoErrorCancelledValue IOErrorEnum = 19
	// Operations are still pending.
	GIoErrorPendingValue IOErrorEnum = 20
	// File is read only.
	GIoErrorReadOnlyValue IOErrorEnum = 21
	// Backup couldn't be created.
	GIoErrorCantCreateBackupValue IOErrorEnum = 22
	// File's Entity Tag was incorrect.
	GIoErrorWrongEtagValue IOErrorEnum = 23
	// Operation timed out.
	GIoErrorTimedOutValue IOErrorEnum = 24
	// Operation would be recursive.
	GIoErrorWouldRecurseValue IOErrorEnum = 25
	// File is busy.
	GIoErrorBusyValue IOErrorEnum = 26
	// Operation would block.
	GIoErrorWouldBlockValue IOErrorEnum = 27
	// Host couldn't be found (remote operations).
	GIoErrorHostNotFoundValue IOErrorEnum = 28
	// Operation would merge files.
	GIoErrorWouldMergeValue IOErrorEnum = 29
	// Operation failed and a helper program has
	//     already interacted with the user. Do not display any error dialog.
	GIoErrorFailedHandledValue IOErrorEnum = 30
	// The current process has too many files
	//     open and can't open any more. Duplicate descriptors do count toward
	//     this limit. Since 2.20
	GIoErrorTooManyOpenFilesValue IOErrorEnum = 31
	// The object has not been initialized. Since 2.22
	GIoErrorNotInitializedValue IOErrorEnum = 32
	// The requested address is already in use. Since 2.22
	GIoErrorAddressInUseValue IOErrorEnum = 33
	// Need more input to finish operation. Since 2.24
	GIoErrorPartialInputValue IOErrorEnum = 34
	// The input data was invalid. Since 2.24
	GIoErrorInvalidDataValue IOErrorEnum = 35
	// A remote object generated an error that
	//     doesn't correspond to a locally registered #GError error
	//     domain. Use g_dbus_error_get_remote_error() to extract the D-Bus
	//     error name and g_dbus_error_strip_remote_error() to fix up the
	//     message so it matches what was received on the wire. Since 2.26.
	GIoErrorDbusErrorValue IOErrorEnum = 36
	// Host unreachable. Since 2.26
	GIoErrorHostUnreachableValue IOErrorEnum = 37
	// Network unreachable. Since 2.26
	GIoErrorNetworkUnreachableValue IOErrorEnum = 38
	// Connection refused. Since 2.26
	GIoErrorConnectionRefusedValue IOErrorEnum = 39
	// Connection to proxy server failed. Since 2.26
	GIoErrorProxyFailedValue IOErrorEnum = 40
	// Proxy authentication failed. Since 2.26
	GIoErrorProxyAuthFailedValue IOErrorEnum = 41
	// Proxy server needs authentication. Since 2.26
	GIoErrorProxyNeedAuthValue IOErrorEnum = 42
	// Proxy connection is not allowed by ruleset.
	//     Since 2.26
	GIoErrorProxyNotAllowedValue IOErrorEnum = 43
	// Broken pipe. Since 2.36
	GIoErrorBrokenPipeValue IOErrorEnum = 44
	// Connection closed by peer. Note that this
	//     is the same code as %G_IO_ERROR_BROKEN_PIPE; before 2.44 some
	//     "connection closed" errors returned %G_IO_ERROR_BROKEN_PIPE, but others
	//     returned %G_IO_ERROR_FAILED. Now they should all return the same
	//     value, which has this more logical name. Since 2.44.
	GIoErrorConnectionClosedValue IOErrorEnum = 44
	// Transport endpoint is not connected. Since 2.44
	GIoErrorNotConnectedValue IOErrorEnum = 45
	// Message too large. Since 2.48.
	GIoErrorMessageTooLargeValue IOErrorEnum = 46
	// No such device found. Since 2.74
	GIoErrorNoSuchDeviceValue IOErrorEnum = 47
	// Destination address unset. Since 2.80
	GIoErrorDestinationUnsetValue IOErrorEnum = 48
)

// Flags for use with g_io_module_scope_new().
type IOModuleScopeFlags int

var xIOModuleScopeFlagsGLibType func() types.GType

func IOModuleScopeFlagsGLibType() types.GType {
	return xIOModuleScopeFlagsGLibType()
}

const (

	// No module scan flags
	GIoModuleScopeNoneValue IOModuleScopeFlags = 0
	// When using this scope to load or
	//     scan modules, automatically block a modules which has the same base
	//     basename as previously loaded module.
	GIoModuleScopeBlockDuplicatesValue IOModuleScopeFlags = 1
)

// Memory availability warning levels.
//
// Note that because new values might be added, it is recommended that applications check
// #GMemoryMonitorWarningLevel as ranges, for example:
// |[<!-- language="C" -->
// if (warning_level > G_MEMORY_MONITOR_WARNING_LEVEL_LOW)
//
//	drop_caches ();
//
// ]|
type MemoryMonitorWarningLevel int

var xMemoryMonitorWarningLevelGLibType func() types.GType

func MemoryMonitorWarningLevelGLibType() types.GType {
	return xMemoryMonitorWarningLevelGLibType()
}

const (

	// Memory on the device is low, processes
	//   should free up unneeded resources (for example, in-memory caches) so they can
	//   be used elsewhere.
	GMemoryMonitorWarningLevelLowValue MemoryMonitorWarningLevel = 50
	// Same as @G_MEMORY_MONITOR_WARNING_LEVEL_LOW
	//   but the device has even less free memory, so processes should try harder to free
	//   up unneeded resources. If your process does not need to stay running, it is a
	//   good time for it to quit.
	GMemoryMonitorWarningLevelMediumValue MemoryMonitorWarningLevel = 100
	// The system will soon start terminating
	//   processes to reclaim memory, including background processes.
	GMemoryMonitorWarningLevelCriticalValue MemoryMonitorWarningLevel = 255
)

// #GMountOperationResult is returned as a result when a request for
// information is send by the mounting operation.
type MountOperationResult int

var xMountOperationResultGLibType func() types.GType

func MountOperationResultGLibType() types.GType {
	return xMountOperationResultGLibType()
}

const (

	// The request was fulfilled and the
	//     user specified data is now available
	GMountOperationHandledValue MountOperationResult = 0
	// The user requested the mount operation
	//     to be aborted
	GMountOperationAbortedValue MountOperationResult = 1
	// The request was unhandled (i.e. not
	//     implemented)
	GMountOperationUnhandledValue MountOperationResult = 2
)

// The host's network connectivity state, as reported by #GNetworkMonitor.
type NetworkConnectivity int

var xNetworkConnectivityGLibType func() types.GType

func NetworkConnectivityGLibType() types.GType {
	return xNetworkConnectivityGLibType()
}

const (

	// The host is not configured with a
	//   route to the Internet; it may or may not be connected to a local
	//   network.
	GNetworkConnectivityLocalValue NetworkConnectivity = 1
	// The host is connected to a network, but
	//   does not appear to be able to reach the full Internet, perhaps
	//   due to upstream network problems.
	GNetworkConnectivityLimitedValue NetworkConnectivity = 2
	// The host is behind a captive portal and
	//   cannot reach the full Internet.
	GNetworkConnectivityPortalValue NetworkConnectivity = 3
	// The host is connected to a network, and
	//   appears to be able to reach the full Internet.
	GNetworkConnectivityFullValue NetworkConnectivity = 4
)

// Priority levels for #GNotifications.
type NotificationPriority int

var xNotificationPriorityGLibType func() types.GType

func NotificationPriorityGLibType() types.GType {
	return xNotificationPriorityGLibType()
}

const (

	// the default priority, to be used for the
	//   majority of notifications (for example email messages, software updates,
	//   completed download/sync operations)
	GNotificationPriorityNormalValue NotificationPriority = 0
	// for notifications that do not require
	//   immediate attention - typically used for contextual background
	//   information, such as contact birthdays or local weather
	GNotificationPriorityLowValue NotificationPriority = 1
	// for events that require more attention,
	//   usually because responses are time-sensitive (for example chat and SMS
	//   messages or alarms)
	GNotificationPriorityHighValue NotificationPriority = 2
	// for urgent notifications, or notifications
	//   that require a response in a short space of time (for example phone calls
	//   or emergency warnings)
	GNotificationPriorityUrgentValue NotificationPriority = 3
)

// #GPasswordSave is used to indicate the lifespan of a saved password.
//
// #Gvfs stores passwords in the Gnome keyring when this flag allows it
// to, and later retrieves it again from there.
type PasswordSave int

var xPasswordSaveGLibType func() types.GType

func PasswordSaveGLibType() types.GType {
	return xPasswordSaveGLibType()
}

const (

	// never save a password.
	GPasswordSaveNeverValue PasswordSave = 0
	// save a password for the session.
	GPasswordSaveForSessionValue PasswordSave = 1
	// save a password permanently.
	GPasswordSavePermanentlyValue PasswordSave = 2
)

// Return value for various IO operations that signal errors via the
// return value and not necessarily via a #GError.
//
// This enum exists to be able to return errors to callers without having to
// allocate a #GError. Allocating #GErrors can be quite expensive for
// regularly happening errors like %G_IO_ERROR_WOULD_BLOCK.
//
// In case of %G_POLLABLE_RETURN_FAILED a #GError should be set for the
// operation to give details about the error that happened.
type PollableReturn int

var xPollableReturnGLibType func() types.GType

func PollableReturnGLibType() types.GType {
	return xPollableReturnGLibType()
}

const (

	// Generic error condition for when an operation fails.
	GPollableReturnFailedValue PollableReturn = 0
	// The operation was successfully finished.
	GPollableReturnOkValue PollableReturn = 1
	// The operation would block.
	GPollableReturnWouldBlockValue PollableReturn = -27
)

// An error code used with %G_RESOLVER_ERROR in a #GError returned
// from a #GResolver routine.
type ResolverError int

var xResolverErrorGLibType func() types.GType

func ResolverErrorGLibType() types.GType {
	return xResolverErrorGLibType()
}

const (

	// the requested name/address/service was not
	//     found
	GResolverErrorNotFoundValue ResolverError = 0
	// the requested information could not
	//     be looked up due to a network error or similar problem
	GResolverErrorTemporaryFailureValue ResolverError = 1
	// unknown error
	GResolverErrorInternalValue ResolverError = 2
)

// The type of record that g_resolver_lookup_records() or
// g_resolver_lookup_records_async() should retrieve. The records are returned
// as lists of #GVariant tuples. Each record type has different values in
// the variant tuples returned.
//
// %G_RESOLVER_RECORD_SRV records are returned as variants with the signature
// `(qqqs)`, containing a `guint16` with the priority, a `guint16` with the
// weight, a `guint16` with the port, and a string of the hostname.
//
// %G_RESOLVER_RECORD_MX records are returned as variants with the signature
// `(qs)`, representing a `guint16` with the preference, and a string containing
// the mail exchanger hostname.
//
// %G_RESOLVER_RECORD_TXT records are returned as variants with the signature
// `(as)`, representing an array of the strings in the text record. Note: Most TXT
// records only contain a single string, but
// [RFC 1035](https://tools.ietf.org/html/rfc1035#section-3.3.14) does allow a
// record to contain multiple strings. The RFC which defines the interpretation
// of a specific TXT record will likely require concatenation of multiple
// strings if they are present, as with
// [RFC 7208](https://tools.ietf.org/html/rfc7208#section-3.3).
//
// %G_RESOLVER_RECORD_SOA records are returned as variants with the signature
// `(ssuuuuu)`, representing a string containing the primary name server, a
// string containing the administrator, the serial as a `guint32`, the refresh
// interval as a `guint32`, the retry interval as a `guint32`, the expire timeout
// as a `guint32`, and the TTL as a `guint32`.
//
// %G_RESOLVER_RECORD_NS records are returned as variants with the signature
// `(s)`, representing a string of the hostname of the name server.
type ResolverRecordType int

var xResolverRecordTypeGLibType func() types.GType

func ResolverRecordTypeGLibType() types.GType {
	return xResolverRecordTypeGLibType()
}

const (

	// look up DNS SRV records for a domain
	GResolverRecordSrvValue ResolverRecordType = 1
	// look up DNS MX records for a domain
	GResolverRecordMxValue ResolverRecordType = 2
	// look up DNS TXT records for a name
	GResolverRecordTxtValue ResolverRecordType = 3
	// look up DNS SOA records for a zone
	GResolverRecordSoaValue ResolverRecordType = 4
	// look up DNS NS records for a domain
	GResolverRecordNsValue ResolverRecordType = 5
)

// An error code used with %G_RESOURCE_ERROR in a #GError returned
// from a #GResource routine.
type ResourceError int

var xResourceErrorGLibType func() types.GType

func ResourceErrorGLibType() types.GType {
	return xResourceErrorGLibType()
}

const (

	// no file was found at the requested path
	GResourceErrorNotFoundValue ResourceError = 0
	// unknown error
	GResourceErrorInternalValue ResourceError = 1
)

// Describes an event occurring on a #GSocketClient. See the
// #GSocketClient::event signal for more details.
//
// Additional values may be added to this type in the future.
type SocketClientEvent int

var xSocketClientEventGLibType func() types.GType

func SocketClientEventGLibType() types.GType {
	return xSocketClientEventGLibType()
}

const (

	// The client is doing a DNS lookup.
	GSocketClientResolvingValue SocketClientEvent = 0
	// The client has completed a DNS lookup.
	GSocketClientResolvedValue SocketClientEvent = 1
	// The client is connecting to a remote
	//   host (either a proxy or the destination server).
	GSocketClientConnectingValue SocketClientEvent = 2
	// The client has connected to a remote
	//   host.
	GSocketClientConnectedValue SocketClientEvent = 3
	// The client is negotiating
	//   with a proxy to connect to the destination server.
	GSocketClientProxyNegotiatingValue SocketClientEvent = 4
	// The client has negotiated
	//   with the proxy server.
	GSocketClientProxyNegotiatedValue SocketClientEvent = 5
	// The client is performing a
	//   TLS handshake.
	GSocketClientTlsHandshakingValue SocketClientEvent = 6
	// The client has performed a
	//   TLS handshake.
	GSocketClientTlsHandshakedValue SocketClientEvent = 7
	// The client is done with a particular
	//   #GSocketConnectable.
	GSocketClientCompleteValue SocketClientEvent = 8
)

// The protocol family of a #GSocketAddress. (These values are
// identical to the system defines %AF_INET, %AF_INET6 and %AF_UNIX,
// if available.)
type SocketFamily int

var xSocketFamilyGLibType func() types.GType

func SocketFamilyGLibType() types.GType {
	return xSocketFamilyGLibType()
}

const (

	// no address family
	GSocketFamilyInvalidValue SocketFamily = 0
	// the UNIX domain family
	GSocketFamilyUnixValue SocketFamily = 1
	// the IPv4 family
	GSocketFamilyIpv4Value SocketFamily = 2
	// the IPv6 family
	GSocketFamilyIpv6Value SocketFamily = 10
)

// Describes an event occurring on a #GSocketListener. See the
// #GSocketListener::event signal for more details.
//
// Additional values may be added to this type in the future.
type SocketListenerEvent int

var xSocketListenerEventGLibType func() types.GType

func SocketListenerEventGLibType() types.GType {
	return xSocketListenerEventGLibType()
}

const (

	// The listener is about to bind a socket.
	GSocketListenerBindingValue SocketListenerEvent = 0
	// The listener has bound a socket.
	GSocketListenerBoundValue SocketListenerEvent = 1
	// The listener is about to start
	//    listening on this socket.
	GSocketListenerListeningValue SocketListenerEvent = 2
	// The listener is now listening on
	//   this socket.
	GSocketListenerListenedValue SocketListenerEvent = 3
)

// A protocol identifier is specified when creating a #GSocket, which is a
// family/type specific identifier, where 0 means the default protocol for
// the particular family/type.
//
// This enum contains a set of commonly available and used protocols. You
// can also pass any other identifiers handled by the platform in order to
// use protocols not listed here.
type SocketProtocol int

var xSocketProtocolGLibType func() types.GType

func SocketProtocolGLibType() types.GType {
	return xSocketProtocolGLibType()
}

const (

	// The protocol type is unknown
	GSocketProtocolUnknownValue SocketProtocol = -1
	// The default protocol for the family/type
	GSocketProtocolDefaultValue SocketProtocol = 0
	// TCP over IP
	GSocketProtocolTcpValue SocketProtocol = 6
	// UDP over IP
	GSocketProtocolUdpValue SocketProtocol = 17
	// SCTP over IP
	GSocketProtocolSctpValue SocketProtocol = 132
)

// Flags used when creating a #GSocket. Some protocols may not implement
// all the socket types.
type SocketType int

var xSocketTypeGLibType func() types.GType

func SocketTypeGLibType() types.GType {
	return xSocketTypeGLibType()
}

const (

	// Type unknown or wrong
	GSocketTypeInvalidValue SocketType = 0
	// Reliable connection-based byte streams (e.g. TCP).
	GSocketTypeStreamValue SocketType = 1
	// Connectionless, unreliable datagram passing.
	//     (e.g. UDP)
	GSocketTypeDatagramValue SocketType = 2
	// Reliable connection-based passing of datagrams
	//     of fixed maximum length (e.g. SCTP).
	GSocketTypeSeqpacketValue SocketType = 3
)

// The client authentication mode for a #GTlsServerConnection.
type TlsAuthenticationMode int

var xTlsAuthenticationModeGLibType func() types.GType

func TlsAuthenticationModeGLibType() types.GType {
	return xTlsAuthenticationModeGLibType()
}

const (

	// client authentication not required
	GTlsAuthenticationNoneValue TlsAuthenticationMode = 0
	// client authentication is requested
	GTlsAuthenticationRequestedValue TlsAuthenticationMode = 1
	// client authentication is required
	GTlsAuthenticationRequiredValue TlsAuthenticationMode = 2
)

// Flags for g_tls_interaction_request_certificate(),
// g_tls_interaction_request_certificate_async(), and
// g_tls_interaction_invoke_request_certificate().
type TlsCertificateRequestFlags int

var xTlsCertificateRequestFlagsGLibType func() types.GType

func TlsCertificateRequestFlagsGLibType() types.GType {
	return xTlsCertificateRequestFlagsGLibType()
}

const (

	// No flags
	GTlsCertificateRequestNoneValue TlsCertificateRequestFlags = 0
)

// An error code used with %G_TLS_CHANNEL_BINDING_ERROR in a #GError to
// indicate a TLS channel binding retrieval error.
type TlsChannelBindingError int

var xTlsChannelBindingErrorGLibType func() types.GType

func TlsChannelBindingErrorGLibType() types.GType {
	return xTlsChannelBindingErrorGLibType()
}

const (

	// Either entire binding
	//    retrieval facility or specific binding type is not implemented in the
	//    TLS backend.
	GTlsChannelBindingErrorNotImplementedValue TlsChannelBindingError = 0
	// The handshake is not yet
	//    complete on the connection which is a strong requirement for any existing
	//    binding type.
	GTlsChannelBindingErrorInvalidStateValue TlsChannelBindingError = 1
	// Handshake is complete but
	//    binding data is not available. That normally indicates the TLS
	//    implementation failed to provide the binding data. For example, some
	//    implementations do not provide a peer certificate for resumed connections.
	GTlsChannelBindingErrorNotAvailableValue TlsChannelBindingError = 2
	// Binding type is not supported
	//    on the current connection. This error could be triggered when requesting
	//    `tls-server-end-point` binding data for a certificate which has no hash
	//    function or uses multiple hash functions.
	GTlsChannelBindingErrorNotSupportedValue TlsChannelBindingError = 3
	// Any other backend error
	//    preventing binding data retrieval.
	GTlsChannelBindingErrorGeneralErrorValue TlsChannelBindingError = 4
)

// The type of TLS channel binding data to retrieve from #GTlsConnection
// or #GDtlsConnection, as documented by RFC 5929 or RFC 9266. The
// [`tls-unique-for-telnet`](https://tools.ietf.org/html/rfc5929#section-5)
// binding type is not currently implemented.
type TlsChannelBindingType int

var xTlsChannelBindingTypeGLibType func() types.GType

func TlsChannelBindingTypeGLibType() types.GType {
	return xTlsChannelBindingTypeGLibType()
}

const (

	// [`tls-unique`](https://tools.ietf.org/html/rfc5929#section-3) binding
	//    type
	GTlsChannelBindingTlsUniqueValue TlsChannelBindingType = 0
	// [`tls-server-end-point`](https://tools.ietf.org/html/rfc5929#section-4)
	//    binding type
	GTlsChannelBindingTlsServerEndPointValue TlsChannelBindingType = 1
	// [`tls-exporter`](https://www.rfc-editor.org/rfc/rfc9266.html) binding
	//    type. Since: 2.74
	GTlsChannelBindingTlsExporterValue TlsChannelBindingType = 2
)

// Flags for g_tls_database_lookup_certificate_for_handle(),
// g_tls_database_lookup_certificate_issuer(),
// and g_tls_database_lookup_certificates_issued_by().
type TlsDatabaseLookupFlags int

var xTlsDatabaseLookupFlagsGLibType func() types.GType

func TlsDatabaseLookupFlagsGLibType() types.GType {
	return xTlsDatabaseLookupFlagsGLibType()
}

const (

	// No lookup flags
	GTlsDatabaseLookupNoneValue TlsDatabaseLookupFlags = 0
	// Restrict lookup to certificates that have
	//     a private key.
	GTlsDatabaseLookupKeypairValue TlsDatabaseLookupFlags = 1
)

// An error code used with %G_TLS_ERROR in a #GError returned from a
// TLS-related routine.
type TlsError int

var xTlsErrorGLibType func() types.GType

func TlsErrorGLibType() types.GType {
	return xTlsErrorGLibType()
}

const (

	// No TLS provider is available
	GTlsErrorUnavailableValue TlsError = 0
	// Miscellaneous TLS error
	GTlsErrorMiscValue TlsError = 1
	// The certificate presented could not
	//   be parsed or failed validation.
	GTlsErrorBadCertificateValue TlsError = 2
	// The TLS handshake failed because the
	//   peer does not seem to be a TLS server.
	GTlsErrorNotTlsValue TlsError = 3
	// The TLS handshake failed because the
	//   peer's certificate was not acceptable.
	GTlsErrorHandshakeValue TlsError = 4
	// The TLS handshake failed because
	//   the server requested a client-side certificate, but none was
	//   provided. See g_tls_connection_set_certificate().
	GTlsErrorCertificateRequiredValue TlsError = 5
	// The TLS connection was closed without proper
	//   notice, which may indicate an attack. See
	//   g_tls_connection_set_require_close_notify().
	GTlsErrorEofValue TlsError = 6
	// The TLS handshake failed
	//   because the client sent the fallback SCSV, indicating a protocol
	//   downgrade attack. Since: 2.60
	GTlsErrorInappropriateFallbackValue TlsError = 7
	// The certificate failed
	//   to load because a password was incorrect. Since: 2.72
	GTlsErrorBadCertificatePasswordValue TlsError = 8
)

// #GTlsInteractionResult is returned by various functions in #GTlsInteraction
// when finishing an interaction request.
type TlsInteractionResult int

var xTlsInteractionResultGLibType func() types.GType

func TlsInteractionResultGLibType() types.GType {
	return xTlsInteractionResultGLibType()
}

const (

	// The interaction was unhandled (i.e. not
	//     implemented).
	GTlsInteractionUnhandledValue TlsInteractionResult = 0
	// The interaction completed, and resulting data
	//     is available.
	GTlsInteractionHandledValue TlsInteractionResult = 1
	// The interaction has failed, or was cancelled.
	//     and the operation should be aborted.
	GTlsInteractionFailedValue TlsInteractionResult = 2
)

// The TLS or DTLS protocol version used by a #GTlsConnection or
// #GDtlsConnection. The integer values of these versions are sequential
// to ensure newer known protocol versions compare greater than older
// known versions. Any known DTLS protocol version will compare greater
// than any SSL or TLS protocol version. The protocol version may be
// %G_TLS_PROTOCOL_VERSION_UNKNOWN if the TLS backend supports a newer
// protocol version that GLib does not yet know about. This means that
// it's possible for an unknown DTLS protocol version to compare less
// than the TLS protocol versions.
type TlsProtocolVersion int

var xTlsProtocolVersionGLibType func() types.GType

func TlsProtocolVersionGLibType() types.GType {
	return xTlsProtocolVersionGLibType()
}

const (

	// No protocol version or unknown protocol version
	GTlsProtocolVersionUnknownValue TlsProtocolVersion = 0
	// SSL 3.0, which is insecure and should not be used
	GTlsProtocolVersionSsl30Value TlsProtocolVersion = 1
	// TLS 1.0, which is insecure and should not be used
	GTlsProtocolVersionTls10Value TlsProtocolVersion = 2
	// TLS 1.1, which is insecure and should not be used
	GTlsProtocolVersionTls11Value TlsProtocolVersion = 3
	// TLS 1.2, defined by [RFC 5246](https://datatracker.ietf.org/doc/html/rfc5246)
	GTlsProtocolVersionTls12Value TlsProtocolVersion = 4
	// TLS 1.3, defined by [RFC 8446](https://datatracker.ietf.org/doc/html/rfc8446)
	GTlsProtocolVersionTls13Value TlsProtocolVersion = 5
	// DTLS 1.0, which is insecure and should not be used
	GTlsProtocolVersionDtls10Value TlsProtocolVersion = 201
	// DTLS 1.2, defined by [RFC 6347](https://datatracker.ietf.org/doc/html/rfc6347)
	GTlsProtocolVersionDtls12Value TlsProtocolVersion = 202
)

// When to allow rehandshaking. See
// g_tls_connection_set_rehandshake_mode().
type TlsRehandshakeMode int

var xTlsRehandshakeModeGLibType func() types.GType

func TlsRehandshakeModeGLibType() types.GType {
	return xTlsRehandshakeModeGLibType()
}

const (

	// Never allow rehandshaking
	GTlsRehandshakeNeverValue TlsRehandshakeMode = 0
	// Allow safe rehandshaking only
	GTlsRehandshakeSafelyValue TlsRehandshakeMode = 1
	// Allow unsafe rehandshaking
	GTlsRehandshakeUnsafelyValue TlsRehandshakeMode = 2
)

// The type of name used by a #GUnixSocketAddress.
// %G_UNIX_SOCKET_ADDRESS_PATH indicates a traditional unix domain
// socket bound to a filesystem path. %G_UNIX_SOCKET_ADDRESS_ANONYMOUS
// indicates a socket not bound to any name (eg, a client-side socket,
// or a socket created with socketpair()).
//
// For abstract sockets, there are two incompatible ways of naming
// them; the man pages suggest using the entire `struct sockaddr_un`
// as the name, padding the unused parts of the %sun_path field with
// zeroes; this corresponds to %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED.
// However, many programs instead just use a portion of %sun_path, and
// pass an appropriate smaller length to bind() or connect(). This is
// %G_UNIX_SOCKET_ADDRESS_ABSTRACT.
type UnixSocketAddressType int

var xUnixSocketAddressTypeGLibType func() types.GType

func UnixSocketAddressTypeGLibType() types.GType {
	return xUnixSocketAddressTypeGLibType()
}

const (

	// invalid
	GUnixSocketAddressInvalidValue UnixSocketAddressType = 0
	// anonymous
	GUnixSocketAddressAnonymousValue UnixSocketAddressType = 1
	// a filesystem path
	GUnixSocketAddressPathValue UnixSocketAddressType = 2
	// an abstract name
	GUnixSocketAddressAbstractValue UnixSocketAddressType = 3
	// an abstract name, 0-padded
	//   to the full length of a unix socket name
	GUnixSocketAddressAbstractPaddedValue UnixSocketAddressType = 4
)

// Used to select the type of data format to use for #GZlibDecompressor
// and #GZlibCompressor.
type ZlibCompressorFormat int

var xZlibCompressorFormatGLibType func() types.GType

func ZlibCompressorFormatGLibType() types.GType {
	return xZlibCompressorFormatGLibType()
}

const (

	// deflate compression with zlib header
	GZlibCompressorFormatZlibValue ZlibCompressorFormat = 0
	// gzip file format
	GZlibCompressorFormatGzipValue ZlibCompressorFormat = 1
	// deflate compression with no header
	GZlibCompressorFormatRawValue ZlibCompressorFormat = 2
)