gio/gioenumtypes.c

   1
   2 /* Generated data (by glib-mkenums) */
   3
   4 #include <gio.h>
   5
   6 /* enumerations from "gioenums.h" */
   7 GType
   8 g_app_info_create_flags_get_type (void)
   9 {
  10   static volatile gsize g_define_type_id__volatile = 0;
  11
  12   if (g_once_init_enter (&g_define_type_id__volatile))
  13     {
  14       static const GFlagsValue values[] = {
  15         { G_APP_INFO_CREATE_NONE, "G_APP_INFO_CREATE_NONE", "none" },
  16         { G_APP_INFO_CREATE_NEEDS_TERMINAL, "G_APP_INFO_CREATE_NEEDS_TERMINAL", "needs-terminal" },
  17         { G_APP_INFO_CREATE_SUPPORTS_URIS, "G_APP_INFO_CREATE_SUPPORTS_URIS", "supports-uris" },
  18         { G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION, "G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION", "supports-startup-notification" },
  19         { 0, NULL, NULL }
  20       };
  21       GType g_define_type_id =
  22         g_flags_register_static (g_intern_static_string ("GAppInfoCreateFlags"), values);
  23       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
  24     }
  25
  26   return g_define_type_id__volatile;
  27 }
  28
  29 GType
  30 g_converter_flags_get_type (void)
  31 {
  32   static volatile gsize g_define_type_id__volatile = 0;
  33
  34   if (g_once_init_enter (&g_define_type_id__volatile))
  35     {
  36       static const GFlagsValue values[] = {
  37         { G_CONVERTER_NO_FLAGS, "G_CONVERTER_NO_FLAGS", "none" },
  38         { G_CONVERTER_INPUT_AT_END, "G_CONVERTER_INPUT_AT_END", "input-at-end" },
  39         { G_CONVERTER_FLUSH, "G_CONVERTER_FLUSH", "flush" },
  40         { 0, NULL, NULL }
  41       };
  42       GType g_define_type_id =
  43         g_flags_register_static (g_intern_static_string ("GConverterFlags"), values);
  44       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
  45     }
  46
  47   return g_define_type_id__volatile;
  48 }
  49
  50 GType
  51 g_converter_result_get_type (void)
  52 {
  53   static volatile gsize g_define_type_id__volatile = 0;
  54
  55   if (g_once_init_enter (&g_define_type_id__volatile))
  56     {
  57       static const GEnumValue values[] = {
  58         { G_CONVERTER_ERROR, "G_CONVERTER_ERROR", "error" },
  59         { G_CONVERTER_CONVERTED, "G_CONVERTER_CONVERTED", "converted" },
  60         { G_CONVERTER_FINISHED, "G_CONVERTER_FINISHED", "finished" },
  61         { G_CONVERTER_FLUSHED, "G_CONVERTER_FLUSHED", "flushed" },
  62         { 0, NULL, NULL }
  63       };
  64       GType g_define_type_id =
  65         g_enum_register_static (g_intern_static_string ("GConverterResult"), values);
  66       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
  67     }
  68
  69   return g_define_type_id__volatile;
  70 }
  71
  72 GType
  73 g_data_stream_byte_order_get_type (void)
  74 {
  75   static volatile gsize g_define_type_id__volatile = 0;
  76
  77   if (g_once_init_enter (&g_define_type_id__volatile))
  78     {
  79       static const GEnumValue values[] = {
  80         { G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN, "G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN", "big-endian" },
  81         { G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN, "G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN", "little-endian" },
  82         { G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN, "G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN", "host-endian" },
  83         { 0, NULL, NULL }
  84       };
  85       GType g_define_type_id =
  86         g_enum_register_static (g_intern_static_string ("GDataStreamByteOrder"), values);
  87       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
  88     }
  89
  90   return g_define_type_id__volatile;
  91 }
  92
  93 GType
  94 g_data_stream_newline_type_get_type (void)
  95 {
  96   static volatile gsize g_define_type_id__volatile = 0;
  97
  98   if (g_once_init_enter (&g_define_type_id__volatile))
  99     {
 100       static const GEnumValue values[] = {
 101         { G_DATA_STREAM_NEWLINE_TYPE_LF, "G_DATA_STREAM_NEWLINE_TYPE_LF", "lf" },
 102         { G_DATA_STREAM_NEWLINE_TYPE_CR, "G_DATA_STREAM_NEWLINE_TYPE_CR", "cr" },
 103         { G_DATA_STREAM_NEWLINE_TYPE_CR_LF, "G_DATA_STREAM_NEWLINE_TYPE_CR_LF", "cr-lf" },
 104         { G_DATA_STREAM_NEWLINE_TYPE_ANY, "G_DATA_STREAM_NEWLINE_TYPE_ANY", "any" },
 105         { 0, NULL, NULL }
 106       };
 107       GType g_define_type_id =
 108         g_enum_register_static (g_intern_static_string ("GDataStreamNewlineType"), values);
 109       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 110     }
 111
 112   return g_define_type_id__volatile;
 113 }
 114
 115 GType
 116 g_file_attribute_type_get_type (void)
 117 {
 118   static volatile gsize g_define_type_id__volatile = 0;
 119
 120   if (g_once_init_enter (&g_define_type_id__volatile))
 121     {
 122       static const GEnumValue values[] = {
 123         { G_FILE_ATTRIBUTE_TYPE_INVALID, "G_FILE_ATTRIBUTE_TYPE_INVALID", "invalid" },
 124         { G_FILE_ATTRIBUTE_TYPE_STRING, "G_FILE_ATTRIBUTE_TYPE_STRING", "string" },
 125         { G_FILE_ATTRIBUTE_TYPE_BYTE_STRING, "G_FILE_ATTRIBUTE_TYPE_BYTE_STRING", "byte-string" },
 126         { G_FILE_ATTRIBUTE_TYPE_BOOLEAN, "G_FILE_ATTRIBUTE_TYPE_BOOLEAN", "boolean" },
 127         { G_FILE_ATTRIBUTE_TYPE_UINT32, "G_FILE_ATTRIBUTE_TYPE_UINT32", "uint32" },
 128         { G_FILE_ATTRIBUTE_TYPE_INT32, "G_FILE_ATTRIBUTE_TYPE_INT32", "int32" },
 129         { G_FILE_ATTRIBUTE_TYPE_UINT64, "G_FILE_ATTRIBUTE_TYPE_UINT64", "uint64" },
 130         { G_FILE_ATTRIBUTE_TYPE_INT64, "G_FILE_ATTRIBUTE_TYPE_INT64", "int64" },
 131         { G_FILE_ATTRIBUTE_TYPE_OBJECT, "G_FILE_ATTRIBUTE_TYPE_OBJECT", "object" },
 132         { G_FILE_ATTRIBUTE_TYPE_STRINGV, "G_FILE_ATTRIBUTE_TYPE_STRINGV", "stringv" },
 133         { 0, NULL, NULL }
 134       };
 135       GType g_define_type_id =
 136         g_enum_register_static (g_intern_static_string ("GFileAttributeType"), values);
 137       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 138     }
 139
 140   return g_define_type_id__volatile;
 141 }
 142
 143 GType
 144 g_file_attribute_info_flags_get_type (void)
 145 {
 146   static volatile gsize g_define_type_id__volatile = 0;
 147
 148   if (g_once_init_enter (&g_define_type_id__volatile))
 149     {
 150       static const GFlagsValue values[] = {
 151         { G_FILE_ATTRIBUTE_INFO_NONE, "G_FILE_ATTRIBUTE_INFO_NONE", "none" },
 152         { G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE, "G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE", "copy-with-file" },
 153         { G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED, "G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED", "copy-when-moved" },
 154         { 0, NULL, NULL }
 155       };
 156       GType g_define_type_id =
 157         g_flags_register_static (g_intern_static_string ("GFileAttributeInfoFlags"), values);
 158       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 159     }
 160
 161   return g_define_type_id__volatile;
 162 }
 163
 164 GType
 165 g_file_attribute_status_get_type (void)
 166 {
 167   static volatile gsize g_define_type_id__volatile = 0;
 168
 169   if (g_once_init_enter (&g_define_type_id__volatile))
 170     {
 171       static const GEnumValue values[] = {
 172         { G_FILE_ATTRIBUTE_STATUS_UNSET, "G_FILE_ATTRIBUTE_STATUS_UNSET", "unset" },
 173         { G_FILE_ATTRIBUTE_STATUS_SET, "G_FILE_ATTRIBUTE_STATUS_SET", "set" },
 174         { G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING, "G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING", "error-setting" },
 175         { 0, NULL, NULL }
 176       };
 177       GType g_define_type_id =
 178         g_enum_register_static (g_intern_static_string ("GFileAttributeStatus"), values);
 179       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 180     }
 181
 182   return g_define_type_id__volatile;
 183 }
 184
 185 GType
 186 g_file_query_info_flags_get_type (void)
 187 {
 188   static volatile gsize g_define_type_id__volatile = 0;
 189
 190   if (g_once_init_enter (&g_define_type_id__volatile))
 191     {
 192       static const GFlagsValue values[] = {
 193         { G_FILE_QUERY_INFO_NONE, "G_FILE_QUERY_INFO_NONE", "none" },
 194         { G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, "G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS", "nofollow-symlinks" },
 195         { 0, NULL, NULL }
 196       };
 197       GType g_define_type_id =
 198         g_flags_register_static (g_intern_static_string ("GFileQueryInfoFlags"), values);
 199       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 200     }
 201
 202   return g_define_type_id__volatile;
 203 }
 204
 205 GType
 206 g_file_create_flags_get_type (void)
 207 {
 208   static volatile gsize g_define_type_id__volatile = 0;
 209
 210   if (g_once_init_enter (&g_define_type_id__volatile))
 211     {
 212       static const GFlagsValue values[] = {
 213         { G_FILE_CREATE_NONE, "G_FILE_CREATE_NONE", "none" },
 214         { G_FILE_CREATE_PRIVATE, "G_FILE_CREATE_PRIVATE", "private" },
 215         { G_FILE_CREATE_REPLACE_DESTINATION, "G_FILE_CREATE_REPLACE_DESTINATION", "replace-destination" },
 216         { 0, NULL, NULL }
 217       };
 218       GType g_define_type_id =
 219         g_flags_register_static (g_intern_static_string ("GFileCreateFlags"), values);
 220       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 221     }
 222
 223   return g_define_type_id__volatile;
 224 }
 225
 226 GType
 227 g_mount_mount_flags_get_type (void)
 228 {
 229   static volatile gsize g_define_type_id__volatile = 0;
 230
 231   if (g_once_init_enter (&g_define_type_id__volatile))
 232     {
 233       static const GFlagsValue values[] = {
 234         { G_MOUNT_MOUNT_NONE, "G_MOUNT_MOUNT_NONE", "none" },
 235         { 0, NULL, NULL }
 236       };
 237       GType g_define_type_id =
 238         g_flags_register_static (g_intern_static_string ("GMountMountFlags"), values);
 239       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 240     }
 241
 242   return g_define_type_id__volatile;
 243 }
 244
 245 GType
 246 g_mount_unmount_flags_get_type (void)
 247 {
 248   static volatile gsize g_define_type_id__volatile = 0;
 249
 250   if (g_once_init_enter (&g_define_type_id__volatile))
 251     {
 252       static const GFlagsValue values[] = {
 253         { G_MOUNT_UNMOUNT_NONE, "G_MOUNT_UNMOUNT_NONE", "none" },
 254         { G_MOUNT_UNMOUNT_FORCE, "G_MOUNT_UNMOUNT_FORCE", "force" },
 255         { 0, NULL, NULL }
 256       };
 257       GType g_define_type_id =
 258         g_flags_register_static (g_intern_static_string ("GMountUnmountFlags"), values);
 259       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 260     }
 261
 262   return g_define_type_id__volatile;
 263 }
 264
 265 GType
 266 g_drive_start_flags_get_type (void)
 267 {
 268   static volatile gsize g_define_type_id__volatile = 0;
 269
 270   if (g_once_init_enter (&g_define_type_id__volatile))
 271     {
 272       static const GFlagsValue values[] = {
 273         { G_DRIVE_START_NONE, "G_DRIVE_START_NONE", "none" },
 274         { 0, NULL, NULL }
 275       };
 276       GType g_define_type_id =
 277         g_flags_register_static (g_intern_static_string ("GDriveStartFlags"), values);
 278       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 279     }
 280
 281   return g_define_type_id__volatile;
 282 }
 283
 284 GType
 285 g_drive_start_stop_type_get_type (void)
 286 {
 287   static volatile gsize g_define_type_id__volatile = 0;
 288
 289   if (g_once_init_enter (&g_define_type_id__volatile))
 290     {
 291       static const GEnumValue values[] = {
 292         { G_DRIVE_START_STOP_TYPE_UNKNOWN, "G_DRIVE_START_STOP_TYPE_UNKNOWN", "unknown" },
 293         { G_DRIVE_START_STOP_TYPE_SHUTDOWN, "G_DRIVE_START_STOP_TYPE_SHUTDOWN", "shutdown" },
 294         { G_DRIVE_START_STOP_TYPE_NETWORK, "G_DRIVE_START_STOP_TYPE_NETWORK", "network" },
 295         { G_DRIVE_START_STOP_TYPE_MULTIDISK, "G_DRIVE_START_STOP_TYPE_MULTIDISK", "multidisk" },
 296         { G_DRIVE_START_STOP_TYPE_PASSWORD, "G_DRIVE_START_STOP_TYPE_PASSWORD", "password" },
 297         { 0, NULL, NULL }
 298       };
 299       GType g_define_type_id =
 300         g_enum_register_static (g_intern_static_string ("GDriveStartStopType"), values);
 301       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 302     }
 303
 304   return g_define_type_id__volatile;
 305 }
 306
 307 GType
 308 g_file_copy_flags_get_type (void)
 309 {
 310   static volatile gsize g_define_type_id__volatile = 0;
 311
 312   if (g_once_init_enter (&g_define_type_id__volatile))
 313     {
 314       static const GFlagsValue values[] = {
 315         { G_FILE_COPY_NONE, "G_FILE_COPY_NONE", "none" },
 316         { G_FILE_COPY_OVERWRITE, "G_FILE_COPY_OVERWRITE", "overwrite" },
 317         { G_FILE_COPY_BACKUP, "G_FILE_COPY_BACKUP", "backup" },
 318         { G_FILE_COPY_NOFOLLOW_SYMLINKS, "G_FILE_COPY_NOFOLLOW_SYMLINKS", "nofollow-symlinks" },
 319         { G_FILE_COPY_ALL_METADATA, "G_FILE_COPY_ALL_METADATA", "all-metadata" },
 320         { G_FILE_COPY_NO_FALLBACK_FOR_MOVE, "G_FILE_COPY_NO_FALLBACK_FOR_MOVE", "no-fallback-for-move" },
 321         { G_FILE_COPY_TARGET_DEFAULT_PERMS, "G_FILE_COPY_TARGET_DEFAULT_PERMS", "target-default-perms" },
 322         { 0, NULL, NULL }
 323       };
 324       GType g_define_type_id =
 325         g_flags_register_static (g_intern_static_string ("GFileCopyFlags"), values);
 326       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 327     }
 328
 329   return g_define_type_id__volatile;
 330 }
 331
 332 GType
 333 g_file_monitor_flags_get_type (void)
 334 {
 335   static volatile gsize g_define_type_id__volatile = 0;
 336
 337   if (g_once_init_enter (&g_define_type_id__volatile))
 338     {
 339       static const GFlagsValue values[] = {
 340         { G_FILE_MONITOR_NONE, "G_FILE_MONITOR_NONE", "none" },
 341         { G_FILE_MONITOR_WATCH_MOUNTS, "G_FILE_MONITOR_WATCH_MOUNTS", "watch-mounts" },
 342         { G_FILE_MONITOR_SEND_MOVED, "G_FILE_MONITOR_SEND_MOVED", "send-moved" },
 343         { 0, NULL, NULL }
 344       };
 345       GType g_define_type_id =
 346         g_flags_register_static (g_intern_static_string ("GFileMonitorFlags"), values);
 347       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 348     }
 349
 350   return g_define_type_id__volatile;
 351 }
 352
 353 GType
 354 g_file_type_get_type (void)
 355 {
 356   static volatile gsize g_define_type_id__volatile = 0;
 357
 358   if (g_once_init_enter (&g_define_type_id__volatile))
 359     {
 360       static const GEnumValue values[] = {
 361         { G_FILE_TYPE_UNKNOWN, "G_FILE_TYPE_UNKNOWN", "unknown" },
 362         { G_FILE_TYPE_REGULAR, "G_FILE_TYPE_REGULAR", "regular" },
 363         { G_FILE_TYPE_DIRECTORY, "G_FILE_TYPE_DIRECTORY", "directory" },
 364         { G_FILE_TYPE_SYMBOLIC_LINK, "G_FILE_TYPE_SYMBOLIC_LINK", "symbolic-link" },
 365         { G_FILE_TYPE_SPECIAL, "G_FILE_TYPE_SPECIAL", "special" },
 366         { G_FILE_TYPE_SHORTCUT, "G_FILE_TYPE_SHORTCUT", "shortcut" },
 367         { G_FILE_TYPE_MOUNTABLE, "G_FILE_TYPE_MOUNTABLE", "mountable" },
 368         { 0, NULL, NULL }
 369       };
 370       GType g_define_type_id =
 371         g_enum_register_static (g_intern_static_string ("GFileType"), values);
 372       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 373     }
 374
 375   return g_define_type_id__volatile;
 376 }
 377
 378 GType
 379 g_filesystem_preview_type_get_type (void)
 380 {
 381   static volatile gsize g_define_type_id__volatile = 0;
 382
 383   if (g_once_init_enter (&g_define_type_id__volatile))
 384     {
 385       static const GEnumValue values[] = {
 386         { G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS, "G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS", "if-always" },
 387         { G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL, "G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL", "if-local" },
 388         { G_FILESYSTEM_PREVIEW_TYPE_NEVER, "G_FILESYSTEM_PREVIEW_TYPE_NEVER", "never" },
 389         { 0, NULL, NULL }
 390       };
 391       GType g_define_type_id =
 392         g_enum_register_static (g_intern_static_string ("GFilesystemPreviewType"), values);
 393       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 394     }
 395
 396   return g_define_type_id__volatile;
 397 }
 398
 399 GType
 400 g_file_monitor_event_get_type (void)
 401 {
 402   static volatile gsize g_define_type_id__volatile = 0;
 403
 404   if (g_once_init_enter (&g_define_type_id__volatile))
 405     {
 406       static const GEnumValue values[] = {
 407         { G_FILE_MONITOR_EVENT_CHANGED, "G_FILE_MONITOR_EVENT_CHANGED", "changed" },
 408         { G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT, "G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT", "changes-done-hint" },
 409         { G_FILE_MONITOR_EVENT_DELETED, "G_FILE_MONITOR_EVENT_DELETED", "deleted" },
 410         { G_FILE_MONITOR_EVENT_CREATED, "G_FILE_MONITOR_EVENT_CREATED", "created" },
 411         { G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED, "G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED", "attribute-changed" },
 412         { G_FILE_MONITOR_EVENT_PRE_UNMOUNT, "G_FILE_MONITOR_EVENT_PRE_UNMOUNT", "pre-unmount" },
 413         { G_FILE_MONITOR_EVENT_UNMOUNTED, "G_FILE_MONITOR_EVENT_UNMOUNTED", "unmounted" },
 414         { G_FILE_MONITOR_EVENT_MOVED, "G_FILE_MONITOR_EVENT_MOVED", "moved" },
 415         { 0, NULL, NULL }
 416       };
 417       GType g_define_type_id =
 418         g_enum_register_static (g_intern_static_string ("GFileMonitorEvent"), values);
 419       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 420     }
 421
 422   return g_define_type_id__volatile;
 423 }
 424
 425 GType
 426 g_io_error_enum_get_type (void)
 427 {
 428   static volatile gsize g_define_type_id__volatile = 0;
 429
 430   if (g_once_init_enter (&g_define_type_id__volatile))
 431     {
 432       static const GEnumValue values[] = {
 433         { G_IO_ERROR_FAILED, "G_IO_ERROR_FAILED", "failed" },
 434         { G_IO_ERROR_NOT_FOUND, "G_IO_ERROR_NOT_FOUND", "not-found" },
 435         { G_IO_ERROR_EXISTS, "G_IO_ERROR_EXISTS", "exists" },
 436         { G_IO_ERROR_IS_DIRECTORY, "G_IO_ERROR_IS_DIRECTORY", "is-directory" },
 437         { G_IO_ERROR_NOT_DIRECTORY, "G_IO_ERROR_NOT_DIRECTORY", "not-directory" },
 438         { G_IO_ERROR_NOT_EMPTY, "G_IO_ERROR_NOT_EMPTY", "not-empty" },
 439         { G_IO_ERROR_NOT_REGULAR_FILE, "G_IO_ERROR_NOT_REGULAR_FILE", "not-regular-file" },
 440         { G_IO_ERROR_NOT_SYMBOLIC_LINK, "G_IO_ERROR_NOT_SYMBOLIC_LINK", "not-symbolic-link" },
 441         { G_IO_ERROR_NOT_MOUNTABLE_FILE, "G_IO_ERROR_NOT_MOUNTABLE_FILE", "not-mountable-file" },
 442         { G_IO_ERROR_FILENAME_TOO_LONG, "G_IO_ERROR_FILENAME_TOO_LONG", "filename-too-long" },
 443         { G_IO_ERROR_INVALID_FILENAME, "G_IO_ERROR_INVALID_FILENAME", "invalid-filename" },
 444         { G_IO_ERROR_TOO_MANY_LINKS, "G_IO_ERROR_TOO_MANY_LINKS", "too-many-links" },
 445         { G_IO_ERROR_NO_SPACE, "G_IO_ERROR_NO_SPACE", "no-space" },
 446         { G_IO_ERROR_INVALID_ARGUMENT, "G_IO_ERROR_INVALID_ARGUMENT", "invalid-argument" },
 447         { G_IO_ERROR_PERMISSION_DENIED, "G_IO_ERROR_PERMISSION_DENIED", "permission-denied" },
 448         { G_IO_ERROR_NOT_SUPPORTED, "G_IO_ERROR_NOT_SUPPORTED", "not-supported" },
 449         { G_IO_ERROR_NOT_MOUNTED, "G_IO_ERROR_NOT_MOUNTED", "not-mounted" },
 450         { G_IO_ERROR_ALREADY_MOUNTED, "G_IO_ERROR_ALREADY_MOUNTED", "already-mounted" },
 451         { G_IO_ERROR_CLOSED, "G_IO_ERROR_CLOSED", "closed" },
 452         { G_IO_ERROR_CANCELLED, "G_IO_ERROR_CANCELLED", "cancelled" },
 453         { G_IO_ERROR_PENDING, "G_IO_ERROR_PENDING", "pending" },
 454         { G_IO_ERROR_READ_ONLY, "G_IO_ERROR_READ_ONLY", "read-only" },
 455         { G_IO_ERROR_CANT_CREATE_BACKUP, "G_IO_ERROR_CANT_CREATE_BACKUP", "cant-create-backup" },
 456         { G_IO_ERROR_WRONG_ETAG, "G_IO_ERROR_WRONG_ETAG", "wrong-etag" },
 457         { G_IO_ERROR_TIMED_OUT, "G_IO_ERROR_TIMED_OUT", "timed-out" },
 458         { G_IO_ERROR_WOULD_RECURSE, "G_IO_ERROR_WOULD_RECURSE", "would-recurse" },
 459         { G_IO_ERROR_BUSY, "G_IO_ERROR_BUSY", "busy" },
 460         { G_IO_ERROR_WOULD_BLOCK, "G_IO_ERROR_WOULD_BLOCK", "would-block" },
 461         { G_IO_ERROR_HOST_NOT_FOUND, "G_IO_ERROR_HOST_NOT_FOUND", "host-not-found" },
 462         { G_IO_ERROR_WOULD_MERGE, "G_IO_ERROR_WOULD_MERGE", "would-merge" },
 463         { G_IO_ERROR_FAILED_HANDLED, "G_IO_ERROR_FAILED_HANDLED", "failed-handled" },
 464         { G_IO_ERROR_TOO_MANY_OPEN_FILES, "G_IO_ERROR_TOO_MANY_OPEN_FILES", "too-many-open-files" },
 465         { G_IO_ERROR_NOT_INITIALIZED, "G_IO_ERROR_NOT_INITIALIZED", "not-initialized" },
 466         { G_IO_ERROR_ADDRESS_IN_USE, "G_IO_ERROR_ADDRESS_IN_USE", "address-in-use" },
 467         { G_IO_ERROR_PARTIAL_INPUT, "G_IO_ERROR_PARTIAL_INPUT", "partial-input" },
 468         { G_IO_ERROR_INVALID_DATA, "G_IO_ERROR_INVALID_DATA", "invalid-data" },
 469         { G_IO_ERROR_DBUS_ERROR, "G_IO_ERROR_DBUS_ERROR", "dbus-error" },
 470         { G_IO_ERROR_HOST_UNREACHABLE, "G_IO_ERROR_HOST_UNREACHABLE", "host-unreachable" },
 471         { G_IO_ERROR_NETWORK_UNREACHABLE, "G_IO_ERROR_NETWORK_UNREACHABLE", "network-unreachable" },
 472         { G_IO_ERROR_CONNECTION_REFUSED, "G_IO_ERROR_CONNECTION_REFUSED", "connection-refused" },
 473         { G_IO_ERROR_PROXY_FAILED, "G_IO_ERROR_PROXY_FAILED", "proxy-failed" },
 474         { G_IO_ERROR_PROXY_AUTH_FAILED, "G_IO_ERROR_PROXY_AUTH_FAILED", "proxy-auth-failed" },
 475         { G_IO_ERROR_PROXY_NEED_AUTH, "G_IO_ERROR_PROXY_NEED_AUTH", "proxy-need-auth" },
 476         { G_IO_ERROR_PROXY_NOT_ALLOWED, "G_IO_ERROR_PROXY_NOT_ALLOWED", "proxy-not-allowed" },
 477         { 0, NULL, NULL }
 478       };
 479       GType g_define_type_id =
 480         g_enum_register_static (g_intern_static_string ("GIOErrorEnum"), values);
 481       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 482     }
 483
 484   return g_define_type_id__volatile;
 485 }
 486
 487 GType
 488 g_ask_password_flags_get_type (void)
 489 {
 490   static volatile gsize g_define_type_id__volatile = 0;
 491
 492   if (g_once_init_enter (&g_define_type_id__volatile))
 493     {
 494       static const GFlagsValue values[] = {
 495         { G_ASK_PASSWORD_NEED_PASSWORD, "G_ASK_PASSWORD_NEED_PASSWORD", "need-password" },
 496         { G_ASK_PASSWORD_NEED_USERNAME, "G_ASK_PASSWORD_NEED_USERNAME", "need-username" },
 497         { G_ASK_PASSWORD_NEED_DOMAIN, "G_ASK_PASSWORD_NEED_DOMAIN", "need-domain" },
 498         { G_ASK_PASSWORD_SAVING_SUPPORTED, "G_ASK_PASSWORD_SAVING_SUPPORTED", "saving-supported" },
 499         { G_ASK_PASSWORD_ANONYMOUS_SUPPORTED, "G_ASK_PASSWORD_ANONYMOUS_SUPPORTED", "anonymous-supported" },
 500         { 0, NULL, NULL }
 501       };
 502       GType g_define_type_id =
 503         g_flags_register_static (g_intern_static_string ("GAskPasswordFlags"), values);
 504       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 505     }
 506
 507   return g_define_type_id__volatile;
 508 }
 509
 510 GType
 511 g_password_save_get_type (void)
 512 {
 513   static volatile gsize g_define_type_id__volatile = 0;
 514
 515   if (g_once_init_enter (&g_define_type_id__volatile))
 516     {
 517       static const GEnumValue values[] = {
 518         { G_PASSWORD_SAVE_NEVER, "G_PASSWORD_SAVE_NEVER", "never" },
 519         { G_PASSWORD_SAVE_FOR_SESSION, "G_PASSWORD_SAVE_FOR_SESSION", "for-session" },
 520         { G_PASSWORD_SAVE_PERMANENTLY, "G_PASSWORD_SAVE_PERMANENTLY", "permanently" },
 521         { 0, NULL, NULL }
 522       };
 523       GType g_define_type_id =
 524         g_enum_register_static (g_intern_static_string ("GPasswordSave"), values);
 525       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 526     }
 527
 528   return g_define_type_id__volatile;
 529 }
 530
 531 GType
 532 g_mount_operation_result_get_type (void)
 533 {
 534   static volatile gsize g_define_type_id__volatile = 0;
 535
 536   if (g_once_init_enter (&g_define_type_id__volatile))
 537     {
 538       static const GEnumValue values[] = {
 539         { G_MOUNT_OPERATION_HANDLED, "G_MOUNT_OPERATION_HANDLED", "handled" },
 540         { G_MOUNT_OPERATION_ABORTED, "G_MOUNT_OPERATION_ABORTED", "aborted" },
 541         { G_MOUNT_OPERATION_UNHANDLED, "G_MOUNT_OPERATION_UNHANDLED", "unhandled" },
 542         { 0, NULL, NULL }
 543       };
 544       GType g_define_type_id =
 545         g_enum_register_static (g_intern_static_string ("GMountOperationResult"), values);
 546       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 547     }
 548
 549   return g_define_type_id__volatile;
 550 }
 551
 552 GType
 553 g_output_stream_splice_flags_get_type (void)
 554 {
 555   static volatile gsize g_define_type_id__volatile = 0;
 556
 557   if (g_once_init_enter (&g_define_type_id__volatile))
 558     {
 559       static const GFlagsValue values[] = {
 560         { G_OUTPUT_STREAM_SPLICE_NONE, "G_OUTPUT_STREAM_SPLICE_NONE", "none" },
 561         { G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE, "G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE", "close-source" },
 562         { G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, "G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET", "close-target" },
 563         { 0, NULL, NULL }
 564       };
 565       GType g_define_type_id =
 566         g_flags_register_static (g_intern_static_string ("GOutputStreamSpliceFlags"), values);
 567       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 568     }
 569
 570   return g_define_type_id__volatile;
 571 }
 572
 573 GType
 574 g_io_stream_splice_flags_get_type (void)
 575 {
 576   static volatile gsize g_define_type_id__volatile = 0;
 577
 578   if (g_once_init_enter (&g_define_type_id__volatile))
 579     {
 580       static const GFlagsValue values[] = {
 581         { G_IO_STREAM_SPLICE_NONE, "G_IO_STREAM_SPLICE_NONE", "none" },
 582         { G_IO_STREAM_SPLICE_CLOSE_STREAM1, "G_IO_STREAM_SPLICE_CLOSE_STREAM1", "close-stream1" },
 583         { G_IO_STREAM_SPLICE_CLOSE_STREAM2, "G_IO_STREAM_SPLICE_CLOSE_STREAM2", "close-stream2" },
 584         { G_IO_STREAM_SPLICE_WAIT_FOR_BOTH, "G_IO_STREAM_SPLICE_WAIT_FOR_BOTH", "wait-for-both" },
 585         { 0, NULL, NULL }
 586       };
 587       GType g_define_type_id =
 588         g_flags_register_static (g_intern_static_string ("GIOStreamSpliceFlags"), values);
 589       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 590     }
 591
 592   return g_define_type_id__volatile;
 593 }
 594
 595 GType
 596 g_emblem_origin_get_type (void)
 597 {
 598   static volatile gsize g_define_type_id__volatile = 0;
 599
 600   if (g_once_init_enter (&g_define_type_id__volatile))
 601     {
 602       static const GEnumValue values[] = {
 603         { G_EMBLEM_ORIGIN_UNKNOWN, "G_EMBLEM_ORIGIN_UNKNOWN", "unknown" },
 604         { G_EMBLEM_ORIGIN_DEVICE, "G_EMBLEM_ORIGIN_DEVICE", "device" },
 605         { G_EMBLEM_ORIGIN_LIVEMETADATA, "G_EMBLEM_ORIGIN_LIVEMETADATA", "livemetadata" },
 606         { G_EMBLEM_ORIGIN_TAG, "G_EMBLEM_ORIGIN_TAG", "tag" },
 607         { 0, NULL, NULL }
 608       };
 609       GType g_define_type_id =
 610         g_enum_register_static (g_intern_static_string ("GEmblemOrigin"), values);
 611       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 612     }
 613
 614   return g_define_type_id__volatile;
 615 }
 616
 617 GType
 618 g_resolver_error_get_type (void)
 619 {
 620   static volatile gsize g_define_type_id__volatile = 0;
 621
 622   if (g_once_init_enter (&g_define_type_id__volatile))
 623     {
 624       static const GEnumValue values[] = {
 625         { G_RESOLVER_ERROR_NOT_FOUND, "G_RESOLVER_ERROR_NOT_FOUND", "not-found" },
 626         { G_RESOLVER_ERROR_TEMPORARY_FAILURE, "G_RESOLVER_ERROR_TEMPORARY_FAILURE", "temporary-failure" },
 627         { G_RESOLVER_ERROR_INTERNAL, "G_RESOLVER_ERROR_INTERNAL", "internal" },
 628         { 0, NULL, NULL }
 629       };
 630       GType g_define_type_id =
 631         g_enum_register_static (g_intern_static_string ("GResolverError"), values);
 632       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 633     }
 634
 635   return g_define_type_id__volatile;
 636 }
 637
 638 GType
 639 g_resource_error_get_type (void)
 640 {
 641   static volatile gsize g_define_type_id__volatile = 0;
 642
 643   if (g_once_init_enter (&g_define_type_id__volatile))
 644     {
 645       static const GEnumValue values[] = {
 646         { G_RESOURCE_ERROR_NOT_FOUND, "G_RESOURCE_ERROR_NOT_FOUND", "not-found" },
 647         { G_RESOURCE_ERROR_INTERNAL, "G_RESOURCE_ERROR_INTERNAL", "internal" },
 648         { 0, NULL, NULL }
 649       };
 650       GType g_define_type_id =
 651         g_enum_register_static (g_intern_static_string ("GResourceError"), values);
 652       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 653     }
 654
 655   return g_define_type_id__volatile;
 656 }
 657
 658 GType
 659 g_resource_flags_get_type (void)
 660 {
 661   static volatile gsize g_define_type_id__volatile = 0;
 662
 663   if (g_once_init_enter (&g_define_type_id__volatile))
 664     {
 665       static const GFlagsValue values[] = {
 666         { G_RESOURCE_FLAGS_NONE, "G_RESOURCE_FLAGS_NONE", "none" },
 667         { G_RESOURCE_FLAGS_COMPRESSED, "G_RESOURCE_FLAGS_COMPRESSED", "compressed" },
 668         { 0, NULL, NULL }
 669       };
 670       GType g_define_type_id =
 671         g_flags_register_static (g_intern_static_string ("GResourceFlags"), values);
 672       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 673     }
 674
 675   return g_define_type_id__volatile;
 676 }
 677
 678 GType
 679 g_resource_lookup_flags_get_type (void)
 680 {
 681   static volatile gsize g_define_type_id__volatile = 0;
 682
 683   if (g_once_init_enter (&g_define_type_id__volatile))
 684     {
 685       static const GFlagsValue values[] = {
 686         { G_RESOURCE_LOOKUP_FLAGS_NONE, "G_RESOURCE_LOOKUP_FLAGS_NONE", "none" },
 687         { 0, NULL, NULL }
 688       };
 689       GType g_define_type_id =
 690         g_flags_register_static (g_intern_static_string ("GResourceLookupFlags"), values);
 691       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 692     }
 693
 694   return g_define_type_id__volatile;
 695 }
 696
 697 GType
 698 g_socket_family_get_type (void)
 699 {
 700   static volatile gsize g_define_type_id__volatile = 0;
 701
 702   if (g_once_init_enter (&g_define_type_id__volatile))
 703     {
 704       static const GEnumValue values[] = {
 705         { G_SOCKET_FAMILY_INVALID, "G_SOCKET_FAMILY_INVALID", "invalid" },
 706         { G_SOCKET_FAMILY_UNIX, "G_SOCKET_FAMILY_UNIX", "unix" },
 707         { G_SOCKET_FAMILY_IPV4, "G_SOCKET_FAMILY_IPV4", "ipv4" },
 708         { G_SOCKET_FAMILY_IPV6, "G_SOCKET_FAMILY_IPV6", "ipv6" },
 709         { 0, NULL, NULL }
 710       };
 711       GType g_define_type_id =
 712         g_enum_register_static (g_intern_static_string ("GSocketFamily"), values);
 713       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 714     }
 715
 716   return g_define_type_id__volatile;
 717 }
 718
 719 GType
 720 g_socket_type_get_type (void)
 721 {
 722   static volatile gsize g_define_type_id__volatile = 0;
 723
 724   if (g_once_init_enter (&g_define_type_id__volatile))
 725     {
 726       static const GEnumValue values[] = {
 727         { G_SOCKET_TYPE_INVALID, "G_SOCKET_TYPE_INVALID", "invalid" },
 728         { G_SOCKET_TYPE_STREAM, "G_SOCKET_TYPE_STREAM", "stream" },
 729         { G_SOCKET_TYPE_DATAGRAM, "G_SOCKET_TYPE_DATAGRAM", "datagram" },
 730         { G_SOCKET_TYPE_SEQPACKET, "G_SOCKET_TYPE_SEQPACKET", "seqpacket" },
 731         { 0, NULL, NULL }
 732       };
 733       GType g_define_type_id =
 734         g_enum_register_static (g_intern_static_string ("GSocketType"), values);
 735       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 736     }
 737
 738   return g_define_type_id__volatile;
 739 }
 740
 741 GType
 742 g_socket_msg_flags_get_type (void)
 743 {
 744   static volatile gsize g_define_type_id__volatile = 0;
 745
 746   if (g_once_init_enter (&g_define_type_id__volatile))
 747     {
 748       static const GFlagsValue values[] = {
 749         { G_SOCKET_MSG_NONE, "G_SOCKET_MSG_NONE", "none" },
 750         { G_SOCKET_MSG_OOB, "G_SOCKET_MSG_OOB", "oob" },
 751         { G_SOCKET_MSG_PEEK, "G_SOCKET_MSG_PEEK", "peek" },
 752         { G_SOCKET_MSG_DONTROUTE, "G_SOCKET_MSG_DONTROUTE", "dontroute" },
 753         { 0, NULL, NULL }
 754       };
 755       GType g_define_type_id =
 756         g_flags_register_static (g_intern_static_string ("GSocketMsgFlags"), values);
 757       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 758     }
 759
 760   return g_define_type_id__volatile;
 761 }
 762
 763 GType
 764 g_socket_protocol_get_type (void)
 765 {
 766   static volatile gsize g_define_type_id__volatile = 0;
 767
 768   if (g_once_init_enter (&g_define_type_id__volatile))
 769     {
 770       static const GEnumValue values[] = {
 771         { G_SOCKET_PROTOCOL_UNKNOWN, "G_SOCKET_PROTOCOL_UNKNOWN", "unknown" },
 772         { G_SOCKET_PROTOCOL_DEFAULT, "G_SOCKET_PROTOCOL_DEFAULT", "default" },
 773         { G_SOCKET_PROTOCOL_TCP, "G_SOCKET_PROTOCOL_TCP", "tcp" },
 774         { G_SOCKET_PROTOCOL_UDP, "G_SOCKET_PROTOCOL_UDP", "udp" },
 775         { G_SOCKET_PROTOCOL_SCTP, "G_SOCKET_PROTOCOL_SCTP", "sctp" },
 776         { 0, NULL, NULL }
 777       };
 778       GType g_define_type_id =
 779         g_enum_register_static (g_intern_static_string ("GSocketProtocol"), values);
 780       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 781     }
 782
 783   return g_define_type_id__volatile;
 784 }
 785
 786 GType
 787 g_zlib_compressor_format_get_type (void)
 788 {
 789   static volatile gsize g_define_type_id__volatile = 0;
 790
 791   if (g_once_init_enter (&g_define_type_id__volatile))
 792     {
 793       static const GEnumValue values[] = {
 794         { G_ZLIB_COMPRESSOR_FORMAT_ZLIB, "G_ZLIB_COMPRESSOR_FORMAT_ZLIB", "zlib" },
 795         { G_ZLIB_COMPRESSOR_FORMAT_GZIP, "G_ZLIB_COMPRESSOR_FORMAT_GZIP", "gzip" },
 796         { G_ZLIB_COMPRESSOR_FORMAT_RAW, "G_ZLIB_COMPRESSOR_FORMAT_RAW", "raw" },
 797         { 0, NULL, NULL }
 798       };
 799       GType g_define_type_id =
 800         g_enum_register_static (g_intern_static_string ("GZlibCompressorFormat"), values);
 801       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 802     }
 803
 804   return g_define_type_id__volatile;
 805 }
 806
 807 GType
 808 g_unix_socket_address_type_get_type (void)
 809 {
 810   static volatile gsize g_define_type_id__volatile = 0;
 811
 812   if (g_once_init_enter (&g_define_type_id__volatile))
 813     {
 814       static const GEnumValue values[] = {
 815         { G_UNIX_SOCKET_ADDRESS_INVALID, "G_UNIX_SOCKET_ADDRESS_INVALID", "invalid" },
 816         { G_UNIX_SOCKET_ADDRESS_ANONYMOUS, "G_UNIX_SOCKET_ADDRESS_ANONYMOUS", "anonymous" },
 817         { G_UNIX_SOCKET_ADDRESS_PATH, "G_UNIX_SOCKET_ADDRESS_PATH", "path" },
 818         { G_UNIX_SOCKET_ADDRESS_ABSTRACT, "G_UNIX_SOCKET_ADDRESS_ABSTRACT", "abstract" },
 819         { G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED, "G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED", "abstract-padded" },
 820         { 0, NULL, NULL }
 821       };
 822       GType g_define_type_id =
 823         g_enum_register_static (g_intern_static_string ("GUnixSocketAddressType"), values);
 824       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 825     }
 826
 827   return g_define_type_id__volatile;
 828 }
 829
 830 GType
 831 g_bus_type_get_type (void)
 832 {
 833   static volatile gsize g_define_type_id__volatile = 0;
 834
 835   if (g_once_init_enter (&g_define_type_id__volatile))
 836     {
 837       static const GEnumValue values[] = {
 838         { G_BUS_TYPE_STARTER, "G_BUS_TYPE_STARTER", "starter" },
 839         { G_BUS_TYPE_NONE, "G_BUS_TYPE_NONE", "none" },
 840         { G_BUS_TYPE_SYSTEM, "G_BUS_TYPE_SYSTEM", "system" },
 841         { G_BUS_TYPE_SESSION, "G_BUS_TYPE_SESSION", "session" },
 842         { 0, NULL, NULL }
 843       };
 844       GType g_define_type_id =
 845         g_enum_register_static (g_intern_static_string ("GBusType"), values);
 846       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 847     }
 848
 849   return g_define_type_id__volatile;
 850 }
 851
 852 GType
 853 g_bus_name_owner_flags_get_type (void)
 854 {
 855   static volatile gsize g_define_type_id__volatile = 0;
 856
 857   if (g_once_init_enter (&g_define_type_id__volatile))
 858     {
 859       static const GFlagsValue values[] = {
 860         { G_BUS_NAME_OWNER_FLAGS_NONE, "G_BUS_NAME_OWNER_FLAGS_NONE", "none" },
 861         { G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT, "G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT", "allow-replacement" },
 862         { G_BUS_NAME_OWNER_FLAGS_REPLACE, "G_BUS_NAME_OWNER_FLAGS_REPLACE", "replace" },
 863         { 0, NULL, NULL }
 864       };
 865       GType g_define_type_id =
 866         g_flags_register_static (g_intern_static_string ("GBusNameOwnerFlags"), values);
 867       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 868     }
 869
 870   return g_define_type_id__volatile;
 871 }
 872
 873 GType
 874 g_bus_name_watcher_flags_get_type (void)
 875 {
 876   static volatile gsize g_define_type_id__volatile = 0;
 877
 878   if (g_once_init_enter (&g_define_type_id__volatile))
 879     {
 880       static const GFlagsValue values[] = {
 881         { G_BUS_NAME_WATCHER_FLAGS_NONE, "G_BUS_NAME_WATCHER_FLAGS_NONE", "none" },
 882         { G_BUS_NAME_WATCHER_FLAGS_AUTO_START, "G_BUS_NAME_WATCHER_FLAGS_AUTO_START", "auto-start" },
 883         { 0, NULL, NULL }
 884       };
 885       GType g_define_type_id =
 886         g_flags_register_static (g_intern_static_string ("GBusNameWatcherFlags"), values);
 887       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 888     }
 889
 890   return g_define_type_id__volatile;
 891 }
 892
 893 GType
 894 g_dbus_proxy_flags_get_type (void)
 895 {
 896   static volatile gsize g_define_type_id__volatile = 0;
 897
 898   if (g_once_init_enter (&g_define_type_id__volatile))
 899     {
 900       static const GFlagsValue values[] = {
 901         { G_DBUS_PROXY_FLAGS_NONE, "G_DBUS_PROXY_FLAGS_NONE", "none" },
 902         { G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, "G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES", "do-not-load-properties" },
 903         { G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS, "G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS", "do-not-connect-signals" },
 904         { G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START, "G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START", "do-not-auto-start" },
 905         { G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES, "G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES", "get-invalidated-properties" },
 906         { 0, NULL, NULL }
 907       };
 908       GType g_define_type_id =
 909         g_flags_register_static (g_intern_static_string ("GDBusProxyFlags"), values);
 910       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 911     }
 912
 913   return g_define_type_id__volatile;
 914 }
 915
 916 GType
 917 g_dbus_error_get_type (void)
 918 {
 919   static volatile gsize g_define_type_id__volatile = 0;
 920
 921   if (g_once_init_enter (&g_define_type_id__volatile))
 922     {
 923       static const GEnumValue values[] = {
 924         { G_DBUS_ERROR_FAILED, "G_DBUS_ERROR_FAILED", "failed" },
 925         { G_DBUS_ERROR_NO_MEMORY, "G_DBUS_ERROR_NO_MEMORY", "no-memory" },
 926         { G_DBUS_ERROR_SERVICE_UNKNOWN, "G_DBUS_ERROR_SERVICE_UNKNOWN", "service-unknown" },
 927         { G_DBUS_ERROR_NAME_HAS_NO_OWNER, "G_DBUS_ERROR_NAME_HAS_NO_OWNER", "name-has-no-owner" },
 928         { G_DBUS_ERROR_NO_REPLY, "G_DBUS_ERROR_NO_REPLY", "no-reply" },
 929         { G_DBUS_ERROR_IO_ERROR, "G_DBUS_ERROR_IO_ERROR", "io-error" },
 930         { G_DBUS_ERROR_BAD_ADDRESS, "G_DBUS_ERROR_BAD_ADDRESS", "bad-address" },
 931         { G_DBUS_ERROR_NOT_SUPPORTED, "G_DBUS_ERROR_NOT_SUPPORTED", "not-supported" },
 932         { G_DBUS_ERROR_LIMITS_EXCEEDED, "G_DBUS_ERROR_LIMITS_EXCEEDED", "limits-exceeded" },
 933         { G_DBUS_ERROR_ACCESS_DENIED, "G_DBUS_ERROR_ACCESS_DENIED", "access-denied" },
 934         { G_DBUS_ERROR_AUTH_FAILED, "G_DBUS_ERROR_AUTH_FAILED", "auth-failed" },
 935         { G_DBUS_ERROR_NO_SERVER, "G_DBUS_ERROR_NO_SERVER", "no-server" },
 936         { G_DBUS_ERROR_TIMEOUT, "G_DBUS_ERROR_TIMEOUT", "timeout" },
 937         { G_DBUS_ERROR_NO_NETWORK, "G_DBUS_ERROR_NO_NETWORK", "no-network" },
 938         { G_DBUS_ERROR_ADDRESS_IN_USE, "G_DBUS_ERROR_ADDRESS_IN_USE", "address-in-use" },
 939         { G_DBUS_ERROR_DISCONNECTED, "G_DBUS_ERROR_DISCONNECTED", "disconnected" },
 940         { G_DBUS_ERROR_INVALID_ARGS, "G_DBUS_ERROR_INVALID_ARGS", "invalid-args" },
 941         { G_DBUS_ERROR_FILE_NOT_FOUND, "G_DBUS_ERROR_FILE_NOT_FOUND", "file-not-found" },
 942         { G_DBUS_ERROR_FILE_EXISTS, "G_DBUS_ERROR_FILE_EXISTS", "file-exists" },
 943         { G_DBUS_ERROR_UNKNOWN_METHOD, "G_DBUS_ERROR_UNKNOWN_METHOD", "unknown-method" },
 944         { G_DBUS_ERROR_TIMED_OUT, "G_DBUS_ERROR_TIMED_OUT", "timed-out" },
 945         { G_DBUS_ERROR_MATCH_RULE_NOT_FOUND, "G_DBUS_ERROR_MATCH_RULE_NOT_FOUND", "match-rule-not-found" },
 946         { G_DBUS_ERROR_MATCH_RULE_INVALID, "G_DBUS_ERROR_MATCH_RULE_INVALID", "match-rule-invalid" },
 947         { G_DBUS_ERROR_SPAWN_EXEC_FAILED, "G_DBUS_ERROR_SPAWN_EXEC_FAILED", "spawn-exec-failed" },
 948         { G_DBUS_ERROR_SPAWN_FORK_FAILED, "G_DBUS_ERROR_SPAWN_FORK_FAILED", "spawn-fork-failed" },
 949         { G_DBUS_ERROR_SPAWN_CHILD_EXITED, "G_DBUS_ERROR_SPAWN_CHILD_EXITED", "spawn-child-exited" },
 950         { G_DBUS_ERROR_SPAWN_CHILD_SIGNALED, "G_DBUS_ERROR_SPAWN_CHILD_SIGNALED", "spawn-child-signaled" },
 951         { G_DBUS_ERROR_SPAWN_FAILED, "G_DBUS_ERROR_SPAWN_FAILED", "spawn-failed" },
 952         { G_DBUS_ERROR_SPAWN_SETUP_FAILED, "G_DBUS_ERROR_SPAWN_SETUP_FAILED", "spawn-setup-failed" },
 953         { G_DBUS_ERROR_SPAWN_CONFIG_INVALID, "G_DBUS_ERROR_SPAWN_CONFIG_INVALID", "spawn-config-invalid" },
 954         { G_DBUS_ERROR_SPAWN_SERVICE_INVALID, "G_DBUS_ERROR_SPAWN_SERVICE_INVALID", "spawn-service-invalid" },
 955         { G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND, "G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND", "spawn-service-not-found" },
 956         { G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID, "G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID", "spawn-permissions-invalid" },
 957         { G_DBUS_ERROR_SPAWN_FILE_INVALID, "G_DBUS_ERROR_SPAWN_FILE_INVALID", "spawn-file-invalid" },
 958         { G_DBUS_ERROR_SPAWN_NO_MEMORY, "G_DBUS_ERROR_SPAWN_NO_MEMORY", "spawn-no-memory" },
 959         { G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN, "G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN", "unix-process-id-unknown" },
 960         { G_DBUS_ERROR_INVALID_SIGNATURE, "G_DBUS_ERROR_INVALID_SIGNATURE", "invalid-signature" },
 961         { G_DBUS_ERROR_INVALID_FILE_CONTENT, "G_DBUS_ERROR_INVALID_FILE_CONTENT", "invalid-file-content" },
 962         { G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN, "G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN", "selinux-security-context-unknown" },
 963         { G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN, "G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN", "adt-audit-data-unknown" },
 964         { G_DBUS_ERROR_OBJECT_PATH_IN_USE, "G_DBUS_ERROR_OBJECT_PATH_IN_USE", "object-path-in-use" },
 965         { 0, NULL, NULL }
 966       };
 967       GType g_define_type_id =
 968         g_enum_register_static (g_intern_static_string ("GDBusError"), values);
 969       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 970     }
 971
 972   return g_define_type_id__volatile;
 973 }
 974
 975 GType
 976 g_dbus_connection_flags_get_type (void)
 977 {
 978   static volatile gsize g_define_type_id__volatile = 0;
 979
 980   if (g_once_init_enter (&g_define_type_id__volatile))
 981     {
 982       static const GFlagsValue values[] = {
 983         { G_DBUS_CONNECTION_FLAGS_NONE, "G_DBUS_CONNECTION_FLAGS_NONE", "none" },
 984         { G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT", "authentication-client" },
 985         { G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER, "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER", "authentication-server" },
 986         { G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS, "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS", "authentication-allow-anonymous" },
 987         { G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION, "G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION", "message-bus-connection" },
 988         { G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING, "G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING", "delay-message-processing" },
 989         { 0, NULL, NULL }
 990       };
 991       GType g_define_type_id =
 992         g_flags_register_static (g_intern_static_string ("GDBusConnectionFlags"), values);
 993       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 994     }
 995
 996   return g_define_type_id__volatile;
 997 }
 998
 999 GType
1000 g_dbus_capability_flags_get_type (void)
1001 {
1002   static volatile gsize g_define_type_id__volatile = 0;
1003
1004   if (g_once_init_enter (&g_define_type_id__volatile))
1005     {
1006       static const GFlagsValue values[] = {
1007         { G_DBUS_CAPABILITY_FLAGS_NONE, "G_DBUS_CAPABILITY_FLAGS_NONE", "none" },
1008         { G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING, "G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING", "unix-fd-passing" },
1009         { 0, NULL, NULL }
1010       };
1011       GType g_define_type_id =
1012         g_flags_register_static (g_intern_static_string ("GDBusCapabilityFlags"), values);
1013       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1014     }
1015
1016   return g_define_type_id__volatile;
1017 }
1018
1019 GType
1020 g_dbus_call_flags_get_type (void)
1021 {
1022   static volatile gsize g_define_type_id__volatile = 0;
1023
1024   if (g_once_init_enter (&g_define_type_id__volatile))
1025     {
1026       static const GFlagsValue values[] = {
1027         { G_DBUS_CALL_FLAGS_NONE, "G_DBUS_CALL_FLAGS_NONE", "none" },
1028         { G_DBUS_CALL_FLAGS_NO_AUTO_START, "G_DBUS_CALL_FLAGS_NO_AUTO_START", "no-auto-start" },
1029         { 0, NULL, NULL }
1030       };
1031       GType g_define_type_id =
1032         g_flags_register_static (g_intern_static_string ("GDBusCallFlags"), values);
1033       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1034     }
1035
1036   return g_define_type_id__volatile;
1037 }
1038
1039 GType
1040 g_dbus_message_type_get_type (void)
1041 {
1042   static volatile gsize g_define_type_id__volatile = 0;
1043
1044   if (g_once_init_enter (&g_define_type_id__volatile))
1045     {
1046       static const GEnumValue values[] = {
1047         { G_DBUS_MESSAGE_TYPE_INVALID, "G_DBUS_MESSAGE_TYPE_INVALID", "invalid" },
1048         { G_DBUS_MESSAGE_TYPE_METHOD_CALL, "G_DBUS_MESSAGE_TYPE_METHOD_CALL", "method-call" },
1049         { G_DBUS_MESSAGE_TYPE_METHOD_RETURN, "G_DBUS_MESSAGE_TYPE_METHOD_RETURN", "method-return" },
1050         { G_DBUS_MESSAGE_TYPE_ERROR, "G_DBUS_MESSAGE_TYPE_ERROR", "error" },
1051         { G_DBUS_MESSAGE_TYPE_SIGNAL, "G_DBUS_MESSAGE_TYPE_SIGNAL", "signal" },
1052         { 0, NULL, NULL }
1053       };
1054       GType g_define_type_id =
1055         g_enum_register_static (g_intern_static_string ("GDBusMessageType"), values);
1056       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1057     }
1058
1059   return g_define_type_id__volatile;
1060 }
1061
1062 GType
1063 g_dbus_message_flags_get_type (void)
1064 {
1065   static volatile gsize g_define_type_id__volatile = 0;
1066
1067   if (g_once_init_enter (&g_define_type_id__volatile))
1068     {
1069       static const GFlagsValue values[] = {
1070         { G_DBUS_MESSAGE_FLAGS_NONE, "G_DBUS_MESSAGE_FLAGS_NONE", "none" },
1071         { G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED, "G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED", "no-reply-expected" },
1072         { G_DBUS_MESSAGE_FLAGS_NO_AUTO_START, "G_DBUS_MESSAGE_FLAGS_NO_AUTO_START", "no-auto-start" },
1073         { 0, NULL, NULL }
1074       };
1075       GType g_define_type_id =
1076         g_flags_register_static (g_intern_static_string ("GDBusMessageFlags"), values);
1077       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1078     }
1079
1080   return g_define_type_id__volatile;
1081 }
1082
1083 GType
1084 g_dbus_message_header_field_get_type (void)
1085 {
1086   static volatile gsize g_define_type_id__volatile = 0;
1087
1088   if (g_once_init_enter (&g_define_type_id__volatile))
1089     {
1090       static const GEnumValue values[] = {
1091         { G_DBUS_MESSAGE_HEADER_FIELD_INVALID, "G_DBUS_MESSAGE_HEADER_FIELD_INVALID", "invalid" },
1092         { G_DBUS_MESSAGE_HEADER_FIELD_PATH, "G_DBUS_MESSAGE_HEADER_FIELD_PATH", "path" },
1093         { G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE, "G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE", "interface" },
1094         { G_DBUS_MESSAGE_HEADER_FIELD_MEMBER, "G_DBUS_MESSAGE_HEADER_FIELD_MEMBER", "member" },
1095         { G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME, "G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME", "error-name" },
1096         { G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL, "G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL", "reply-serial" },
1097         { G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION, "G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION", "destination" },
1098         { G_DBUS_MESSAGE_HEADER_FIELD_SENDER, "G_DBUS_MESSAGE_HEADER_FIELD_SENDER", "sender" },
1099         { G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE, "G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE", "signature" },
1100         { G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS, "G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS", "num-unix-fds" },
1101         { 0, NULL, NULL }
1102       };
1103       GType g_define_type_id =
1104         g_enum_register_static (g_intern_static_string ("GDBusMessageHeaderField"), values);
1105       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1106     }
1107
1108   return g_define_type_id__volatile;
1109 }
1110
1111 GType
1112 g_dbus_property_info_flags_get_type (void)
1113 {
1114   static volatile gsize g_define_type_id__volatile = 0;
1115
1116   if (g_once_init_enter (&g_define_type_id__volatile))
1117     {
1118       static const GFlagsValue values[] = {
1119         { G_DBUS_PROPERTY_INFO_FLAGS_NONE, "G_DBUS_PROPERTY_INFO_FLAGS_NONE", "none" },
1120         { G_DBUS_PROPERTY_INFO_FLAGS_READABLE, "G_DBUS_PROPERTY_INFO_FLAGS_READABLE", "readable" },
1121         { G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE, "G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE", "writable" },
1122         { 0, NULL, NULL }
1123       };
1124       GType g_define_type_id =
1125         g_flags_register_static (g_intern_static_string ("GDBusPropertyInfoFlags"), values);
1126       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1127     }
1128
1129   return g_define_type_id__volatile;
1130 }
1131
1132 GType
1133 g_dbus_subtree_flags_get_type (void)
1134 {
1135   static volatile gsize g_define_type_id__volatile = 0;
1136
1137   if (g_once_init_enter (&g_define_type_id__volatile))
1138     {
1139       static const GFlagsValue values[] = {
1140         { G_DBUS_SUBTREE_FLAGS_NONE, "G_DBUS_SUBTREE_FLAGS_NONE", "none" },
1141         { G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES, "G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES", "dispatch-to-unenumerated-nodes" },
1142         { 0, NULL, NULL }
1143       };
1144       GType g_define_type_id =
1145         g_flags_register_static (g_intern_static_string ("GDBusSubtreeFlags"), values);
1146       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1147     }
1148
1149   return g_define_type_id__volatile;
1150 }
1151
1152 GType
1153 g_dbus_server_flags_get_type (void)
1154 {
1155   static volatile gsize g_define_type_id__volatile = 0;
1156
1157   if (g_once_init_enter (&g_define_type_id__volatile))
1158     {
1159       static const GFlagsValue values[] = {
1160         { G_DBUS_SERVER_FLAGS_NONE, "G_DBUS_SERVER_FLAGS_NONE", "none" },
1161         { G_DBUS_SERVER_FLAGS_RUN_IN_THREAD, "G_DBUS_SERVER_FLAGS_RUN_IN_THREAD", "run-in-thread" },
1162         { G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS, "G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS", "authentication-allow-anonymous" },
1163         { 0, NULL, NULL }
1164       };
1165       GType g_define_type_id =
1166         g_flags_register_static (g_intern_static_string ("GDBusServerFlags"), values);
1167       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1168     }
1169
1170   return g_define_type_id__volatile;
1171 }
1172
1173 GType
1174 g_dbus_signal_flags_get_type (void)
1175 {
1176   static volatile gsize g_define_type_id__volatile = 0;
1177
1178   if (g_once_init_enter (&g_define_type_id__volatile))
1179     {
1180       static const GFlagsValue values[] = {
1181         { G_DBUS_SIGNAL_FLAGS_NONE, "G_DBUS_SIGNAL_FLAGS_NONE", "none" },
1182         { G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE, "G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE", "no-match-rule" },
1183         { 0, NULL, NULL }
1184       };
1185       GType g_define_type_id =
1186         g_flags_register_static (g_intern_static_string ("GDBusSignalFlags"), values);
1187       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1188     }
1189
1190   return g_define_type_id__volatile;
1191 }
1192
1193 GType
1194 g_dbus_send_message_flags_get_type (void)
1195 {
1196   static volatile gsize g_define_type_id__volatile = 0;
1197
1198   if (g_once_init_enter (&g_define_type_id__volatile))
1199     {
1200       static const GFlagsValue values[] = {
1201         { G_DBUS_SEND_MESSAGE_FLAGS_NONE, "G_DBUS_SEND_MESSAGE_FLAGS_NONE", "none" },
1202         { G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL, "G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL", "preserve-serial" },
1203         { 0, NULL, NULL }
1204       };
1205       GType g_define_type_id =
1206         g_flags_register_static (g_intern_static_string ("GDBusSendMessageFlags"), values);
1207       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1208     }
1209
1210   return g_define_type_id__volatile;
1211 }
1212
1213 GType
1214 g_credentials_type_get_type (void)
1215 {
1216   static volatile gsize g_define_type_id__volatile = 0;
1217
1218   if (g_once_init_enter (&g_define_type_id__volatile))
1219     {
1220       static const GEnumValue values[] = {
1221         { G_CREDENTIALS_TYPE_INVALID, "G_CREDENTIALS_TYPE_INVALID", "invalid" },
1222         { G_CREDENTIALS_TYPE_LINUX_UCRED, "G_CREDENTIALS_TYPE_LINUX_UCRED", "linux-ucred" },
1223         { G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED, "G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED", "freebsd-cmsgcred" },
1224         { G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED, "G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED", "openbsd-sockpeercred" },
1225         { 0, NULL, NULL }
1226       };
1227       GType g_define_type_id =
1228         g_enum_register_static (g_intern_static_string ("GCredentialsType"), values);
1229       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1230     }
1231
1232   return g_define_type_id__volatile;
1233 }
1234
1235 GType
1236 g_dbus_message_byte_order_get_type (void)
1237 {
1238   static volatile gsize g_define_type_id__volatile = 0;
1239
1240   if (g_once_init_enter (&g_define_type_id__volatile))
1241     {
1242       static const GEnumValue values[] = {
1243         { G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN, "G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN", "big-endian" },
1244         { G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN, "G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN", "little-endian" },
1245         { 0, NULL, NULL }
1246       };
1247       GType g_define_type_id =
1248         g_enum_register_static (g_intern_static_string ("GDBusMessageByteOrder"), values);
1249       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1250     }
1251
1252   return g_define_type_id__volatile;
1253 }
1254
1255 GType
1256 g_application_flags_get_type (void)
1257 {
1258   static volatile gsize g_define_type_id__volatile = 0;
1259
1260   if (g_once_init_enter (&g_define_type_id__volatile))
1261     {
1262       static const GFlagsValue values[] = {
1263         { G_APPLICATION_FLAGS_NONE, "G_APPLICATION_FLAGS_NONE", "flags-none" },
1264         { G_APPLICATION_IS_SERVICE, "G_APPLICATION_IS_SERVICE", "is-service" },
1265         { G_APPLICATION_IS_LAUNCHER, "G_APPLICATION_IS_LAUNCHER", "is-launcher" },
1266         { G_APPLICATION_HANDLES_OPEN, "G_APPLICATION_HANDLES_OPEN", "handles-open" },
1267         { G_APPLICATION_HANDLES_COMMAND_LINE, "G_APPLICATION_HANDLES_COMMAND_LINE", "handles-command-line" },
1268         { G_APPLICATION_SEND_ENVIRONMENT, "G_APPLICATION_SEND_ENVIRONMENT", "send-environment" },
1269         { G_APPLICATION_NON_UNIQUE, "G_APPLICATION_NON_UNIQUE", "non-unique" },
1270         { 0, NULL, NULL }
1271       };
1272       GType g_define_type_id =
1273         g_flags_register_static (g_intern_static_string ("GApplicationFlags"), values);
1274       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1275     }
1276
1277   return g_define_type_id__volatile;
1278 }
1279
1280 GType
1281 g_tls_error_get_type (void)
1282 {
1283   static volatile gsize g_define_type_id__volatile = 0;
1284
1285   if (g_once_init_enter (&g_define_type_id__volatile))
1286     {
1287       static const GEnumValue values[] = {
1288         { G_TLS_ERROR_UNAVAILABLE, "G_TLS_ERROR_UNAVAILABLE", "unavailable" },
1289         { G_TLS_ERROR_MISC, "G_TLS_ERROR_MISC", "misc" },
1290         { G_TLS_ERROR_BAD_CERTIFICATE, "G_TLS_ERROR_BAD_CERTIFICATE", "bad-certificate" },
1291         { G_TLS_ERROR_NOT_TLS, "G_TLS_ERROR_NOT_TLS", "not-tls" },
1292         { G_TLS_ERROR_HANDSHAKE, "G_TLS_ERROR_HANDSHAKE", "handshake" },
1293         { G_TLS_ERROR_CERTIFICATE_REQUIRED, "G_TLS_ERROR_CERTIFICATE_REQUIRED", "certificate-required" },
1294         { G_TLS_ERROR_EOF, "G_TLS_ERROR_EOF", "eof" },
1295         { 0, NULL, NULL }
1296       };
1297       GType g_define_type_id =
1298         g_enum_register_static (g_intern_static_string ("GTlsError"), values);
1299       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1300     }
1301
1302   return g_define_type_id__volatile;
1303 }
1304
1305 GType
1306 g_tls_certificate_flags_get_type (void)
1307 {
1308   static volatile gsize g_define_type_id__volatile = 0;
1309
1310   if (g_once_init_enter (&g_define_type_id__volatile))
1311     {
1312       static const GFlagsValue values[] = {
1313         { G_TLS_CERTIFICATE_UNKNOWN_CA, "G_TLS_CERTIFICATE_UNKNOWN_CA", "unknown-ca" },
1314         { G_TLS_CERTIFICATE_BAD_IDENTITY, "G_TLS_CERTIFICATE_BAD_IDENTITY", "bad-identity" },
1315         { G_TLS_CERTIFICATE_NOT_ACTIVATED, "G_TLS_CERTIFICATE_NOT_ACTIVATED", "not-activated" },
1316         { G_TLS_CERTIFICATE_EXPIRED, "G_TLS_CERTIFICATE_EXPIRED", "expired" },
1317         { G_TLS_CERTIFICATE_REVOKED, "G_TLS_CERTIFICATE_REVOKED", "revoked" },
1318         { G_TLS_CERTIFICATE_INSECURE, "G_TLS_CERTIFICATE_INSECURE", "insecure" },
1319         { G_TLS_CERTIFICATE_GENERIC_ERROR, "G_TLS_CERTIFICATE_GENERIC_ERROR", "generic-error" },
1320         { G_TLS_CERTIFICATE_VALIDATE_ALL, "G_TLS_CERTIFICATE_VALIDATE_ALL", "validate-all" },
1321         { 0, NULL, NULL }
1322       };
1323       GType g_define_type_id =
1324         g_flags_register_static (g_intern_static_string ("GTlsCertificateFlags"), values);
1325       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1326     }
1327
1328   return g_define_type_id__volatile;
1329 }
1330
1331 GType
1332 g_tls_authentication_mode_get_type (void)
1333 {
1334   static volatile gsize g_define_type_id__volatile = 0;
1335
1336   if (g_once_init_enter (&g_define_type_id__volatile))
1337     {
1338       static const GEnumValue values[] = {
1339         { G_TLS_AUTHENTICATION_NONE, "G_TLS_AUTHENTICATION_NONE", "none" },
1340         { G_TLS_AUTHENTICATION_REQUESTED, "G_TLS_AUTHENTICATION_REQUESTED", "requested" },
1341         { G_TLS_AUTHENTICATION_REQUIRED, "G_TLS_AUTHENTICATION_REQUIRED", "required" },
1342         { 0, NULL, NULL }
1343       };
1344       GType g_define_type_id =
1345         g_enum_register_static (g_intern_static_string ("GTlsAuthenticationMode"), values);
1346       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1347     }
1348
1349   return g_define_type_id__volatile;
1350 }
1351
1352 GType
1353 g_tls_rehandshake_mode_get_type (void)
1354 {
1355   static volatile gsize g_define_type_id__volatile = 0;
1356
1357   if (g_once_init_enter (&g_define_type_id__volatile))
1358     {
1359       static const GEnumValue values[] = {
1360         { G_TLS_REHANDSHAKE_NEVER, "G_TLS_REHANDSHAKE_NEVER", "never" },
1361         { G_TLS_REHANDSHAKE_SAFELY, "G_TLS_REHANDSHAKE_SAFELY", "safely" },
1362         { G_TLS_REHANDSHAKE_UNSAFELY, "G_TLS_REHANDSHAKE_UNSAFELY", "unsafely" },
1363         { 0, NULL, NULL }
1364       };
1365       GType g_define_type_id =
1366         g_enum_register_static (g_intern_static_string ("GTlsRehandshakeMode"), values);
1367       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1368     }
1369
1370   return g_define_type_id__volatile;
1371 }
1372
1373 GType
1374 g_tls_password_flags_get_type (void)
1375 {
1376   static volatile gsize g_define_type_id__volatile = 0;
1377
1378   if (g_once_init_enter (&g_define_type_id__volatile))
1379     {
1380       static const GFlagsValue values[] = {
1381         { G_TLS_PASSWORD_NONE, "G_TLS_PASSWORD_NONE", "none" },
1382         { G_TLS_PASSWORD_RETRY, "G_TLS_PASSWORD_RETRY", "retry" },
1383         { G_TLS_PASSWORD_MANY_TRIES, "G_TLS_PASSWORD_MANY_TRIES", "many-tries" },
1384         { G_TLS_PASSWORD_FINAL_TRY, "G_TLS_PASSWORD_FINAL_TRY", "final-try" },
1385         { 0, NULL, NULL }
1386       };
1387       GType g_define_type_id =
1388         g_flags_register_static (g_intern_static_string ("GTlsPasswordFlags"), values);
1389       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1390     }
1391
1392   return g_define_type_id__volatile;
1393 }
1394
1395 GType
1396 g_tls_interaction_result_get_type (void)
1397 {
1398   static volatile gsize g_define_type_id__volatile = 0;
1399
1400   if (g_once_init_enter (&g_define_type_id__volatile))
1401     {
1402       static const GEnumValue values[] = {
1403         { G_TLS_INTERACTION_UNHANDLED, "G_TLS_INTERACTION_UNHANDLED", "unhandled" },
1404         { G_TLS_INTERACTION_HANDLED, "G_TLS_INTERACTION_HANDLED", "handled" },
1405         { G_TLS_INTERACTION_FAILED, "G_TLS_INTERACTION_FAILED", "failed" },
1406         { 0, NULL, NULL }
1407       };
1408       GType g_define_type_id =
1409         g_enum_register_static (g_intern_static_string ("GTlsInteractionResult"), values);
1410       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1411     }
1412
1413   return g_define_type_id__volatile;
1414 }
1415
1416 GType
1417 g_dbus_interface_skeleton_flags_get_type (void)
1418 {
1419   static volatile gsize g_define_type_id__volatile = 0;
1420
1421   if (g_once_init_enter (&g_define_type_id__volatile))
1422     {
1423       static const GFlagsValue values[] = {
1424         { G_DBUS_INTERFACE_SKELETON_FLAGS_NONE, "G_DBUS_INTERFACE_SKELETON_FLAGS_NONE", "none" },
1425         { G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD, "G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD", "handle-method-invocations-in-thread" },
1426         { 0, NULL, NULL }
1427       };
1428       GType g_define_type_id =
1429         g_flags_register_static (g_intern_static_string ("GDBusInterfaceSkeletonFlags"), values);
1430       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1431     }
1432
1433   return g_define_type_id__volatile;
1434 }
1435
1436 GType
1437 g_dbus_object_manager_client_flags_get_type (void)
1438 {
1439   static volatile gsize g_define_type_id__volatile = 0;
1440
1441   if (g_once_init_enter (&g_define_type_id__volatile))
1442     {
1443       static const GFlagsValue values[] = {
1444         { G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE, "G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE", "none" },
1445         { G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START, "G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START", "do-not-auto-start" },
1446         { 0, NULL, NULL }
1447       };
1448       GType g_define_type_id =
1449         g_flags_register_static (g_intern_static_string ("GDBusObjectManagerClientFlags"), values);
1450       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1451     }
1452
1453   return g_define_type_id__volatile;
1454 }
1455
1456 GType
1457 g_tls_database_verify_flags_get_type (void)
1458 {
1459   static volatile gsize g_define_type_id__volatile = 0;
1460
1461   if (g_once_init_enter (&g_define_type_id__volatile))
1462     {
1463       static const GFlagsValue values[] = {
1464         { G_TLS_DATABASE_VERIFY_NONE, "G_TLS_DATABASE_VERIFY_NONE", "none" },
1465         { 0, NULL, NULL }
1466       };
1467       GType g_define_type_id =
1468         g_flags_register_static (g_intern_static_string ("GTlsDatabaseVerifyFlags"), values);
1469       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1470     }
1471
1472   return g_define_type_id__volatile;
1473 }
1474
1475 GType
1476 g_tls_database_lookup_flags_get_type (void)
1477 {
1478   static volatile gsize g_define_type_id__volatile = 0;
1479
1480   if (g_once_init_enter (&g_define_type_id__volatile))
1481     {
1482       static const GEnumValue values[] = {
1483         { G_TLS_DATABASE_LOOKUP_NONE, "G_TLS_DATABASE_LOOKUP_NONE", "none" },
1484         { G_TLS_DATABASE_LOOKUP_KEYPAIR, "G_TLS_DATABASE_LOOKUP_KEYPAIR", "keypair" },
1485         { 0, NULL, NULL }
1486       };
1487       GType g_define_type_id =
1488         g_enum_register_static (g_intern_static_string ("GTlsDatabaseLookupFlags"), values);
1489       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1490     }
1491
1492   return g_define_type_id__volatile;
1493 }
1494
1495 GType
1496 g_io_module_scope_flags_get_type (void)
1497 {
1498   static volatile gsize g_define_type_id__volatile = 0;
1499
1500   if (g_once_init_enter (&g_define_type_id__volatile))
1501     {
1502       static const GEnumValue values[] = {
1503         { G_IO_MODULE_SCOPE_NONE, "G_IO_MODULE_SCOPE_NONE", "none" },
1504         { G_IO_MODULE_SCOPE_BLOCK_DUPLICATES, "G_IO_MODULE_SCOPE_BLOCK_DUPLICATES", "block-duplicates" },
1505         { 0, NULL, NULL }
1506       };
1507       GType g_define_type_id =
1508         g_enum_register_static (g_intern_static_string ("GIOModuleScopeFlags"), values);
1509       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1510     }
1511
1512   return g_define_type_id__volatile;
1513 }
1514
1515 GType
1516 g_socket_client_event_get_type (void)
1517 {
1518   static volatile gsize g_define_type_id__volatile = 0;
1519
1520   if (g_once_init_enter (&g_define_type_id__volatile))
1521     {
1522       static const GEnumValue values[] = {
1523         { G_SOCKET_CLIENT_RESOLVING, "G_SOCKET_CLIENT_RESOLVING", "resolving" },
1524         { G_SOCKET_CLIENT_RESOLVED, "G_SOCKET_CLIENT_RESOLVED", "resolved" },
1525         { G_SOCKET_CLIENT_CONNECTING, "G_SOCKET_CLIENT_CONNECTING", "connecting" },
1526         { G_SOCKET_CLIENT_CONNECTED, "G_SOCKET_CLIENT_CONNECTED", "connected" },
1527         { G_SOCKET_CLIENT_PROXY_NEGOTIATING, "G_SOCKET_CLIENT_PROXY_NEGOTIATING", "proxy-negotiating" },
1528         { G_SOCKET_CLIENT_PROXY_NEGOTIATED, "G_SOCKET_CLIENT_PROXY_NEGOTIATED", "proxy-negotiated" },
1529         { G_SOCKET_CLIENT_TLS_HANDSHAKING, "G_SOCKET_CLIENT_TLS_HANDSHAKING", "tls-handshaking" },
1530         { G_SOCKET_CLIENT_TLS_HANDSHAKED, "G_SOCKET_CLIENT_TLS_HANDSHAKED", "tls-handshaked" },
1531         { G_SOCKET_CLIENT_COMPLETE, "G_SOCKET_CLIENT_COMPLETE", "complete" },
1532         { 0, NULL, NULL }
1533       };
1534       GType g_define_type_id =
1535         g_enum_register_static (g_intern_static_string ("GSocketClientEvent"), values);
1536       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1537     }
1538
1539   return g_define_type_id__volatile;
1540 }
1541
1542 /* enumerations from "gsettings.h" */
1543 GType
1544 g_settings_bind_flags_get_type (void)
1545 {
1546   static volatile gsize g_define_type_id__volatile = 0;
1547
1548   if (g_once_init_enter (&g_define_type_id__volatile))
1549     {
1550       static const GFlagsValue values[] = {
1551         { G_SETTINGS_BIND_DEFAULT, "G_SETTINGS_BIND_DEFAULT", "default" },
1552         { G_SETTINGS_BIND_GET, "G_SETTINGS_BIND_GET", "get" },
1553         { G_SETTINGS_BIND_SET, "G_SETTINGS_BIND_SET", "set" },
1554         { G_SETTINGS_BIND_NO_SENSITIVITY, "G_SETTINGS_BIND_NO_SENSITIVITY", "no-sensitivity" },
1555         { G_SETTINGS_BIND_GET_NO_CHANGES, "G_SETTINGS_BIND_GET_NO_CHANGES", "get-no-changes" },
1556         { G_SETTINGS_BIND_INVERT_BOOLEAN, "G_SETTINGS_BIND_INVERT_BOOLEAN", "invert-boolean" },
1557         { 0, NULL, NULL }
1558       };
1559       GType g_define_type_id =
1560         g_flags_register_static (g_intern_static_string ("GSettingsBindFlags"), values);
1561       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
1562     }
1563
1564   return g_define_type_id__volatile;
1565 }
1566
1567
1568 /* Generated data ends here */
1569