// GENERATED — DO NOT EDIT

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.ConverterResult.html).
pub(all) enum ConverterResult {
  Error = 0
  Converted = 1
  Finished = 2
  Flushed = 3
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.CredentialsType.html).
pub(all) enum CredentialsType {
  Invalid = 0
  LinuxUcred = 1
  FreebsdCmsgcred = 2
  OpenbsdSockpeercred = 3
  SolarisUcred = 4
  NetbsdUnpcbid = 5
  AppleXucred = 6
  Win32Pid = 7
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/error.DBusError.html).
pub(all) enum DBusError {
  Failed = 0
  NoMemory = 1
  ServiceUnknown = 2
  NameHasNoOwner = 3
  NoReply = 4
  IoError = 5
  BadAddress = 6
  NotSupported = 7
  LimitsExceeded = 8
  AccessDenied = 9
  AuthFailed = 10
  NoServer = 11
  Timeout = 12
  NoNetwork = 13
  AddressInUse = 14
  Disconnected = 15
  InvalidArgs = 16
  FileNotFound = 17
  FileExists = 18
  UnknownMethod = 19
  TimedOut = 20
  MatchRuleNotFound = 21
  MatchRuleInvalid = 22
  SpawnExecFailed = 23
  SpawnForkFailed = 24
  SpawnChildExited = 25
  SpawnChildSignaled = 26
  SpawnFailed = 27
  SpawnSetupFailed = 28
  SpawnConfigInvalid = 29
  SpawnServiceInvalid = 30
  SpawnServiceNotFound = 31
  SpawnPermissionsInvalid = 32
  SpawnFileInvalid = 33
  SpawnNoMemory = 34
  UnixProcessIdUnknown = 35
  InvalidSignature = 36
  InvalidFileContent = 37
  SelinuxSecurityContextUnknown = 38
  AdtAuditDataUnknown = 39
  ObjectPathInUse = 40
  UnknownObject = 41
  UnknownInterface = 42
  UnknownProperty = 43
  PropertyReadOnly = 44
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.DBusMessageByteOrder.html).
pub(all) enum DBusMessageByteOrder {
  BigEndian = 0
  LittleEndian = 1
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.DBusMessageHeaderField.html).
pub(all) enum DBusMessageHeaderField {
  Invalid = 0
  Path = 1
  Interface = 2
  Member = 3
  ErrorName = 4
  ReplySerial = 5
  Destination = 6
  Sender = 7
  Signature = 8
  NumUnixFds = 9
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.DBusMessageType.html).
pub(all) enum DBusMessageType {
  Invalid = 0
  MethodCall = 1
  MethodReturn = 2
  Error = 3
  Signal = 4
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.DataStreamByteOrder.html).
pub(all) enum DataStreamByteOrder {
  BigEndian = 0
  LittleEndian = 1
  HostEndian = 2
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.DataStreamNewlineType.html).
pub(all) enum DataStreamNewlineType {
  Lf = 0
  Cr = 1
  CrLf = 2
  Any = 3
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.DriveStartStopType.html).
pub(all) enum DriveStartStopType {
  Unknown = 0
  Shutdown = 1
  Network = 2
  Multidisk = 3
  Password = 4
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.EmblemOrigin.html).
pub(all) enum EmblemOrigin {
  Unknown = 0
  Device = 1
  Livemetadata = 2
  Tag = 3
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.FileAttributeStatus.html).
pub(all) enum FileAttributeStatus {
  Unset = 0
  Set = 1
  ErrorSetting = 2
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.FileAttributeType.html).
pub(all) enum FileAttributeType {
  Invalid = 0
  String = 1
  ByteString = 2
  Boolean = 3
  Uint32 = 4
  Int32 = 5
  Uint64 = 6
  Int64 = 7
  Object = 8
  Stringv = 9
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.FileMonitorEvent.html).
pub(all) enum FileMonitorEvent {
  Changed = 0
  ChangesDoneHint = 1
  Deleted = 2
  Created = 3
  AttributeChanged = 4
  PreUnmount = 5
  Unmounted = 6
  Moved = 7
  Renamed = 8
  MovedIn = 9
  MovedOut = 10
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.FileType.html).
pub(all) enum FileType {
  Unknown = 0
  Regular = 1
  Directory = 2
  SymbolicLink = 3
  Special = 4
  Shortcut = 5
  Mountable = 6
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.FilesystemPreviewType.html).
pub(all) enum FilesystemPreviewType {
  IfAlways = 0
  IfLocal = 1
  Never = 2
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/error.IOErrorEnum.html).
pub(all) enum IOErrorEnum {
  Failed = 0
  NotFound = 1
  Exists = 2
  IsDirectory = 3
  NotDirectory = 4
  NotEmpty = 5
  NotRegularFile = 6
  NotSymbolicLink = 7
  NotMountableFile = 8
  FilenameTooLong = 9
  InvalidFilename = 10
  TooManyLinks = 11
  NoSpace = 12
  InvalidArgument = 13
  PermissionDenied = 14
  NotSupported = 15
  NotMounted = 16
  AlreadyMounted = 17
  Closed = 18
  Cancelled = 19
  Pending = 20
  ReadOnly = 21
  CantCreateBackup = 22
  WrongEtag = 23
  TimedOut = 24
  WouldRecurse = 25
  Busy = 26
  WouldBlock = 27
  HostNotFound = 28
  WouldMerge = 29
  FailedHandled = 30
  TooManyOpenFiles = 31
  NotInitialized = 32
  AddressInUse = 33
  PartialInput = 34
  InvalidData = 35
  DbusError = 36
  HostUnreachable = 37
  NetworkUnreachable = 38
  ConnectionRefused = 39
  ProxyFailed = 40
  ProxyAuthFailed = 41
  ProxyNeedAuth = 42
  ProxyNotAllowed = 43
  BrokenPipe = 44
  NotConnected = 45
  MessageTooLarge = 46
  NoSuchDevice = 47
  DestinationUnset = 48
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.IOModuleScopeFlags.html).
pub(all) enum IOModuleScopeFlag {
  None = 1
  BlockDuplicates = 2
}

///|
fn IOModuleScopeFlag::to_int(self : IOModuleScopeFlag) -> Int = "%identity"

///|
pub struct IOModuleScopeFlags {
  priv value : Int
}

///|
pub fn IOModuleScopeFlags::IOModuleScopeFlags(
  flags : Array[IOModuleScopeFlag],
) -> IOModuleScopeFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  IOModuleScopeFlags::{ value: v }
}

///|
pub fn IOModuleScopeFlags::from_int(value : Int) -> IOModuleScopeFlags {
  IOModuleScopeFlags::{ value, }
}

///|
pub fn IOModuleScopeFlags::to_int(self : IOModuleScopeFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.MemoryMonitorWarningLevel.html).
pub(all) enum MemoryMonitorWarningLevel {
  Low = 0
  Medium = 1
  Critical = 2
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.MountOperationResult.html).
pub(all) enum MountOperationResult {
  Handled = 0
  Aborted = 1
  Unhandled = 2
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.NetworkConnectivity.html).
pub(all) enum NetworkConnectivity {
  Local = 0
  Limited = 1
  Portal = 2
  Full = 3
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.NotificationPriority.html).
pub(all) enum NotificationPriority {
  Normal = 0
  Low = 1
  High = 2
  Urgent = 3
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.PasswordSave.html).
pub(all) enum PasswordSave {
  Never = 0
  ForSession = 1
  Permanently = 2
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/error.ResolverError.html).
pub(all) enum ResolverError {
  NotFound = 0
  TemporaryFailure = 1
  Internal = 2
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.ResolverRecordType.html).
pub(all) enum ResolverRecordType {
  Srv = 0
  Mx = 1
  Txt = 2
  Soa = 3
  Ns = 4
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/error.ResourceError.html).
pub(all) enum ResourceError {
  NotFound = 0
  Internal = 1
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.SocketClientEvent.html).
pub(all) enum SocketClientEvent {
  Resolving = 0
  Resolved = 1
  Connecting = 2
  Connected = 3
  ProxyNegotiating = 4
  ProxyNegotiated = 5
  TlsHandshaking = 6
  TlsHandshaked = 7
  Complete = 8
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.SocketFamily.html).
pub(all) enum SocketFamily {
  Invalid = 0
  Unix = 1
  Ipv4 = 2
  Ipv6 = 3
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.SocketListenerEvent.html).
pub(all) enum SocketListenerEvent {
  Binding = 0
  Bound = 1
  Listening = 2
  Listened = 3
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.SocketType.html).
pub(all) enum SocketType {
  Invalid = 0
  Stream = 1
  Datagram = 2
  Seqpacket = 3
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.TlsAuthenticationMode.html).
pub(all) enum TlsAuthenticationMode {
  None = 0
  Requested = 1
  Required = 2
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.TlsCertificateRequestFlags.html).
pub(all) enum TlsCertificateRequestFlag {
  None = 1
}

///|
fn TlsCertificateRequestFlag::to_int(self : TlsCertificateRequestFlag) -> Int = "%identity"

///|
pub struct TlsCertificateRequestFlags {
  priv value : Int
}

///|
pub fn TlsCertificateRequestFlags::TlsCertificateRequestFlags(
  flags : Array[TlsCertificateRequestFlag],
) -> TlsCertificateRequestFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  TlsCertificateRequestFlags::{ value: v }
}

///|
pub fn TlsCertificateRequestFlags::from_int(
  value : Int,
) -> TlsCertificateRequestFlags {
  TlsCertificateRequestFlags::{ value, }
}

///|
pub fn TlsCertificateRequestFlags::to_int(
  self : TlsCertificateRequestFlags,
) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/error.TlsChannelBindingError.html).
pub(all) enum TlsChannelBindingError {
  NotImplemented = 0
  InvalidState = 1
  NotAvailable = 2
  NotSupported = 3
  GeneralError = 4
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.TlsChannelBindingType.html).
pub(all) enum TlsChannelBindingType {
  Unique = 0
  ServerEndPoint = 1
  Exporter = 2
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.TlsDatabaseLookupFlags.html).
pub(all) enum TlsDatabaseLookupFlag {
  None = 1
  Keypair = 2
}

///|
fn TlsDatabaseLookupFlag::to_int(self : TlsDatabaseLookupFlag) -> Int = "%identity"

///|
pub struct TlsDatabaseLookupFlags {
  priv value : Int
}

///|
pub fn TlsDatabaseLookupFlags::TlsDatabaseLookupFlags(
  flags : Array[TlsDatabaseLookupFlag],
) -> TlsDatabaseLookupFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  TlsDatabaseLookupFlags::{ value: v }
}

///|
pub fn TlsDatabaseLookupFlags::from_int(value : Int) -> TlsDatabaseLookupFlags {
  TlsDatabaseLookupFlags::{ value, }
}

///|
pub fn TlsDatabaseLookupFlags::to_int(self : TlsDatabaseLookupFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/error.TlsError.html).
pub(all) enum TlsError {
  Unavailable = 0
  Misc = 1
  BadCertificate = 2
  NotTls = 3
  Handshake = 4
  CertificateRequired = 5
  Eof = 6
  InappropriateFallback = 7
  BadCertificatePassword = 8
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.TlsInteractionResult.html).
pub(all) enum TlsInteractionResult {
  Unhandled = 0
  Handled = 1
  Failed = 2
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.TlsProtocolVersion.html).
pub(all) enum TlsProtocolVersion {
  Unknown = 0
  Ssl30 = 1
  Tls10 = 2
  Tls11 = 3
  Tls12 = 4
  Tls13 = 5
  Dtls10 = 6
  Dtls12 = 7
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.TlsRehandshakeMode.html).
pub(all) enum TlsRehandshakeMode {
  Never = 0
  Safely = 1
  Unsafely = 2
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.UnixSocketAddressType.html).
pub(all) enum UnixSocketAddressType {
  Invalid = 0
  Anonymous = 1
  Path = 2
  Abstract = 3
  AbstractPadded = 4
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/enum.ZlibCompressorFormat.html).
pub(all) enum ZlibCompressorFormat {
  Zlib = 0
  Gzip = 1
  Raw = 2
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.AppInfoCreateFlags.html).
pub(all) enum AppInfoCreateFlag {
  None = 1
  NeedsTerminal = 2
  SupportsUris = 4
  SupportsStartupNotification = 8
}

///|
fn AppInfoCreateFlag::to_int(self : AppInfoCreateFlag) -> Int = "%identity"

///|
pub struct AppInfoCreateFlags {
  priv value : Int
}

///|
pub fn AppInfoCreateFlags::AppInfoCreateFlags(
  flags : Array[AppInfoCreateFlag],
) -> AppInfoCreateFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  AppInfoCreateFlags::{ value: v }
}

///|
pub fn AppInfoCreateFlags::from_int(value : Int) -> AppInfoCreateFlags {
  AppInfoCreateFlags::{ value, }
}

///|
pub fn AppInfoCreateFlags::to_int(self : AppInfoCreateFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.ApplicationFlags.html).
pub(all) enum ApplicationFlag {
  DefaultFlags = 1
  IsService = 2
  IsLauncher = 4
  HandlesOpen = 8
  HandlesCommandLine = 16
  SendEnvironment = 32
  NonUnique = 64
  CanOverrideAppId = 128
  AllowReplacement = 256
  Replace = 512
}

///|
fn ApplicationFlag::to_int(self : ApplicationFlag) -> Int = "%identity"

///|
pub struct ApplicationFlags {
  priv value : Int
}

///|
pub fn ApplicationFlags::ApplicationFlags(
  flags : Array[ApplicationFlag],
) -> ApplicationFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  ApplicationFlags::{ value: v }
}

///|
pub fn ApplicationFlags::from_int(value : Int) -> ApplicationFlags {
  ApplicationFlags::{ value, }
}

///|
pub fn ApplicationFlags::to_int(self : ApplicationFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.AskPasswordFlags.html).
pub(all) enum AskPasswordFlag {
  NeedPassword = 1
  NeedUsername = 2
  NeedDomain = 4
  SavingSupported = 8
  AnonymousSupported = 16
  Tcrypt = 32
}

///|
fn AskPasswordFlag::to_int(self : AskPasswordFlag) -> Int = "%identity"

///|
pub struct AskPasswordFlags {
  priv value : Int
}

///|
pub fn AskPasswordFlags::AskPasswordFlags(
  flags : Array[AskPasswordFlag],
) -> AskPasswordFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  AskPasswordFlags::{ value: v }
}

///|
pub fn AskPasswordFlags::from_int(value : Int) -> AskPasswordFlags {
  AskPasswordFlags::{ value, }
}

///|
pub fn AskPasswordFlags::to_int(self : AskPasswordFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.BusNameOwnerFlags.html).
pub(all) enum BusNameOwnerFlag {
  None = 1
  AllowReplacement = 2
  Replace = 4
  DoNotQueue = 8
}

///|
fn BusNameOwnerFlag::to_int(self : BusNameOwnerFlag) -> Int = "%identity"

///|
pub struct BusNameOwnerFlags {
  priv value : Int
}

///|
pub fn BusNameOwnerFlags::BusNameOwnerFlags(
  flags : Array[BusNameOwnerFlag],
) -> BusNameOwnerFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  BusNameOwnerFlags::{ value: v }
}

///|
pub fn BusNameOwnerFlags::from_int(value : Int) -> BusNameOwnerFlags {
  BusNameOwnerFlags::{ value, }
}

///|
pub fn BusNameOwnerFlags::to_int(self : BusNameOwnerFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.BusNameWatcherFlags.html).
pub(all) enum BusNameWatcherFlag {
  None = 1
  AutoStart = 2
}

///|
fn BusNameWatcherFlag::to_int(self : BusNameWatcherFlag) -> Int = "%identity"

///|
pub struct BusNameWatcherFlags {
  priv value : Int
}

///|
pub fn BusNameWatcherFlags::BusNameWatcherFlags(
  flags : Array[BusNameWatcherFlag],
) -> BusNameWatcherFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  BusNameWatcherFlags::{ value: v }
}

///|
pub fn BusNameWatcherFlags::from_int(value : Int) -> BusNameWatcherFlags {
  BusNameWatcherFlags::{ value, }
}

///|
pub fn BusNameWatcherFlags::to_int(self : BusNameWatcherFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.ConverterFlags.html).
pub(all) enum ConverterFlag {
  None = 1
  InputAtEnd = 2
  Flush = 4
}

///|
fn ConverterFlag::to_int(self : ConverterFlag) -> Int = "%identity"

///|
pub struct ConverterFlags {
  priv value : Int
}

///|
pub fn ConverterFlags::ConverterFlags(
  flags : Array[ConverterFlag],
) -> ConverterFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  ConverterFlags::{ value: v }
}

///|
pub fn ConverterFlags::from_int(value : Int) -> ConverterFlags {
  ConverterFlags::{ value, }
}

///|
pub fn ConverterFlags::to_int(self : ConverterFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.DBusCallFlags.html).
pub(all) enum DBusCallFlag {
  None = 1
  NoAutoStart = 2
  AllowInteractiveAuthorization = 4
}

///|
fn DBusCallFlag::to_int(self : DBusCallFlag) -> Int = "%identity"

///|
pub struct DBusCallFlags {
  priv value : Int
}

///|
pub fn DBusCallFlags::DBusCallFlags(
  flags : Array[DBusCallFlag],
) -> DBusCallFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  DBusCallFlags::{ value: v }
}

///|
pub fn DBusCallFlags::from_int(value : Int) -> DBusCallFlags {
  DBusCallFlags::{ value, }
}

///|
pub fn DBusCallFlags::to_int(self : DBusCallFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.DBusCapabilityFlags.html).
pub(all) enum DBusCapabilityFlag {
  None = 1
  UnixFdPassing = 2
}

///|
fn DBusCapabilityFlag::to_int(self : DBusCapabilityFlag) -> Int = "%identity"

///|
pub struct DBusCapabilityFlags {
  priv value : Int
}

///|
pub fn DBusCapabilityFlags::DBusCapabilityFlags(
  flags : Array[DBusCapabilityFlag],
) -> DBusCapabilityFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  DBusCapabilityFlags::{ value: v }
}

///|
pub fn DBusCapabilityFlags::from_int(value : Int) -> DBusCapabilityFlags {
  DBusCapabilityFlags::{ value, }
}

///|
pub fn DBusCapabilityFlags::to_int(self : DBusCapabilityFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.DBusConnectionFlags.html).
pub(all) enum DBusConnectionFlag {
  None = 1
  AuthenticationClient = 2
  AuthenticationServer = 4
  AuthenticationAllowAnonymous = 8
  MessageBusConnection = 16
  DelayMessageProcessing = 32
  AuthenticationRequireSameUser = 64
  CrossNamespace = 128
}

///|
fn DBusConnectionFlag::to_int(self : DBusConnectionFlag) -> Int = "%identity"

///|
pub struct DBusConnectionFlags {
  priv value : Int
}

///|
pub fn DBusConnectionFlags::DBusConnectionFlags(
  flags : Array[DBusConnectionFlag],
) -> DBusConnectionFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  DBusConnectionFlags::{ value: v }
}

///|
pub fn DBusConnectionFlags::from_int(value : Int) -> DBusConnectionFlags {
  DBusConnectionFlags::{ value, }
}

///|
pub fn DBusConnectionFlags::to_int(self : DBusConnectionFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.DBusInterfaceSkeletonFlags.html).
pub(all) enum DBusInterfaceSkeletonFlag {
  None = 1
  HandleMethodInvocationsInThread = 2
}

///|
fn DBusInterfaceSkeletonFlag::to_int(self : DBusInterfaceSkeletonFlag) -> Int = "%identity"

///|
pub struct DBusInterfaceSkeletonFlags {
  priv value : Int
}

///|
pub fn DBusInterfaceSkeletonFlags::DBusInterfaceSkeletonFlags(
  flags : Array[DBusInterfaceSkeletonFlag],
) -> DBusInterfaceSkeletonFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  DBusInterfaceSkeletonFlags::{ value: v }
}

///|
pub fn DBusInterfaceSkeletonFlags::from_int(
  value : Int,
) -> DBusInterfaceSkeletonFlags {
  DBusInterfaceSkeletonFlags::{ value, }
}

///|
pub fn DBusInterfaceSkeletonFlags::to_int(
  self : DBusInterfaceSkeletonFlags,
) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.DBusMessageFlags.html).
pub(all) enum DBusMessageFlag {
  None = 1
  NoReplyExpected = 2
  NoAutoStart = 4
  AllowInteractiveAuthorization = 8
}

///|
fn DBusMessageFlag::to_int(self : DBusMessageFlag) -> Int = "%identity"

///|
pub struct DBusMessageFlags {
  priv value : Int
}

///|
pub fn DBusMessageFlags::DBusMessageFlags(
  flags : Array[DBusMessageFlag],
) -> DBusMessageFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  DBusMessageFlags::{ value: v }
}

///|
pub fn DBusMessageFlags::from_int(value : Int) -> DBusMessageFlags {
  DBusMessageFlags::{ value, }
}

///|
pub fn DBusMessageFlags::to_int(self : DBusMessageFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.DBusObjectManagerClientFlags.html).
pub(all) enum DBusObjectManagerClientFlag {
  None = 1
  DoNotAutoStart = 2
}

///|
fn DBusObjectManagerClientFlag::to_int(
  self : DBusObjectManagerClientFlag,
) -> Int = "%identity"

///|
pub struct DBusObjectManagerClientFlags {
  priv value : Int
}

///|
pub fn DBusObjectManagerClientFlags::DBusObjectManagerClientFlags(
  flags : Array[DBusObjectManagerClientFlag],
) -> DBusObjectManagerClientFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  DBusObjectManagerClientFlags::{ value: v }
}

///|
pub fn DBusObjectManagerClientFlags::from_int(
  value : Int,
) -> DBusObjectManagerClientFlags {
  DBusObjectManagerClientFlags::{ value, }
}

///|
pub fn DBusObjectManagerClientFlags::to_int(
  self : DBusObjectManagerClientFlags,
) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.DBusPropertyInfoFlags.html).
pub(all) enum DBusPropertyInfoFlag {
  None = 1
  Readable = 2
  Writable = 4
}

///|
fn DBusPropertyInfoFlag::to_int(self : DBusPropertyInfoFlag) -> Int = "%identity"

///|
pub struct DBusPropertyInfoFlags {
  priv value : Int
}

///|
pub fn DBusPropertyInfoFlags::DBusPropertyInfoFlags(
  flags : Array[DBusPropertyInfoFlag],
) -> DBusPropertyInfoFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  DBusPropertyInfoFlags::{ value: v }
}

///|
pub fn DBusPropertyInfoFlags::from_int(value : Int) -> DBusPropertyInfoFlags {
  DBusPropertyInfoFlags::{ value, }
}

///|
pub fn DBusPropertyInfoFlags::to_int(self : DBusPropertyInfoFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.DBusProxyFlags.html).
pub(all) enum DBusProxyFlag {
  None = 1
  DoNotLoadProperties = 2
  DoNotConnectSignals = 4
  DoNotAutoStart = 8
  GetInvalidatedProperties = 16
  DoNotAutoStartAtConstruction = 32
  NoMatchRule = 64
}

///|
fn DBusProxyFlag::to_int(self : DBusProxyFlag) -> Int = "%identity"

///|
pub struct DBusProxyFlags {
  priv value : Int
}

///|
pub fn DBusProxyFlags::DBusProxyFlags(
  flags : Array[DBusProxyFlag],
) -> DBusProxyFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  DBusProxyFlags::{ value: v }
}

///|
pub fn DBusProxyFlags::from_int(value : Int) -> DBusProxyFlags {
  DBusProxyFlags::{ value, }
}

///|
pub fn DBusProxyFlags::to_int(self : DBusProxyFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.DBusSendMessageFlags.html).
pub(all) enum DBusSendMessageFlag {
  None = 1
  PreserveSerial = 2
}

///|
fn DBusSendMessageFlag::to_int(self : DBusSendMessageFlag) -> Int = "%identity"

///|
pub struct DBusSendMessageFlags {
  priv value : Int
}

///|
pub fn DBusSendMessageFlags::DBusSendMessageFlags(
  flags : Array[DBusSendMessageFlag],
) -> DBusSendMessageFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  DBusSendMessageFlags::{ value: v }
}

///|
pub fn DBusSendMessageFlags::from_int(value : Int) -> DBusSendMessageFlags {
  DBusSendMessageFlags::{ value, }
}

///|
pub fn DBusSendMessageFlags::to_int(self : DBusSendMessageFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.DBusServerFlags.html).
pub(all) enum DBusServerFlag {
  None = 1
  RunInThread = 2
  AuthenticationAllowAnonymous = 4
  AuthenticationRequireSameUser = 8
}

///|
fn DBusServerFlag::to_int(self : DBusServerFlag) -> Int = "%identity"

///|
pub struct DBusServerFlags {
  priv value : Int
}

///|
pub fn DBusServerFlags::DBusServerFlags(
  flags : Array[DBusServerFlag],
) -> DBusServerFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  DBusServerFlags::{ value: v }
}

///|
pub fn DBusServerFlags::from_int(value : Int) -> DBusServerFlags {
  DBusServerFlags::{ value, }
}

///|
pub fn DBusServerFlags::to_int(self : DBusServerFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.DBusSignalFlags.html).
pub(all) enum DBusSignalFlag {
  None = 1
  NoMatchRule = 2
  MatchArg0Namespace = 4
  MatchArg0Path = 8
}

///|
fn DBusSignalFlag::to_int(self : DBusSignalFlag) -> Int = "%identity"

///|
pub struct DBusSignalFlags {
  priv value : Int
}

///|
pub fn DBusSignalFlags::DBusSignalFlags(
  flags : Array[DBusSignalFlag],
) -> DBusSignalFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  DBusSignalFlags::{ value: v }
}

///|
pub fn DBusSignalFlags::from_int(value : Int) -> DBusSignalFlags {
  DBusSignalFlags::{ value, }
}

///|
pub fn DBusSignalFlags::to_int(self : DBusSignalFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.DBusSubtreeFlags.html).
pub(all) enum DBusSubtreeFlag {
  None = 1
  DispatchToUnenumeratedNodes = 2
}

///|
fn DBusSubtreeFlag::to_int(self : DBusSubtreeFlag) -> Int = "%identity"

///|
pub struct DBusSubtreeFlags {
  priv value : Int
}

///|
pub fn DBusSubtreeFlags::DBusSubtreeFlags(
  flags : Array[DBusSubtreeFlag],
) -> DBusSubtreeFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  DBusSubtreeFlags::{ value: v }
}

///|
pub fn DBusSubtreeFlags::from_int(value : Int) -> DBusSubtreeFlags {
  DBusSubtreeFlags::{ value, }
}

///|
pub fn DBusSubtreeFlags::to_int(self : DBusSubtreeFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.DriveStartFlags.html).
pub(all) enum DriveStartFlag {
  None = 1
}

///|
fn DriveStartFlag::to_int(self : DriveStartFlag) -> Int = "%identity"

///|
pub struct DriveStartFlags {
  priv value : Int
}

///|
pub fn DriveStartFlags::DriveStartFlags(
  flags : Array[DriveStartFlag],
) -> DriveStartFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  DriveStartFlags::{ value: v }
}

///|
pub fn DriveStartFlags::from_int(value : Int) -> DriveStartFlags {
  DriveStartFlags::{ value, }
}

///|
pub fn DriveStartFlags::to_int(self : DriveStartFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.FileAttributeInfoFlags.html).
pub(all) enum FileAttributeInfoFlag {
  None = 1
  CopyWithFile = 2
  CopyWhenMoved = 4
}

///|
fn FileAttributeInfoFlag::to_int(self : FileAttributeInfoFlag) -> Int = "%identity"

///|
pub struct FileAttributeInfoFlags {
  priv value : Int
}

///|
pub fn FileAttributeInfoFlags::FileAttributeInfoFlags(
  flags : Array[FileAttributeInfoFlag],
) -> FileAttributeInfoFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  FileAttributeInfoFlags::{ value: v }
}

///|
pub fn FileAttributeInfoFlags::from_int(value : Int) -> FileAttributeInfoFlags {
  FileAttributeInfoFlags::{ value, }
}

///|
pub fn FileAttributeInfoFlags::to_int(self : FileAttributeInfoFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.FileCopyFlags.html).
pub(all) enum FileCopyFlag {
  None = 1
  Overwrite = 2
  Backup = 4
  NofollowSymlinks = 8
  AllMetadata = 16
  NoFallbackForMove = 32
  TargetDefaultPerms = 64
  TargetDefaultModifiedTime = 128
}

///|
fn FileCopyFlag::to_int(self : FileCopyFlag) -> Int = "%identity"

///|
pub struct FileCopyFlags {
  priv value : Int
}

///|
pub fn FileCopyFlags::FileCopyFlags(
  flags : Array[FileCopyFlag],
) -> FileCopyFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  FileCopyFlags::{ value: v }
}

///|
pub fn FileCopyFlags::from_int(value : Int) -> FileCopyFlags {
  FileCopyFlags::{ value, }
}

///|
pub fn FileCopyFlags::to_int(self : FileCopyFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.FileCreateFlags.html).
pub(all) enum FileCreateFlag {
  None = 1
  Private = 2
  ReplaceDestination = 4
}

///|
fn FileCreateFlag::to_int(self : FileCreateFlag) -> Int = "%identity"

///|
pub struct FileCreateFlags {
  priv value : Int
}

///|
pub fn FileCreateFlags::FileCreateFlags(
  flags : Array[FileCreateFlag],
) -> FileCreateFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  FileCreateFlags::{ value: v }
}

///|
pub fn FileCreateFlags::from_int(value : Int) -> FileCreateFlags {
  FileCreateFlags::{ value, }
}

///|
pub fn FileCreateFlags::to_int(self : FileCreateFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.FileMeasureFlags.html).
pub(all) enum FileMeasureFlag {
  None = 1
  ReportAnyError = 2
  ApparentSize = 4
  NoXdev = 8
}

///|
fn FileMeasureFlag::to_int(self : FileMeasureFlag) -> Int = "%identity"

///|
pub struct FileMeasureFlags {
  priv value : Int
}

///|
pub fn FileMeasureFlags::FileMeasureFlags(
  flags : Array[FileMeasureFlag],
) -> FileMeasureFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  FileMeasureFlags::{ value: v }
}

///|
pub fn FileMeasureFlags::from_int(value : Int) -> FileMeasureFlags {
  FileMeasureFlags::{ value, }
}

///|
pub fn FileMeasureFlags::to_int(self : FileMeasureFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.FileMonitorFlags.html).
pub(all) enum FileMonitorFlag {
  None = 1
  WatchMounts = 2
  SendMoved = 4
  WatchHardLinks = 8
  WatchMoves = 16
}

///|
fn FileMonitorFlag::to_int(self : FileMonitorFlag) -> Int = "%identity"

///|
pub struct FileMonitorFlags {
  priv value : Int
}

///|
pub fn FileMonitorFlags::FileMonitorFlags(
  flags : Array[FileMonitorFlag],
) -> FileMonitorFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  FileMonitorFlags::{ value: v }
}

///|
pub fn FileMonitorFlags::from_int(value : Int) -> FileMonitorFlags {
  FileMonitorFlags::{ value, }
}

///|
pub fn FileMonitorFlags::to_int(self : FileMonitorFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.FileQueryInfoFlags.html).
pub(all) enum FileQueryInfoFlag {
  None = 1
  NofollowSymlinks = 2
}

///|
fn FileQueryInfoFlag::to_int(self : FileQueryInfoFlag) -> Int = "%identity"

///|
pub struct FileQueryInfoFlags {
  priv value : Int
}

///|
pub fn FileQueryInfoFlags::FileQueryInfoFlags(
  flags : Array[FileQueryInfoFlag],
) -> FileQueryInfoFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  FileQueryInfoFlags::{ value: v }
}

///|
pub fn FileQueryInfoFlags::from_int(value : Int) -> FileQueryInfoFlags {
  FileQueryInfoFlags::{ value, }
}

///|
pub fn FileQueryInfoFlags::to_int(self : FileQueryInfoFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.IOStreamSpliceFlags.html).
pub(all) enum IOStreamSpliceFlag {
  None = 1
  CloseStream1 = 2
  CloseStream2 = 4
  WaitForBoth = 8
}

///|
fn IOStreamSpliceFlag::to_int(self : IOStreamSpliceFlag) -> Int = "%identity"

///|
pub struct IOStreamSpliceFlags {
  priv value : Int
}

///|
pub fn IOStreamSpliceFlags::IOStreamSpliceFlags(
  flags : Array[IOStreamSpliceFlag],
) -> IOStreamSpliceFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  IOStreamSpliceFlags::{ value: v }
}

///|
pub fn IOStreamSpliceFlags::from_int(value : Int) -> IOStreamSpliceFlags {
  IOStreamSpliceFlags::{ value, }
}

///|
pub fn IOStreamSpliceFlags::to_int(self : IOStreamSpliceFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.MountMountFlags.html).
pub(all) enum MountMountFlag {
  None = 1
}

///|
fn MountMountFlag::to_int(self : MountMountFlag) -> Int = "%identity"

///|
pub struct MountMountFlags {
  priv value : Int
}

///|
pub fn MountMountFlags::MountMountFlags(
  flags : Array[MountMountFlag],
) -> MountMountFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  MountMountFlags::{ value: v }
}

///|
pub fn MountMountFlags::from_int(value : Int) -> MountMountFlags {
  MountMountFlags::{ value, }
}

///|
pub fn MountMountFlags::to_int(self : MountMountFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.MountUnmountFlags.html).
pub(all) enum MountUnmountFlag {
  None = 1
  Force = 2
}

///|
fn MountUnmountFlag::to_int(self : MountUnmountFlag) -> Int = "%identity"

///|
pub struct MountUnmountFlags {
  priv value : Int
}

///|
pub fn MountUnmountFlags::MountUnmountFlags(
  flags : Array[MountUnmountFlag],
) -> MountUnmountFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  MountUnmountFlags::{ value: v }
}

///|
pub fn MountUnmountFlags::from_int(value : Int) -> MountUnmountFlags {
  MountUnmountFlags::{ value, }
}

///|
pub fn MountUnmountFlags::to_int(self : MountUnmountFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.OutputStreamSpliceFlags.html).
pub(all) enum OutputStreamSpliceFlag {
  None = 1
  CloseSource = 2
  CloseTarget = 4
}

///|
fn OutputStreamSpliceFlag::to_int(self : OutputStreamSpliceFlag) -> Int = "%identity"

///|
pub struct OutputStreamSpliceFlags {
  priv value : Int
}

///|
pub fn OutputStreamSpliceFlags::OutputStreamSpliceFlags(
  flags : Array[OutputStreamSpliceFlag],
) -> OutputStreamSpliceFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  OutputStreamSpliceFlags::{ value: v }
}

///|
pub fn OutputStreamSpliceFlags::from_int(
  value : Int,
) -> OutputStreamSpliceFlags {
  OutputStreamSpliceFlags::{ value, }
}

///|
pub fn OutputStreamSpliceFlags::to_int(self : OutputStreamSpliceFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.ResolverNameLookupFlags.html).
pub(all) enum ResolverNameLookupFlag {
  Default = 1
  Ipv4Only = 2
  Ipv6Only = 4
}

///|
fn ResolverNameLookupFlag::to_int(self : ResolverNameLookupFlag) -> Int = "%identity"

///|
pub struct ResolverNameLookupFlags {
  priv value : Int
}

///|
pub fn ResolverNameLookupFlags::ResolverNameLookupFlags(
  flags : Array[ResolverNameLookupFlag],
) -> ResolverNameLookupFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  ResolverNameLookupFlags::{ value: v }
}

///|
pub fn ResolverNameLookupFlags::from_int(
  value : Int,
) -> ResolverNameLookupFlags {
  ResolverNameLookupFlags::{ value, }
}

///|
pub fn ResolverNameLookupFlags::to_int(self : ResolverNameLookupFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.ResourceFlags.html).
pub(all) enum ResourceFlag {
  None = 1
  Compressed = 2
}

///|
fn ResourceFlag::to_int(self : ResourceFlag) -> Int = "%identity"

///|
pub struct ResourceFlags {
  priv value : Int
}

///|
pub fn ResourceFlags::ResourceFlags(
  flags : Array[ResourceFlag],
) -> ResourceFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  ResourceFlags::{ value: v }
}

///|
pub fn ResourceFlags::from_int(value : Int) -> ResourceFlags {
  ResourceFlags::{ value, }
}

///|
pub fn ResourceFlags::to_int(self : ResourceFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.ResourceLookupFlags.html).
pub(all) enum ResourceLookupFlag {
  None = 1
}

///|
fn ResourceLookupFlag::to_int(self : ResourceLookupFlag) -> Int = "%identity"

///|
pub struct ResourceLookupFlags {
  priv value : Int
}

///|
pub fn ResourceLookupFlags::ResourceLookupFlags(
  flags : Array[ResourceLookupFlag],
) -> ResourceLookupFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  ResourceLookupFlags::{ value: v }
}

///|
pub fn ResourceLookupFlags::from_int(value : Int) -> ResourceLookupFlags {
  ResourceLookupFlags::{ value, }
}

///|
pub fn ResourceLookupFlags::to_int(self : ResourceLookupFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.SettingsBindFlags.html).
pub(all) enum SettingsBindFlag {
  Default = 1
  Get = 2
  Set = 4
  NoSensitivity = 8
  GetNoChanges = 16
  InvertBoolean = 32
}

///|
fn SettingsBindFlag::to_int(self : SettingsBindFlag) -> Int = "%identity"

///|
pub struct SettingsBindFlags {
  priv value : Int
}

///|
pub fn SettingsBindFlags::SettingsBindFlags(
  flags : Array[SettingsBindFlag],
) -> SettingsBindFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  SettingsBindFlags::{ value: v }
}

///|
pub fn SettingsBindFlags::from_int(value : Int) -> SettingsBindFlags {
  SettingsBindFlags::{ value, }
}

///|
pub fn SettingsBindFlags::to_int(self : SettingsBindFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.SocketMsgFlags.html).
pub(all) enum SocketMsgFlag {
  None = 1
  Oob = 2
  Peek = 4
  Dontroute = 8
}

///|
fn SocketMsgFlag::to_int(self : SocketMsgFlag) -> Int = "%identity"

///|
pub struct SocketMsgFlags {
  priv value : Int
}

///|
pub fn SocketMsgFlags::SocketMsgFlags(
  flags : Array[SocketMsgFlag],
) -> SocketMsgFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  SocketMsgFlags::{ value: v }
}

///|
pub fn SocketMsgFlags::from_int(value : Int) -> SocketMsgFlags {
  SocketMsgFlags::{ value, }
}

///|
pub fn SocketMsgFlags::to_int(self : SocketMsgFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.SubprocessFlags.html).
pub(all) enum SubprocessFlag {
  None = 1
  StdinPipe = 2
  StdinInherit = 4
  StdoutPipe = 8
  StdoutSilence = 16
  StderrPipe = 32
  StderrSilence = 64
  StderrMerge = 128
  InheritFds = 256
  SearchPathFromEnvp = 512
}

///|
fn SubprocessFlag::to_int(self : SubprocessFlag) -> Int = "%identity"

///|
pub struct SubprocessFlags {
  priv value : Int
}

///|
pub fn SubprocessFlags::SubprocessFlags(
  flags : Array[SubprocessFlag],
) -> SubprocessFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  SubprocessFlags::{ value: v }
}

///|
pub fn SubprocessFlags::from_int(value : Int) -> SubprocessFlags {
  SubprocessFlags::{ value, }
}

///|
pub fn SubprocessFlags::to_int(self : SubprocessFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.TestDBusFlags.html).
pub(all) enum TestDBusFlag {
  None = 1
}

///|
fn TestDBusFlag::to_int(self : TestDBusFlag) -> Int = "%identity"

///|
pub struct TestDBusFlags {
  priv value : Int
}

///|
pub fn TestDBusFlags::TestDBusFlags(
  flags : Array[TestDBusFlag],
) -> TestDBusFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  TestDBusFlags::{ value: v }
}

///|
pub fn TestDBusFlags::from_int(value : Int) -> TestDBusFlags {
  TestDBusFlags::{ value, }
}

///|
pub fn TestDBusFlags::to_int(self : TestDBusFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.TlsCertificateFlags.html).
pub(all) enum TlsCertificateFlag {
  NoFlags = 1
  UnknownCa = 2
  BadIdentity = 4
  NotActivated = 8
  Expired = 16
  Revoked = 32
  Insecure = 64
  GenericError = 128
  ValidateAll = 256
}

///|
fn TlsCertificateFlag::to_int(self : TlsCertificateFlag) -> Int = "%identity"

///|
pub struct TlsCertificateFlags {
  priv value : Int
}

///|
pub fn TlsCertificateFlags::TlsCertificateFlags(
  flags : Array[TlsCertificateFlag],
) -> TlsCertificateFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  TlsCertificateFlags::{ value: v }
}

///|
pub fn TlsCertificateFlags::from_int(value : Int) -> TlsCertificateFlags {
  TlsCertificateFlags::{ value, }
}

///|
pub fn TlsCertificateFlags::to_int(self : TlsCertificateFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.TlsDatabaseVerifyFlags.html).
pub(all) enum TlsDatabaseVerifyFlag {
  None = 1
}

///|
fn TlsDatabaseVerifyFlag::to_int(self : TlsDatabaseVerifyFlag) -> Int = "%identity"

///|
pub struct TlsDatabaseVerifyFlags {
  priv value : Int
}

///|
pub fn TlsDatabaseVerifyFlags::TlsDatabaseVerifyFlags(
  flags : Array[TlsDatabaseVerifyFlag],
) -> TlsDatabaseVerifyFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  TlsDatabaseVerifyFlags::{ value: v }
}

///|
pub fn TlsDatabaseVerifyFlags::from_int(value : Int) -> TlsDatabaseVerifyFlags {
  TlsDatabaseVerifyFlags::{ value, }
}

///|
pub fn TlsDatabaseVerifyFlags::to_int(self : TlsDatabaseVerifyFlags) -> Int {
  self.value
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/flags.TlsPasswordFlags.html).
pub(all) enum TlsPasswordFlag {
  None = 1
  Retry = 2
  ManyTries = 4
  FinalTry = 8
  Pkcs11User = 16
  Pkcs11SecurityOfficer = 32
  Pkcs11ContextSpecific = 64
}

///|
fn TlsPasswordFlag::to_int(self : TlsPasswordFlag) -> Int = "%identity"

///|
pub struct TlsPasswordFlags {
  priv value : Int
}

///|
pub fn TlsPasswordFlags::TlsPasswordFlags(
  flags : Array[TlsPasswordFlag],
) -> TlsPasswordFlags {
  let mut v = 0
  for flag in flags {
    v = v | flag.to_int()
  }
  TlsPasswordFlags::{ value: v }
}

///|
pub fn TlsPasswordFlags::from_int(value : Int) -> TlsPasswordFlags {
  TlsPasswordFlags::{ value, }
}

///|
pub fn TlsPasswordFlags::to_int(self : TlsPasswordFlags) -> Int {
  self.value
}