{ This is an autogenerated unit using gobject introspection (gir2pascal). Do not Edit. }
unit GLib2;

{$MODE OBJFPC}{$H+}

{$PACKRECORDS C}
{$MODESWITCH DUPLICATELOCALS+}

{$LINKLIB libgobject-2.0.so.0}
{$LINKLIB libglib-2.0.so.0}
interface
uses
  CTypes;

const
  GLib2_library = 'libgobject-2.0.so.0';

  ASCII_DTOSTR_BUF_SIZE = 39;
  BIG_ENDIAN = 4321;
  CAN_INLINE = 1;
  CSET_A_2_Z_UPPER = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  CSET_DIGITS = '0123456789';
  CSET_a_2_z_lower = 'abcdefghijklmnopqrstuvwxyz';
  DATALIST_FLAGS_MASK = 3;
  DATE_BAD_DAY = 0;
  DATE_BAD_JULIAN = 0;
  DATE_BAD_YEAR = 0;
  DIR_SEPARATOR = 92;
  DIR_SEPARATOR_S = '\';
  E = 2.718282;
  GINT16_FORMAT = 'hi';
  GINT16_MODIFIER = 'h';
  GINT32_FORMAT = 'i';
  GINT32_MODIFIER = '';
  GINT64_FORMAT = 'li';
  GINT64_MODIFIER = 'l';
  GINTPTR_FORMAT = 'li';
  GINTPTR_MODIFIER = 'l';
  GNUC_FUNCTION = '';
  GNUC_PRETTY_FUNCTION = '';
  GSIZE_FORMAT = 'lu';
  GSIZE_MODIFIER = 'l';
  GSSIZE_FORMAT = 'li';
  GUINT16_FORMAT = 'hu';
  GUINT32_FORMAT = 'u';
  GUINT64_FORMAT = 'lu';
  GUINTPTR_FORMAT = 'lu';
  HAVE_GINT64 = 1;
  HAVE_GNUC_VARARGS = 1;
  HAVE_GNUC_VISIBILITY = 1;
  HAVE_GROWING_STACK = 1;
  HAVE_INLINE = 1;
  HAVE_ISO_VARARGS = 1;
  HAVE___INLINE = 1;
  HAVE___INLINE__ = 1;
  HOOK_FLAG_USER_SHIFT = 4;
  IEEE754_DOUBLE_BIAS = 1023;
  IEEE754_FLOAT_BIAS = 127;
  KEY_FILE_DESKTOP_GROUP = 'Desktop Entry';
  KEY_FILE_DESKTOP_KEY_CATEGORIES = 'Categories';
  KEY_FILE_DESKTOP_KEY_COMMENT = 'Comment';
  KEY_FILE_DESKTOP_KEY_EXEC = 'Exec';
  KEY_FILE_DESKTOP_KEY_GENERIC_NAME = 'GenericName';
  KEY_FILE_DESKTOP_KEY_HIDDEN = 'Hidden';
  KEY_FILE_DESKTOP_KEY_ICON = 'Icon';
  KEY_FILE_DESKTOP_KEY_MIME_TYPE = 'MimeType';
  KEY_FILE_DESKTOP_KEY_NAME = 'Name';
  KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN = 'NotShowIn';
  KEY_FILE_DESKTOP_KEY_NO_DISPLAY = 'NoDisplay';
  KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN = 'OnlyShowIn';
  KEY_FILE_DESKTOP_KEY_PATH = 'Path';
  KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY = 'StartupNotify';
  KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS = 'StartupWMClass';
  KEY_FILE_DESKTOP_KEY_TERMINAL = 'Terminal';
  KEY_FILE_DESKTOP_KEY_TRY_EXEC = 'TryExec';
  KEY_FILE_DESKTOP_KEY_TYPE = 'Type';
  KEY_FILE_DESKTOP_KEY_URL = 'URL';
  KEY_FILE_DESKTOP_KEY_VERSION = 'Version';
  KEY_FILE_DESKTOP_TYPE_APPLICATION = 'Application';
  KEY_FILE_DESKTOP_TYPE_DIRECTORY = 'Directory';
  KEY_FILE_DESKTOP_TYPE_LINK = 'Link';
  LITTLE_ENDIAN = 1234;
  LN10 = 2.302585;
  LN2 = 0.693147;
  LOG_2_BASE_10 = 0.301030;
  LOG_DOMAIN = 0;
  LOG_FATAL_MASK = 0;
  LOG_LEVEL_USER_SHIFT = 8;
  MAJOR_VERSION = 2;
  MAXINT16 = 32767;
  MAXINT32 = 2147483647;
  MAXINT64 = 9223372036854775807;
  MAXINT8 = 127;
  MAXUINT16 = 65535;
  MAXUINT32 = 4294967295;
  MAXUINT64 = 18446744073709551615;
  MAXUINT8 = 255;
  MICRO_VERSION = 4;
  MININT16 = 32768;
  MININT32 = 2147483648;
  MININT64 = -9223372036854775808;
  MININT8 = 128;
  MINOR_VERSION = 36;
  MODULE_SUFFIX = 'so';
  OPTION_REMAINING = '';
  PDP_ENDIAN = 3412;
  PI = 3.141593;
  PI_2 = 1.570796;
  PI_4 = 0.785398;
  POLLFD_FORMAT = '%#I64x';
  PRIORITY_DEFAULT = 0;
  PRIORITY_DEFAULT_IDLE = 200;
  PRIORITY_HIGH = -100;
  PRIORITY_HIGH_IDLE = 100;
  PRIORITY_LOW = 300;
  SEARCHPATH_SEPARATOR = 59;
  SEARCHPATH_SEPARATOR_S = ';';
  SIZEOF_LONG = 8;
  SIZEOF_SIZE_T = 8;
  SIZEOF_VOID_P = 8;
  SQRT2 = 1.414214;
  STR_DELIMITERS = '_-|> <.';
  SYSDEF_AF_INET = 2;
  SYSDEF_AF_INET6 = 10;
  SYSDEF_AF_UNIX = 1;
  SYSDEF_MSG_DONTROUTE = 4;
  SYSDEF_MSG_OOB = 1;
  SYSDEF_MSG_PEEK = 2;
  TIME_SPAN_DAY = 86400000000;
  TIME_SPAN_HOUR = 3600000000;
  TIME_SPAN_MILLISECOND = 1000;
  TIME_SPAN_MINUTE = 60000000;
  TIME_SPAN_SECOND = 1000000;
  UNICHAR_MAX_DECOMPOSITION_LENGTH = 18;
  URI_RESERVED_CHARS_GENERIC_DELIMITERS = ':/?#[]@';
  URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS = '!$&''()*+,;=';
  USEC_PER_SEC = 1000000;
  VA_COPY_AS_ARRAY = 1;
  VERSION_MIN_REQUIRED = 2;
  WIN32_MSG_HANDLE = 19981206;

type
  TGAsciiType = Integer;
const
  { GAsciiType }
  G_ASCII_ALNUM: TGAsciiType = 1;
  G_ASCII_ALPHA: TGAsciiType = 2;
  G_ASCII_CNTRL: TGAsciiType = 4;
  G_ASCII_DIGIT: TGAsciiType = 8;
  G_ASCII_GRAPH: TGAsciiType = 16;
  G_ASCII_LOWER: TGAsciiType = 32;
  G_ASCII_PRINT: TGAsciiType = 64;
  G_ASCII_PUNCT: TGAsciiType = 128;
  G_ASCII_SPACE: TGAsciiType = 256;
  G_ASCII_UPPER: TGAsciiType = 512;
  G_ASCII_XDIGIT: TGAsciiType = 1024;

type
  TGBookmarkFileError = Integer;
const
  { GBookmarkFileError }
  G_BOOKMARK_FILE_ERROR_INVALID_URI: TGBookmarkFileError = 0;
  G_BOOKMARK_FILE_ERROR_INVALID_VALUE: TGBookmarkFileError = 1;
  G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED: TGBookmarkFileError = 2;
  G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND: TGBookmarkFileError = 3;
  G_BOOKMARK_FILE_ERROR_READ: TGBookmarkFileError = 4;
  G_BOOKMARK_FILE_ERROR_UNKNOWN_ENCODING: TGBookmarkFileError = 5;
  G_BOOKMARK_FILE_ERROR_WRITE: TGBookmarkFileError = 6;
  G_BOOKMARK_FILE_ERROR_FILE_NOT_FOUND: TGBookmarkFileError = 7;

type
  TGChecksumType = Integer;
const
  { GChecksumType }
  G_CHECKSUM_MD5: TGChecksumType = 0;
  G_CHECKSUM_SHA1: TGChecksumType = 1;
  G_CHECKSUM_SHA256: TGChecksumType = 2;
  G_CHECKSUM_SHA512: TGChecksumType = 3;

type
  TGConvertError = Integer;
const
  { GConvertError }
  G_CONVERT_ERROR_NO_CONVERSION: TGConvertError = 0;
  G_CONVERT_ERROR_ILLEGAL_SEQUENCE: TGConvertError = 1;
  G_CONVERT_ERROR_FAILED: TGConvertError = 2;
  G_CONVERT_ERROR_PARTIAL_INPUT: TGConvertError = 3;
  G_CONVERT_ERROR_BAD_URI: TGConvertError = 4;
  G_CONVERT_ERROR_NOT_ABSOLUTE_PATH: TGConvertError = 5;

type
  TGDateMonth = Integer;
const
  { GDateMonth }
  G_DATE_BAD_MONTH: TGDateMonth = 0;
  G_DATE_JANUARY: TGDateMonth = 1;
  G_DATE_FEBRUARY: TGDateMonth = 2;
  G_DATE_MARCH: TGDateMonth = 3;
  G_DATE_APRIL: TGDateMonth = 4;
  G_DATE_MAY: TGDateMonth = 5;
  G_DATE_JUNE: TGDateMonth = 6;
  G_DATE_JULY: TGDateMonth = 7;
  G_DATE_AUGUST: TGDateMonth = 8;
  G_DATE_SEPTEMBER: TGDateMonth = 9;
  G_DATE_OCTOBER: TGDateMonth = 10;
  G_DATE_NOVEMBER: TGDateMonth = 11;
  G_DATE_DECEMBER: TGDateMonth = 12;

type
  TGDateWeekday = Integer;
const
  { GDateWeekday }
  G_DATE_BAD_WEEKDAY: TGDateWeekday = 0;
  G_DATE_MONDAY: TGDateWeekday = 1;
  G_DATE_TUESDAY: TGDateWeekday = 2;
  G_DATE_WEDNESDAY: TGDateWeekday = 3;
  G_DATE_THURSDAY: TGDateWeekday = 4;
  G_DATE_FRIDAY: TGDateWeekday = 5;
  G_DATE_SATURDAY: TGDateWeekday = 6;
  G_DATE_SUNDAY: TGDateWeekday = 7;

type
  TGDateDMY = Integer;
const
  { GDateDMY }
  G_DATE_DAY: TGDateDMY = 0;
  G_DATE_MONTH: TGDateDMY = 1;
  G_DATE_YEAR: TGDateDMY = 2;

type
  TGTimeType = Integer;
const
  { GTimeType }
  G_TIME_TYPE_STANDARD: TGTimeType = 0;
  G_TIME_TYPE_DAYLIGHT: TGTimeType = 1;
  G_TIME_TYPE_UNIVERSAL: TGTimeType = 2;

type
  TGErrorType = Integer;
const
  { GErrorType }
  G_ERR_UNKNOWN: TGErrorType = 0;
  G_ERR_UNEXP_EOF: TGErrorType = 1;
  G_ERR_UNEXP_EOF_IN_STRING: TGErrorType = 2;
  G_ERR_UNEXP_EOF_IN_COMMENT: TGErrorType = 3;
  G_ERR_NON_DIGIT_IN_CONST: TGErrorType = 4;
  G_ERR_DIGIT_RADIX: TGErrorType = 5;
  G_ERR_FLOAT_RADIX: TGErrorType = 6;
  G_ERR_FLOAT_MALFORMED: TGErrorType = 7;

type
  TGFileError = Integer;
const
  { GFileError }
  G_FILE_ERROR_EXIST: TGFileError = 0;
  G_FILE_ERROR_ISDIR: TGFileError = 1;
  G_FILE_ERROR_ACCES: TGFileError = 2;
  G_FILE_ERROR_NAMETOOLONG: TGFileError = 3;
  G_FILE_ERROR_NOENT: TGFileError = 4;
  G_FILE_ERROR_NOTDIR: TGFileError = 5;
  G_FILE_ERROR_NXIO: TGFileError = 6;
  G_FILE_ERROR_NODEV: TGFileError = 7;
  G_FILE_ERROR_ROFS: TGFileError = 8;
  G_FILE_ERROR_TXTBSY: TGFileError = 9;
  G_FILE_ERROR_FAULT: TGFileError = 10;
  G_FILE_ERROR_LOOP: TGFileError = 11;
  G_FILE_ERROR_NOSPC: TGFileError = 12;
  G_FILE_ERROR_NOMEM: TGFileError = 13;
  G_FILE_ERROR_MFILE: TGFileError = 14;
  G_FILE_ERROR_NFILE: TGFileError = 15;
  G_FILE_ERROR_BADF: TGFileError = 16;
  G_FILE_ERROR_INVAL: TGFileError = 17;
  G_FILE_ERROR_PIPE: TGFileError = 18;
  G_FILE_ERROR_AGAIN: TGFileError = 19;
  G_FILE_ERROR_INTR: TGFileError = 20;
  G_FILE_ERROR_IO: TGFileError = 21;
  G_FILE_ERROR_PERM: TGFileError = 22;
  G_FILE_ERROR_NOSYS: TGFileError = 23;
  G_FILE_ERROR_FAILED: TGFileError = 24;

type
  TGFileTest = Integer;
const
  { GFileTest }
  G_FILE_TEST_IS_REGULAR: TGFileTest = 1;
  G_FILE_TEST_IS_SYMLINK: TGFileTest = 2;
  G_FILE_TEST_IS_DIR: TGFileTest = 4;
  G_FILE_TEST_IS_EXECUTABLE: TGFileTest = 8;
  G_FILE_TEST_EXISTS: TGFileTest = 16;

type
  TGFormatSizeFlags = Integer;
const
  { GFormatSizeFlags }
  G_FORMAT_SIZE_DEFAULT: TGFormatSizeFlags = 0;
  G_FORMAT_SIZE_LONG_FORMAT: TGFormatSizeFlags = 1;
  G_FORMAT_SIZE_IEC_UNITS: TGFormatSizeFlags = 2;

type
  TGHookFlagMask = Integer;
const
  { GHookFlagMask }
  G_HOOK_FLAG_ACTIVE: TGHookFlagMask = 1;
  G_HOOK_FLAG_IN_CALL: TGHookFlagMask = 2;
  G_HOOK_FLAG_MASK: TGHookFlagMask = 15;

type
  TGSeekType = Integer;
const
  { GSeekType }
  G_SEEK_CUR: TGSeekType = 0;
  G_SEEK_SET: TGSeekType = 1;
  G_SEEK_END: TGSeekType = 2;

type
  TGIOCondition = Integer;
const
  { GIOCondition }
  G_IO_IN: TGIOCondition = 1;
  G_IO_OUT: TGIOCondition = 4;
  G_IO_PRI: TGIOCondition = 2;
  G_IO_ERR: TGIOCondition = 8;
  G_IO_HUP: TGIOCondition = 16;
  G_IO_NVAL: TGIOCondition = 32;

type
  TGIOFlags = Integer;
const
  { GIOFlags }
  G_IO_FLAG_APPEND: TGIOFlags = 1;
  G_IO_FLAG_NONBLOCK: TGIOFlags = 2;
  G_IO_FLAG_IS_READABLE: TGIOFlags = 4;
  G_IO_FLAG_IS_WRITABLE: TGIOFlags = 8;
  G_IO_FLAG_IS_WRITEABLE: TGIOFlags = 8;
  G_IO_FLAG_IS_SEEKABLE: TGIOFlags = 16;
  G_IO_FLAG_MASK: TGIOFlags = 31;
  G_IO_FLAG_GET_MASK: TGIOFlags = 31;
  G_IO_FLAG_SET_MASK: TGIOFlags = 3;

type
  TGIOStatus = Integer;
const
  { GIOStatus }
  G_IO_STATUS_ERROR: TGIOStatus = 0;
  G_IO_STATUS_NORMAL: TGIOStatus = 1;
  G_IO_STATUS_EOF: TGIOStatus = 2;
  G_IO_STATUS_AGAIN: TGIOStatus = 3;

type
  TGIOError = Integer;
const
  { GIOError }
  G_IO_ERROR_NONE: TGIOError = 0;
  G_IO_ERROR_AGAIN: TGIOError = 1;
  G_IO_ERROR_INVAL: TGIOError = 2;
  G_IO_ERROR_UNKNOWN: TGIOError = 3;

type
  TGIOChannelError = Integer;
const
  { GIOChannelError }
  G_IO_CHANNEL_ERROR_FBIG: TGIOChannelError = 0;
  G_IO_CHANNEL_ERROR_INVAL: TGIOChannelError = 1;
  G_IO_CHANNEL_ERROR_IO: TGIOChannelError = 2;
  G_IO_CHANNEL_ERROR_ISDIR: TGIOChannelError = 3;
  G_IO_CHANNEL_ERROR_NOSPC: TGIOChannelError = 4;
  G_IO_CHANNEL_ERROR_NXIO: TGIOChannelError = 5;
  G_IO_CHANNEL_ERROR_OVERFLOW: TGIOChannelError = 6;
  G_IO_CHANNEL_ERROR_PIPE: TGIOChannelError = 7;
  G_IO_CHANNEL_ERROR_FAILED: TGIOChannelError = 8;

type
  TGKeyFileFlags = Integer;
const
  { GKeyFileFlags }
  G_KEY_FILE_NONE: TGKeyFileFlags = 0;
  G_KEY_FILE_KEEP_COMMENTS: TGKeyFileFlags = 1;
  G_KEY_FILE_KEEP_TRANSLATIONS: TGKeyFileFlags = 2;

type
  TGKeyFileError = Integer;
const
  { GKeyFileError }
  G_KEY_FILE_ERROR_UNKNOWN_ENCODING: TGKeyFileError = 0;
  G_KEY_FILE_ERROR_PARSE: TGKeyFileError = 1;
  G_KEY_FILE_ERROR_NOT_FOUND: TGKeyFileError = 2;
  G_KEY_FILE_ERROR_KEY_NOT_FOUND: TGKeyFileError = 3;
  G_KEY_FILE_ERROR_GROUP_NOT_FOUND: TGKeyFileError = 4;
  G_KEY_FILE_ERROR_INVALID_VALUE: TGKeyFileError = 5;

type
  TGLogLevelFlags = Integer;
const
  { GLogLevelFlags }
  G_LOG_FLAG_RECURSION: TGLogLevelFlags = 1;
  G_LOG_FLAG_FATAL: TGLogLevelFlags = 2;
  G_LOG_LEVEL_ERROR: TGLogLevelFlags = 4;
  G_LOG_LEVEL_CRITICAL: TGLogLevelFlags = 8;
  G_LOG_LEVEL_WARNING: TGLogLevelFlags = 16;
  G_LOG_LEVEL_MESSAGE: TGLogLevelFlags = 32;
  G_LOG_LEVEL_INFO: TGLogLevelFlags = 64;
  G_LOG_LEVEL_DEBUG: TGLogLevelFlags = 128;
  G_LOG_LEVEL_MASK: TGLogLevelFlags = -4;

type
  TGMarkupCollectType = Integer;
const
  { GMarkupCollectType }
  G_MARKUP_COLLECT_INVALID: TGMarkupCollectType = 0;
  G_MARKUP_COLLECT_STRING: TGMarkupCollectType = 1;
  G_MARKUP_COLLECT_STRDUP: TGMarkupCollectType = 2;
  G_MARKUP_COLLECT_BOOLEAN: TGMarkupCollectType = 3;
  G_MARKUP_COLLECT_TRISTATE: TGMarkupCollectType = 4;
  G_MARKUP_COLLECT_OPTIONAL: TGMarkupCollectType = 65536;

type
  TGMarkupError = Integer;
const
  { GMarkupError }
  G_MARKUP_ERROR_BAD_UTF8: TGMarkupError = 0;
  G_MARKUP_ERROR_EMPTY: TGMarkupError = 1;
  G_MARKUP_ERROR_PARSE: TGMarkupError = 2;
  G_MARKUP_ERROR_UNKNOWN_ELEMENT: TGMarkupError = 3;
  G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE: TGMarkupError = 4;
  G_MARKUP_ERROR_INVALID_CONTENT: TGMarkupError = 5;
  G_MARKUP_ERROR_MISSING_ATTRIBUTE: TGMarkupError = 6;

type
  TGMarkupParseFlags = Integer;
const
  { GMarkupParseFlags }
  G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG: TGMarkupParseFlags = 1;
  G_MARKUP_TREAT_CDATA_AS_TEXT: TGMarkupParseFlags = 2;
  G_MARKUP_PREFIX_ERROR_POSITION: TGMarkupParseFlags = 4;

type
  TGRegexCompileFlags = Integer;
const
  { GRegexCompileFlags }
  G_REGEX_CASELESS: TGRegexCompileFlags = 1;
  G_REGEX_MULTILINE: TGRegexCompileFlags = 2;
  G_REGEX_DOTALL: TGRegexCompileFlags = 4;
  G_REGEX_EXTENDED: TGRegexCompileFlags = 8;
  G_REGEX_ANCHORED: TGRegexCompileFlags = 16;
  G_REGEX_DOLLAR_ENDONLY: TGRegexCompileFlags = 32;
  G_REGEX_UNGREEDY: TGRegexCompileFlags = 512;
  G_REGEX_RAW: TGRegexCompileFlags = 2048;
  G_REGEX_NO_AUTO_CAPTURE: TGRegexCompileFlags = 4096;
  G_REGEX_OPTIMIZE: TGRegexCompileFlags = 8192;
  G_REGEX_FIRSTLINE: TGRegexCompileFlags = 262144;
  G_REGEX_DUPNAMES: TGRegexCompileFlags = 524288;
  G_REGEX_NEWLINE_CR: TGRegexCompileFlags = 1048576;
  G_REGEX_NEWLINE_LF: TGRegexCompileFlags = 2097152;
  G_REGEX_NEWLINE_CRLF: TGRegexCompileFlags = 3145728;
  G_REGEX_NEWLINE_ANYCRLF: TGRegexCompileFlags = 5242880;
  G_REGEX_BSR_ANYCRLF: TGRegexCompileFlags = 8388608;
  G_REGEX_JAVASCRIPT_COMPAT: TGRegexCompileFlags = 33554432;

type
  TGRegexMatchFlags = Integer;
const
  { GRegexMatchFlags }
  G_REGEX_MATCH_ANCHORED: TGRegexMatchFlags = 16;
  G_REGEX_MATCH_NOTBOL: TGRegexMatchFlags = 128;
  G_REGEX_MATCH_NOTEOL: TGRegexMatchFlags = 256;
  G_REGEX_MATCH_NOTEMPTY: TGRegexMatchFlags = 1024;
  G_REGEX_MATCH_PARTIAL: TGRegexMatchFlags = 32768;
  G_REGEX_MATCH_NEWLINE_CR: TGRegexMatchFlags = 1048576;
  G_REGEX_MATCH_NEWLINE_LF: TGRegexMatchFlags = 2097152;
  G_REGEX_MATCH_NEWLINE_CRLF: TGRegexMatchFlags = 3145728;
  G_REGEX_MATCH_NEWLINE_ANY: TGRegexMatchFlags = 4194304;
  G_REGEX_MATCH_NEWLINE_ANYCRLF: TGRegexMatchFlags = 5242880;
  G_REGEX_MATCH_BSR_ANYCRLF: TGRegexMatchFlags = 8388608;
  G_REGEX_MATCH_BSR_ANY: TGRegexMatchFlags = 16777216;
  G_REGEX_MATCH_PARTIAL_SOFT: TGRegexMatchFlags = 32768;
  G_REGEX_MATCH_PARTIAL_HARD: TGRegexMatchFlags = 134217728;
  G_REGEX_MATCH_NOTEMPTY_ATSTART: TGRegexMatchFlags = 268435456;

type
  TGTraverseFlags = Integer;
const
  { GTraverseFlags }
  G_TRAVERSE_LEAVES: TGTraverseFlags = 1;
  G_TRAVERSE_NON_LEAVES: TGTraverseFlags = 2;
  G_TRAVERSE_ALL: TGTraverseFlags = 3;
  G_TRAVERSE_MASK: TGTraverseFlags = 3;
  G_TRAVERSE_LEAFS: TGTraverseFlags = 1;
  G_TRAVERSE_NON_LEAFS: TGTraverseFlags = 2;

type
  TGTraverseType = Integer;
const
  { GTraverseType }
  G_IN_ORDER: TGTraverseType = 0;
  G_PRE_ORDER: TGTraverseType = 1;
  G_POST_ORDER: TGTraverseType = 2;
  G_LEVEL_ORDER: TGTraverseType = 3;

type
  TGNormalizeMode = Integer;
const
  { GNormalizeMode }
  G_NORMALIZE_DEFAULT: TGNormalizeMode = 0;
  G_NORMALIZE_NFD: TGNormalizeMode = 0;
  G_NORMALIZE_DEFAULT_COMPOSE: TGNormalizeMode = 1;
  G_NORMALIZE_NFC: TGNormalizeMode = 1;
  G_NORMALIZE_ALL: TGNormalizeMode = 2;
  G_NORMALIZE_NFKD: TGNormalizeMode = 2;
  G_NORMALIZE_ALL_COMPOSE: TGNormalizeMode = 3;
  G_NORMALIZE_NFKC: TGNormalizeMode = 3;

type
  TGOnceStatus = Integer;
const
  { GOnceStatus }
  G_ONCE_STATUS_NOTCALLED: TGOnceStatus = 0;
  G_ONCE_STATUS_PROGRESS: TGOnceStatus = 1;
  G_ONCE_STATUS_READY: TGOnceStatus = 2;

type
  TGOptionArg = Integer;
const
  { GOptionArg }
  G_OPTION_ARG_NONE: TGOptionArg = 0;
  G_OPTION_ARG_STRING: TGOptionArg = 1;
  G_OPTION_ARG_INT: TGOptionArg = 2;
  G_OPTION_ARG_CALLBACK: TGOptionArg = 3;
  G_OPTION_ARG_FILENAME: TGOptionArg = 4;
  G_OPTION_ARG_STRING_ARRAY: TGOptionArg = 5;
  G_OPTION_ARG_FILENAME_ARRAY: TGOptionArg = 6;
  G_OPTION_ARG_DOUBLE: TGOptionArg = 7;
  G_OPTION_ARG_INT64: TGOptionArg = 8;

type
  TGOptionError = Integer;
const
  { GOptionError }
  G_OPTION_ERROR_UNKNOWN_OPTION: TGOptionError = 0;
  G_OPTION_ERROR_BAD_VALUE: TGOptionError = 1;
  G_OPTION_ERROR_FAILED: TGOptionError = 2;

type
  TGOptionFlags = Integer;
const
  { GOptionFlags }
  G_OPTION_FLAG_HIDDEN: TGOptionFlags = 1;
  G_OPTION_FLAG_IN_MAIN: TGOptionFlags = 2;
  G_OPTION_FLAG_REVERSE: TGOptionFlags = 4;
  G_OPTION_FLAG_NO_ARG: TGOptionFlags = 8;
  G_OPTION_FLAG_FILENAME: TGOptionFlags = 16;
  G_OPTION_FLAG_OPTIONAL_ARG: TGOptionFlags = 32;
  G_OPTION_FLAG_NOALIAS: TGOptionFlags = 64;

type
  TGRegexError = Integer;
const
  { GRegexError }
  G_REGEX_ERROR_COMPILE: TGRegexError = 0;
  G_REGEX_ERROR_OPTIMIZE: TGRegexError = 1;
  G_REGEX_ERROR_REPLACE: TGRegexError = 2;
  G_REGEX_ERROR_MATCH: TGRegexError = 3;
  G_REGEX_ERROR_INTERNAL: TGRegexError = 4;
  G_REGEX_ERROR_STRAY_BACKSLASH: TGRegexError = 101;
  G_REGEX_ERROR_MISSING_CONTROL_CHAR: TGRegexError = 102;
  G_REGEX_ERROR_UNRECOGNIZED_ESCAPE: TGRegexError = 103;
  G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER: TGRegexError = 104;
  G_REGEX_ERROR_QUANTIFIER_TOO_BIG: TGRegexError = 105;
  G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS: TGRegexError = 106;
  G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS: TGRegexError = 107;
  G_REGEX_ERROR_RANGE_OUT_OF_ORDER: TGRegexError = 108;
  G_REGEX_ERROR_NOTHING_TO_REPEAT: TGRegexError = 109;
  G_REGEX_ERROR_UNRECOGNIZED_CHARACTER: TGRegexError = 112;
  G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS: TGRegexError = 113;
  G_REGEX_ERROR_UNMATCHED_PARENTHESIS: TGRegexError = 114;
  G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE: TGRegexError = 115;
  G_REGEX_ERROR_UNTERMINATED_COMMENT: TGRegexError = 118;
  G_REGEX_ERROR_EXPRESSION_TOO_LARGE: TGRegexError = 120;
  G_REGEX_ERROR_MEMORY_ERROR: TGRegexError = 121;
  G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND: TGRegexError = 125;
  G_REGEX_ERROR_MALFORMED_CONDITION: TGRegexError = 126;
  G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES: TGRegexError = 127;
  G_REGEX_ERROR_ASSERTION_EXPECTED: TGRegexError = 128;
  G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME: TGRegexError = 130;
  G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED: TGRegexError = 131;
  G_REGEX_ERROR_HEX_CODE_TOO_LARGE: TGRegexError = 134;
  G_REGEX_ERROR_INVALID_CONDITION: TGRegexError = 135;
  G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND: TGRegexError = 136;
  G_REGEX_ERROR_INFINITE_LOOP: TGRegexError = 140;
  G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR: TGRegexError = 142;
  G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME: TGRegexError = 143;
  G_REGEX_ERROR_MALFORMED_PROPERTY: TGRegexError = 146;
  G_REGEX_ERROR_UNKNOWN_PROPERTY: TGRegexError = 147;
  G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG: TGRegexError = 148;
  G_REGEX_ERROR_TOO_MANY_SUBPATTERNS: TGRegexError = 149;
  G_REGEX_ERROR_INVALID_OCTAL_VALUE: TGRegexError = 151;
  G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE: TGRegexError = 154;
  G_REGEX_ERROR_DEFINE_REPETION: TGRegexError = 155;
  G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS: TGRegexError = 156;
  G_REGEX_ERROR_MISSING_BACK_REFERENCE: TGRegexError = 157;
  G_REGEX_ERROR_INVALID_RELATIVE_REFERENCE: TGRegexError = 158;
  G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN: TGRegexError = 159;
  G_REGEX_ERROR_UNKNOWN_BACKTRACKING_CONTROL_VERB: TGRegexError = 160;
  G_REGEX_ERROR_NUMBER_TOO_BIG: TGRegexError = 161;
  G_REGEX_ERROR_MISSING_SUBPATTERN_NAME: TGRegexError = 162;
  G_REGEX_ERROR_MISSING_DIGIT: TGRegexError = 163;
  G_REGEX_ERROR_INVALID_DATA_CHARACTER: TGRegexError = 164;
  G_REGEX_ERROR_EXTRA_SUBPATTERN_NAME: TGRegexError = 165;
  G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED: TGRegexError = 166;
  G_REGEX_ERROR_INVALID_CONTROL_CHAR: TGRegexError = 168;
  G_REGEX_ERROR_MISSING_NAME: TGRegexError = 169;
  G_REGEX_ERROR_NOT_SUPPORTED_IN_CLASS: TGRegexError = 171;
  G_REGEX_ERROR_TOO_MANY_FORWARD_REFERENCES: TGRegexError = 172;
  G_REGEX_ERROR_NAME_TOO_LONG: TGRegexError = 175;
  G_REGEX_ERROR_CHARACTER_VALUE_TOO_LARGE: TGRegexError = 176;

type
  TGTokenType = Integer;
const
  { GTokenType }
  G_TOKEN_EOF: TGTokenType = 0;
  G_TOKEN_LEFT_PAREN: TGTokenType = 40;
  G_TOKEN_RIGHT_PAREN: TGTokenType = 41;
  G_TOKEN_LEFT_CURLY: TGTokenType = 123;
  G_TOKEN_RIGHT_CURLY: TGTokenType = 125;
  G_TOKEN_LEFT_BRACE: TGTokenType = 91;
  G_TOKEN_RIGHT_BRACE: TGTokenType = 93;
  G_TOKEN_EQUAL_SIGN: TGTokenType = 61;
  G_TOKEN_COMMA: TGTokenType = 44;
  G_TOKEN_NONE: TGTokenType = 256;
  G_TOKEN_ERROR: TGTokenType = 257;
  G_TOKEN_CHAR: TGTokenType = 258;
  G_TOKEN_BINARY: TGTokenType = 259;
  G_TOKEN_OCTAL: TGTokenType = 260;
  G_TOKEN_INT: TGTokenType = 261;
  G_TOKEN_HEX: TGTokenType = 262;
  G_TOKEN_FLOAT: TGTokenType = 263;
  G_TOKEN_STRING: TGTokenType = 264;
  G_TOKEN_SYMBOL: TGTokenType = 265;
  G_TOKEN_IDENTIFIER: TGTokenType = 266;
  G_TOKEN_IDENTIFIER_NULL: TGTokenType = 267;
  G_TOKEN_COMMENT_SINGLE: TGTokenType = 268;
  G_TOKEN_COMMENT_MULTI: TGTokenType = 269;

type
  TGShellError = Integer;
const
  { GShellError }
  G_SHELL_ERROR_BAD_QUOTING: TGShellError = 0;
  G_SHELL_ERROR_EMPTY_STRING: TGShellError = 1;
  G_SHELL_ERROR_FAILED: TGShellError = 2;

type
  TGSliceConfig = Integer;
const
  { GSliceConfig }
  G_SLICE_CONFIG_ALWAYS_MALLOC: TGSliceConfig = 1;
  G_SLICE_CONFIG_BYPASS_MAGAZINES: TGSliceConfig = 2;
  G_SLICE_CONFIG_WORKING_SET_MSECS: TGSliceConfig = 3;
  G_SLICE_CONFIG_COLOR_INCREMENT: TGSliceConfig = 4;
  G_SLICE_CONFIG_CHUNK_SIZES: TGSliceConfig = 5;
  G_SLICE_CONFIG_CONTENTION_COUNTER: TGSliceConfig = 6;

type
  TGSpawnError = Integer;
const
  { GSpawnError }
  G_SPAWN_ERROR_FORK: TGSpawnError = 0;
  G_SPAWN_ERROR_READ: TGSpawnError = 1;
  G_SPAWN_ERROR_CHDIR: TGSpawnError = 2;
  G_SPAWN_ERROR_ACCES: TGSpawnError = 3;
  G_SPAWN_ERROR_PERM: TGSpawnError = 4;
  G_SPAWN_ERROR_TOO_BIG: TGSpawnError = 5;
  G_SPAWN_ERROR_2BIG: TGSpawnError = 5;
  G_SPAWN_ERROR_NOEXEC: TGSpawnError = 6;
  G_SPAWN_ERROR_NAMETOOLONG: TGSpawnError = 7;
  G_SPAWN_ERROR_NOENT: TGSpawnError = 8;
  G_SPAWN_ERROR_NOMEM: TGSpawnError = 9;
  G_SPAWN_ERROR_NOTDIR: TGSpawnError = 10;
  G_SPAWN_ERROR_LOOP: TGSpawnError = 11;
  G_SPAWN_ERROR_TXTBUSY: TGSpawnError = 12;
  G_SPAWN_ERROR_IO: TGSpawnError = 13;
  G_SPAWN_ERROR_NFILE: TGSpawnError = 14;
  G_SPAWN_ERROR_MFILE: TGSpawnError = 15;
  G_SPAWN_ERROR_INVAL: TGSpawnError = 16;
  G_SPAWN_ERROR_ISDIR: TGSpawnError = 17;
  G_SPAWN_ERROR_LIBBAD: TGSpawnError = 18;
  G_SPAWN_ERROR_FAILED: TGSpawnError = 19;

type
  TGSpawnFlags = Integer;
const
  { GSpawnFlags }
  G_SPAWN_LEAVE_DESCRIPTORS_OPEN: TGSpawnFlags = 1;
  G_SPAWN_DO_NOT_REAP_CHILD: TGSpawnFlags = 2;
  G_SPAWN_SEARCH_PATH: TGSpawnFlags = 4;
  G_SPAWN_STDOUT_TO_DEV_NULL: TGSpawnFlags = 8;
  G_SPAWN_STDERR_TO_DEV_NULL: TGSpawnFlags = 16;
  G_SPAWN_CHILD_INHERITS_STDIN: TGSpawnFlags = 32;
  G_SPAWN_FILE_AND_ARGV_ZERO: TGSpawnFlags = 64;
  G_SPAWN_SEARCH_PATH_FROM_ENVP: TGSpawnFlags = 128;

type
  TGTestLogType = Integer;
const
  { GTestLogType }
  G_TEST_LOG_NONE: TGTestLogType = 0;
  G_TEST_LOG_ERROR: TGTestLogType = 1;
  G_TEST_LOG_START_BINARY: TGTestLogType = 2;
  G_TEST_LOG_LIST_CASE: TGTestLogType = 3;
  G_TEST_LOG_SKIP_CASE: TGTestLogType = 4;
  G_TEST_LOG_START_CASE: TGTestLogType = 5;
  G_TEST_LOG_STOP_CASE: TGTestLogType = 6;
  G_TEST_LOG_MIN_RESULT: TGTestLogType = 7;
  G_TEST_LOG_MAX_RESULT: TGTestLogType = 8;
  G_TEST_LOG_MESSAGE: TGTestLogType = 9;

type
  TGTestTrapFlags = Integer;
const
  { GTestTrapFlags }
  G_TEST_TRAP_SILENCE_STDOUT: TGTestTrapFlags = 128;
  G_TEST_TRAP_SILENCE_STDERR: TGTestTrapFlags = 256;
  G_TEST_TRAP_INHERIT_STDIN: TGTestTrapFlags = 512;

type
  TGThreadError = Integer;
const
  { GThreadError }
  G_THREAD_ERROR_AGAIN: TGThreadError = 0;

type
  TGUnicodeBreakType = Integer;
const
  { GUnicodeBreakType }
  G_UNICODE_BREAK_MANDATORY: TGUnicodeBreakType = 0;
  G_UNICODE_BREAK_CARRIAGE_RETURN: TGUnicodeBreakType = 1;
  G_UNICODE_BREAK_LINE_FEED: TGUnicodeBreakType = 2;
  G_UNICODE_BREAK_COMBINING_MARK: TGUnicodeBreakType = 3;
  G_UNICODE_BREAK_SURROGATE: TGUnicodeBreakType = 4;
  G_UNICODE_BREAK_ZERO_WIDTH_SPACE: TGUnicodeBreakType = 5;
  G_UNICODE_BREAK_INSEPARABLE: TGUnicodeBreakType = 6;
  G_UNICODE_BREAK_NON_BREAKING_GLUE: TGUnicodeBreakType = 7;
  G_UNICODE_BREAK_CONTINGENT: TGUnicodeBreakType = 8;
  G_UNICODE_BREAK_SPACE: TGUnicodeBreakType = 9;
  G_UNICODE_BREAK_AFTER: TGUnicodeBreakType = 10;
  G_UNICODE_BREAK_BEFORE: TGUnicodeBreakType = 11;
  G_UNICODE_BREAK_BEFORE_AND_AFTER: TGUnicodeBreakType = 12;
  G_UNICODE_BREAK_HYPHEN: TGUnicodeBreakType = 13;
  G_UNICODE_BREAK_NON_STARTER: TGUnicodeBreakType = 14;
  G_UNICODE_BREAK_OPEN_PUNCTUATION: TGUnicodeBreakType = 15;
  G_UNICODE_BREAK_CLOSE_PUNCTUATION: TGUnicodeBreakType = 16;
  G_UNICODE_BREAK_QUOTATION: TGUnicodeBreakType = 17;
  G_UNICODE_BREAK_EXCLAMATION: TGUnicodeBreakType = 18;
  G_UNICODE_BREAK_IDEOGRAPHIC: TGUnicodeBreakType = 19;
  G_UNICODE_BREAK_NUMERIC: TGUnicodeBreakType = 20;
  G_UNICODE_BREAK_INFIX_SEPARATOR: TGUnicodeBreakType = 21;
  G_UNICODE_BREAK_SYMBOL: TGUnicodeBreakType = 22;
  G_UNICODE_BREAK_ALPHABETIC: TGUnicodeBreakType = 23;
  G_UNICODE_BREAK_PREFIX: TGUnicodeBreakType = 24;
  G_UNICODE_BREAK_POSTFIX: TGUnicodeBreakType = 25;
  G_UNICODE_BREAK_COMPLEX_CONTEXT: TGUnicodeBreakType = 26;
  G_UNICODE_BREAK_AMBIGUOUS: TGUnicodeBreakType = 27;
  G_UNICODE_BREAK_UNKNOWN: TGUnicodeBreakType = 28;
  G_UNICODE_BREAK_NEXT_LINE: TGUnicodeBreakType = 29;
  G_UNICODE_BREAK_WORD_JOINER: TGUnicodeBreakType = 30;
  G_UNICODE_BREAK_HANGUL_L_JAMO: TGUnicodeBreakType = 31;
  G_UNICODE_BREAK_HANGUL_V_JAMO: TGUnicodeBreakType = 32;
  G_UNICODE_BREAK_HANGUL_T_JAMO: TGUnicodeBreakType = 33;
  G_UNICODE_BREAK_HANGUL_LV_SYLLABLE: TGUnicodeBreakType = 34;
  G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE: TGUnicodeBreakType = 35;
  G_UNICODE_BREAK_CLOSE_PARANTHESIS: TGUnicodeBreakType = 36;
  G_UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER: TGUnicodeBreakType = 37;
  G_UNICODE_BREAK_HEBREW_LETTER: TGUnicodeBreakType = 38;
  G_UNICODE_BREAK_REGIONAL_INDICATOR: TGUnicodeBreakType = 39;

type
  TGUnicodeScript = Integer;
const
  { GUnicodeScript }
  G_UNICODE_SCRIPT_INVALID_CODE: TGUnicodeScript = -1;
  G_UNICODE_SCRIPT_COMMON: TGUnicodeScript = 0;
  G_UNICODE_SCRIPT_INHERITED: TGUnicodeScript = 1;
  G_UNICODE_SCRIPT_ARABIC: TGUnicodeScript = 2;
  G_UNICODE_SCRIPT_ARMENIAN: TGUnicodeScript = 3;
  G_UNICODE_SCRIPT_BENGALI: TGUnicodeScript = 4;
  G_UNICODE_SCRIPT_BOPOMOFO: TGUnicodeScript = 5;
  G_UNICODE_SCRIPT_CHEROKEE: TGUnicodeScript = 6;
  G_UNICODE_SCRIPT_COPTIC: TGUnicodeScript = 7;
  G_UNICODE_SCRIPT_CYRILLIC: TGUnicodeScript = 8;
  G_UNICODE_SCRIPT_DESERET: TGUnicodeScript = 9;
  G_UNICODE_SCRIPT_DEVANAGARI: TGUnicodeScript = 10;
  G_UNICODE_SCRIPT_ETHIOPIC: TGUnicodeScript = 11;
  G_UNICODE_SCRIPT_GEORGIAN: TGUnicodeScript = 12;
  G_UNICODE_SCRIPT_GOTHIC: TGUnicodeScript = 13;
  G_UNICODE_SCRIPT_GREEK: TGUnicodeScript = 14;
  G_UNICODE_SCRIPT_GUJARATI: TGUnicodeScript = 15;
  G_UNICODE_SCRIPT_GURMUKHI: TGUnicodeScript = 16;
  G_UNICODE_SCRIPT_HAN: TGUnicodeScript = 17;
  G_UNICODE_SCRIPT_HANGUL: TGUnicodeScript = 18;
  G_UNICODE_SCRIPT_HEBREW: TGUnicodeScript = 19;
  G_UNICODE_SCRIPT_HIRAGANA: TGUnicodeScript = 20;
  G_UNICODE_SCRIPT_KANNADA: TGUnicodeScript = 21;
  G_UNICODE_SCRIPT_KATAKANA: TGUnicodeScript = 22;
  G_UNICODE_SCRIPT_KHMER: TGUnicodeScript = 23;
  G_UNICODE_SCRIPT_LAO: TGUnicodeScript = 24;
  G_UNICODE_SCRIPT_LATIN: TGUnicodeScript = 25;
  G_UNICODE_SCRIPT_MALAYALAM: TGUnicodeScript = 26;
  G_UNICODE_SCRIPT_MONGOLIAN: TGUnicodeScript = 27;
  G_UNICODE_SCRIPT_MYANMAR: TGUnicodeScript = 28;
  G_UNICODE_SCRIPT_OGHAM: TGUnicodeScript = 29;
  G_UNICODE_SCRIPT_OLD_ITALIC: TGUnicodeScript = 30;
  G_UNICODE_SCRIPT_ORIYA: TGUnicodeScript = 31;
  G_UNICODE_SCRIPT_RUNIC: TGUnicodeScript = 32;
  G_UNICODE_SCRIPT_SINHALA: TGUnicodeScript = 33;
  G_UNICODE_SCRIPT_SYRIAC: TGUnicodeScript = 34;
  G_UNICODE_SCRIPT_TAMIL: TGUnicodeScript = 35;
  G_UNICODE_SCRIPT_TELUGU: TGUnicodeScript = 36;
  G_UNICODE_SCRIPT_THAANA: TGUnicodeScript = 37;
  G_UNICODE_SCRIPT_THAI: TGUnicodeScript = 38;
  G_UNICODE_SCRIPT_TIBETAN: TGUnicodeScript = 39;
  G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL: TGUnicodeScript = 40;
  G_UNICODE_SCRIPT_YI: TGUnicodeScript = 41;
  G_UNICODE_SCRIPT_TAGALOG: TGUnicodeScript = 42;
  G_UNICODE_SCRIPT_HANUNOO: TGUnicodeScript = 43;
  G_UNICODE_SCRIPT_BUHID: TGUnicodeScript = 44;
  G_UNICODE_SCRIPT_TAGBANWA: TGUnicodeScript = 45;
  G_UNICODE_SCRIPT_BRAILLE: TGUnicodeScript = 46;
  G_UNICODE_SCRIPT_CYPRIOT: TGUnicodeScript = 47;
  G_UNICODE_SCRIPT_LIMBU: TGUnicodeScript = 48;
  G_UNICODE_SCRIPT_OSMANYA: TGUnicodeScript = 49;
  G_UNICODE_SCRIPT_SHAVIAN: TGUnicodeScript = 50;
  G_UNICODE_SCRIPT_LINEAR_B: TGUnicodeScript = 51;
  G_UNICODE_SCRIPT_TAI_LE: TGUnicodeScript = 52;
  G_UNICODE_SCRIPT_UGARITIC: TGUnicodeScript = 53;
  G_UNICODE_SCRIPT_NEW_TAI_LUE: TGUnicodeScript = 54;
  G_UNICODE_SCRIPT_BUGINESE: TGUnicodeScript = 55;
  G_UNICODE_SCRIPT_GLAGOLITIC: TGUnicodeScript = 56;
  G_UNICODE_SCRIPT_TIFINAGH: TGUnicodeScript = 57;
  G_UNICODE_SCRIPT_SYLOTI_NAGRI: TGUnicodeScript = 58;
  G_UNICODE_SCRIPT_OLD_PERSIAN: TGUnicodeScript = 59;
  G_UNICODE_SCRIPT_KHAROSHTHI: TGUnicodeScript = 60;
  G_UNICODE_SCRIPT_UNKNOWN: TGUnicodeScript = 61;
  G_UNICODE_SCRIPT_BALINESE: TGUnicodeScript = 62;
  G_UNICODE_SCRIPT_CUNEIFORM: TGUnicodeScript = 63;
  G_UNICODE_SCRIPT_PHOENICIAN: TGUnicodeScript = 64;
  G_UNICODE_SCRIPT_PHAGS_PA: TGUnicodeScript = 65;
  G_UNICODE_SCRIPT_NKO: TGUnicodeScript = 66;
  G_UNICODE_SCRIPT_KAYAH_LI: TGUnicodeScript = 67;
  G_UNICODE_SCRIPT_LEPCHA: TGUnicodeScript = 68;
  G_UNICODE_SCRIPT_REJANG: TGUnicodeScript = 69;
  G_UNICODE_SCRIPT_SUNDANESE: TGUnicodeScript = 70;
  G_UNICODE_SCRIPT_SAURASHTRA: TGUnicodeScript = 71;
  G_UNICODE_SCRIPT_CHAM: TGUnicodeScript = 72;
  G_UNICODE_SCRIPT_OL_CHIKI: TGUnicodeScript = 73;
  G_UNICODE_SCRIPT_VAI: TGUnicodeScript = 74;
  G_UNICODE_SCRIPT_CARIAN: TGUnicodeScript = 75;
  G_UNICODE_SCRIPT_LYCIAN: TGUnicodeScript = 76;
  G_UNICODE_SCRIPT_LYDIAN: TGUnicodeScript = 77;
  G_UNICODE_SCRIPT_AVESTAN: TGUnicodeScript = 78;
  G_UNICODE_SCRIPT_BAMUM: TGUnicodeScript = 79;
  G_UNICODE_SCRIPT_EGYPTIAN_HIEROGLYPHS: TGUnicodeScript = 80;
  G_UNICODE_SCRIPT_IMPERIAL_ARAMAIC: TGUnicodeScript = 81;
  G_UNICODE_SCRIPT_INSCRIPTIONAL_PAHLAVI: TGUnicodeScript = 82;
  G_UNICODE_SCRIPT_INSCRIPTIONAL_PARTHIAN: TGUnicodeScript = 83;
  G_UNICODE_SCRIPT_JAVANESE: TGUnicodeScript = 84;
  G_UNICODE_SCRIPT_KAITHI: TGUnicodeScript = 85;
  G_UNICODE_SCRIPT_LISU: TGUnicodeScript = 86;
  G_UNICODE_SCRIPT_MEETEI_MAYEK: TGUnicodeScript = 87;
  G_UNICODE_SCRIPT_OLD_SOUTH_ARABIAN: TGUnicodeScript = 88;
  G_UNICODE_SCRIPT_OLD_TURKIC: TGUnicodeScript = 89;
  G_UNICODE_SCRIPT_SAMARITAN: TGUnicodeScript = 90;
  G_UNICODE_SCRIPT_TAI_THAM: TGUnicodeScript = 91;
  G_UNICODE_SCRIPT_TAI_VIET: TGUnicodeScript = 92;
  G_UNICODE_SCRIPT_BATAK: TGUnicodeScript = 93;
  G_UNICODE_SCRIPT_BRAHMI: TGUnicodeScript = 94;
  G_UNICODE_SCRIPT_MANDAIC: TGUnicodeScript = 95;
  G_UNICODE_SCRIPT_CHAKMA: TGUnicodeScript = 96;
  G_UNICODE_SCRIPT_MEROITIC_CURSIVE: TGUnicodeScript = 97;
  G_UNICODE_SCRIPT_MEROITIC_HIEROGLYPHS: TGUnicodeScript = 98;
  G_UNICODE_SCRIPT_MIAO: TGUnicodeScript = 99;
  G_UNICODE_SCRIPT_SHARADA: TGUnicodeScript = 100;
  G_UNICODE_SCRIPT_SORA_SOMPENG: TGUnicodeScript = 101;
  G_UNICODE_SCRIPT_TAKRI: TGUnicodeScript = 102;

type
  TGUnicodeType = Integer;
const
  { GUnicodeType }
  G_UNICODE_CONTROL: TGUnicodeType = 0;
  G_UNICODE_FORMAT: TGUnicodeType = 1;
  G_UNICODE_UNASSIGNED: TGUnicodeType = 2;
  G_UNICODE_PRIVATE_USE: TGUnicodeType = 3;
  G_UNICODE_SURROGATE: TGUnicodeType = 4;
  G_UNICODE_LOWERCASE_LETTER: TGUnicodeType = 5;
  G_UNICODE_MODIFIER_LETTER: TGUnicodeType = 6;
  G_UNICODE_OTHER_LETTER: TGUnicodeType = 7;
  G_UNICODE_TITLECASE_LETTER: TGUnicodeType = 8;
  G_UNICODE_UPPERCASE_LETTER: TGUnicodeType = 9;
  G_UNICODE_SPACING_MARK: TGUnicodeType = 10;
  G_UNICODE_ENCLOSING_MARK: TGUnicodeType = 11;
  G_UNICODE_NON_SPACING_MARK: TGUnicodeType = 12;
  G_UNICODE_DECIMAL_NUMBER: TGUnicodeType = 13;
  G_UNICODE_LETTER_NUMBER: TGUnicodeType = 14;
  G_UNICODE_OTHER_NUMBER: TGUnicodeType = 15;
  G_UNICODE_CONNECT_PUNCTUATION: TGUnicodeType = 16;
  G_UNICODE_DASH_PUNCTUATION: TGUnicodeType = 17;
  G_UNICODE_CLOSE_PUNCTUATION: TGUnicodeType = 18;
  G_UNICODE_FINAL_PUNCTUATION: TGUnicodeType = 19;
  G_UNICODE_INITIAL_PUNCTUATION: TGUnicodeType = 20;
  G_UNICODE_OTHER_PUNCTUATION: TGUnicodeType = 21;
  G_UNICODE_OPEN_PUNCTUATION: TGUnicodeType = 22;
  G_UNICODE_CURRENCY_SYMBOL: TGUnicodeType = 23;
  G_UNICODE_MODIFIER_SYMBOL: TGUnicodeType = 24;
  G_UNICODE_MATH_SYMBOL: TGUnicodeType = 25;
  G_UNICODE_OTHER_SYMBOL: TGUnicodeType = 26;
  G_UNICODE_LINE_SEPARATOR: TGUnicodeType = 27;
  G_UNICODE_PARAGRAPH_SEPARATOR: TGUnicodeType = 28;
  G_UNICODE_SPACE_SEPARATOR: TGUnicodeType = 29;

type
  TGUserDirectory = Integer;
const
  { GUserDirectory }
  G_USER_DIRECTORY_DESKTOP: TGUserDirectory = 0;
  G_USER_DIRECTORY_DOCUMENTS: TGUserDirectory = 1;
  G_USER_DIRECTORY_DOWNLOAD: TGUserDirectory = 2;
  G_USER_DIRECTORY_MUSIC: TGUserDirectory = 3;
  G_USER_DIRECTORY_PICTURES: TGUserDirectory = 4;
  G_USER_DIRECTORY_PUBLIC_SHARE: TGUserDirectory = 5;
  G_USER_DIRECTORY_TEMPLATES: TGUserDirectory = 6;
  G_USER_DIRECTORY_VIDEOS: TGUserDirectory = 7;
  G_USER_N_DIRECTORIES: TGUserDirectory = 8;

type
  TGVariantClass = Integer;
const
  { GVariantClass }
  G_VARIANT_CLASS_BOOLEAN: TGVariantClass = 98;
  G_VARIANT_CLASS_BYTE: TGVariantClass = 121;
  G_VARIANT_CLASS_INT16: TGVariantClass = 110;
  G_VARIANT_CLASS_UINT16: TGVariantClass = 113;
  G_VARIANT_CLASS_INT32: TGVariantClass = 105;
  G_VARIANT_CLASS_UINT32: TGVariantClass = 117;
  G_VARIANT_CLASS_INT64: TGVariantClass = 120;
  G_VARIANT_CLASS_UINT64: TGVariantClass = 116;
  G_VARIANT_CLASS_HANDLE: TGVariantClass = 104;
  G_VARIANT_CLASS_DOUBLE: TGVariantClass = 100;
  G_VARIANT_CLASS_STRING: TGVariantClass = 115;
  G_VARIANT_CLASS_OBJECT_PATH: TGVariantClass = 111;
  G_VARIANT_CLASS_SIGNATURE: TGVariantClass = 103;
  G_VARIANT_CLASS_VARIANT: TGVariantClass = 118;
  G_VARIANT_CLASS_MAYBE: TGVariantClass = 109;
  G_VARIANT_CLASS_ARRAY: TGVariantClass = 97;
  G_VARIANT_CLASS_TUPLE: TGVariantClass = 40;
  G_VARIANT_CLASS_DICT_ENTRY: TGVariantClass = 123;

type
  TGVariantParseError = Integer;
const
  { GVariantParseError }
  G_VARIANT_PARSE_ERROR_FAILED: TGVariantParseError = 0;
  G_VARIANT_PARSE_ERROR_BASIC_TYPE_EXPECTED: TGVariantParseError = 1;
  G_VARIANT_PARSE_ERROR_CANNOT_INFER_TYPE: TGVariantParseError = 2;
  G_VARIANT_PARSE_ERROR_DEFINITE_TYPE_EXPECTED: TGVariantParseError = 3;
  G_VARIANT_PARSE_ERROR_INPUT_NOT_AT_END: TGVariantParseError = 4;
  G_VARIANT_PARSE_ERROR_INVALID_CHARACTER: TGVariantParseError = 5;
  G_VARIANT_PARSE_ERROR_INVALID_FORMAT_STRING: TGVariantParseError = 6;
  G_VARIANT_PARSE_ERROR_INVALID_OBJECT_PATH: TGVariantParseError = 7;
  G_VARIANT_PARSE_ERROR_INVALID_SIGNATURE: TGVariantParseError = 8;
  G_VARIANT_PARSE_ERROR_INVALID_TYPE_STRING: TGVariantParseError = 9;
  G_VARIANT_PARSE_ERROR_NO_COMMON_TYPE: TGVariantParseError = 10;
  G_VARIANT_PARSE_ERROR_NUMBER_OUT_OF_RANGE: TGVariantParseError = 11;
  G_VARIANT_PARSE_ERROR_NUMBER_TOO_BIG: TGVariantParseError = 12;
  G_VARIANT_PARSE_ERROR_TYPE_ERROR: TGVariantParseError = 13;
  G_VARIANT_PARSE_ERROR_UNEXPECTED_TOKEN: TGVariantParseError = 14;
  G_VARIANT_PARSE_ERROR_UNKNOWN_KEYWORD: TGVariantParseError = 15;
  G_VARIANT_PARSE_ERROR_UNTERMINATED_STRING_CONSTANT: TGVariantParseError = 16;
  G_VARIANT_PARSE_ERROR_VALUE_EXPECTED: TGVariantParseError = 17;
type
  guint1 = 0..(1 shl 1-1);
  guint2 = 0..(1 shl 2-1);
  guint3 = 0..(1 shl 3-1);
  guint4 = 0..(1 shl 4-1);
  guint5 = 0..(1 shl 5-1);
  guint6 = 0..(1 shl 6-1);
  guint7 = 0..(1 shl 7-1);
  guint9 = 0..(1 shl 9-1);
  guint10 = 0..(1 shl 10-1);
  guint11 = 0..(1 shl 11-1);
  guint12 = 0..(1 shl 12-1);
  guint13 = 0..(1 shl 13-1);
  guint14 = 0..(1 shl 14-1);
  guint15 = 0..(1 shl 15-1);
  guint17 = 0..(1 shl 17-1);
  guint18 = 0..(1 shl 18-1);
  guint19 = 0..(1 shl 19-1);
  guint20 = 0..(1 shl 20-1);
  guint21 = 0..(1 shl 21-1);
  guint22 = 0..(1 shl 22-1);
  guint23 = 0..(1 shl 23-1);
  guint24 = 0..(1 shl 24-1);
  guint25 = 0..(1 shl 25-1);
  guint26 = 0..(1 shl 26-1);
  guint27 = 0..(1 shl 27-1);
  guint28 = 0..(1 shl 28-1);
  guint29 = 0..(1 shl 29-1);
  guint30 = 0..(1 shl 30-1);
  guint31 = 0..(1 shl 31-1);
  gpointer = pointer;
  int = cint;
  gint = cint;
  guint = cuint;
  guint8 = cuint8;
  guint16 = cuint16;
  guint32 = cuint32;
  guint64 = cuint64;
  gint8 = cint8;
  gint16 = cint16;
  gint32 = cint32;
  gint64 = cint64;
  gsize = csize_t;
  glong = clong;
  gulong = culong;
  gushort = cushort;
  gshort = cshort;
  gchar = char;
  guchar = byte;
  gboolean = Boolean32;
  gssize = PtrInt;
  size_t = csize_t;
  gconstpointer = gpointer;
  gfloat = cfloat;
  gdouble = cdouble;
  double = cdouble;
  goffset = Int64;
  long_double = Extended;
  gunichar = guint32;
  gunichar2 = guint32;
  unsigned_long_long = qword;

  PPGDateDay = ^PGDateDay;
  PGDateDay = ^TGDateDay;
  TGDateDay = guint8;

  PPGDateYear = ^PGDateYear;
  PGDateYear = ^TGDateYear;
  TGDateYear = guint16;

  PPGPid = ^PGPid;
  PGPid = ^TGPid;
  TGPid = gint;

  PPGQuark = ^PGQuark;
  PGQuark = ^TGQuark;
  TGQuark = guint32;

  PPGStrv = ^PGStrv;
  PGStrv = ^TGStrv;
  TGStrv = gpointer;

  PPGTime = ^PGTime;
  PGTime = ^TGTime;
  TGTime = gint32;

  PPGTimeSpan = ^PGTimeSpan;
  PGTimeSpan = ^TGTimeSpan;
  TGTimeSpan = gint64;

  PPPGType = ^PPGType;
  PPGType = ^PGType;
  PGType = ^TGType;
  TGType = gsize;

  PPPgpointer = ^PPgpointer;
  PPgpointer = ^Pgpointer;
  Pgpointer = ^gpointer;
  TGDestroyNotify = procedure(data: gpointer); cdecl;

  PPPgint = ^PPgint;
  PPgint = ^Pgint;
  Pgint = ^gint;
  TGCompareFunc = function(a: Pgpointer; b: Pgpointer): gint; cdecl;
  TGCompareDataFunc = function(a: Pgpointer; b: Pgpointer; user_data: gpointer): gint; cdecl;

  PPGArray = ^PGArray;
  PGArray = ^TGArray;

  PPPguint = ^PPguint;
  PPguint = ^Pguint;
  Pguint = ^guint;

  PPPgchar = ^PPgchar;
  PPgchar = ^Pgchar;
  Pgchar = ^gchar;

  PPPgboolean = ^PPgboolean;
  PPgboolean = ^Pgboolean;
  Pgboolean = ^gboolean;

  PPGDestroyNotify = ^PGDestroyNotify;
  PGDestroyNotify = ^TGDestroyNotify;

  PPGCompareFunc = ^PGCompareFunc;
  PGCompareFunc = ^TGCompareFunc;

  PPGCompareDataFunc = ^PGCompareDataFunc;
  PGCompareDataFunc = ^TGCompareDataFunc;
  TGArray = object
    data: Pgchar;
    len: guint;
    function append_vals(array_: Pgpointer; data: Pgpointer; len: guint): Pgpointer; cdecl; inline; static;
    function free(array_: Pgpointer; free_segment: gboolean): Pgchar; cdecl; inline; static;
    function get_element_size(array_: Pgpointer): guint; cdecl; inline; static;
    function insert_vals(array_: Pgpointer; index_: guint; data: Pgpointer; len: guint): Pgpointer; cdecl; inline; static;
    function new(zero_terminated: gboolean; clear_: gboolean; element_size: guint): Pgpointer; cdecl; inline; static;
    function prepend_vals(array_: Pgpointer; data: Pgpointer; len: guint): Pgpointer; cdecl; inline; static;
    function ref(array_: Pgpointer): Pgpointer; cdecl; inline; static;
    function remove_index(array_: Pgpointer; index_: guint): Pgpointer; cdecl; inline; static;
    function remove_index_fast(array_: Pgpointer; index_: guint): Pgpointer; cdecl; inline; static;
    function remove_range(array_: Pgpointer; index_: guint; length: guint): Pgpointer; cdecl; inline; static;
    procedure set_clear_func(array_: Pgpointer; clear_func: TGDestroyNotify); cdecl; inline; static;
    function set_size(array_: Pgpointer; length: guint): Pgpointer; cdecl; inline; static;
    function sized_new(zero_terminated: gboolean; clear_: gboolean; element_size: guint; reserved_size: guint): Pgpointer; cdecl; inline; static;
    procedure sort(array_: Pgpointer; compare_func: TGCompareFunc); cdecl; inline; static;
    procedure sort_with_data(array_: Pgpointer; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; inline; static;
    procedure unref(array_: Pgpointer); cdecl; inline; static;
  end;

  PPGAsciiType = ^PGAsciiType;
  PGAsciiType = ^TGAsciiType;

  PPGAsyncQueue = ^PGAsyncQueue;
  PGAsyncQueue = ^TGAsyncQueue;

  PPPguint64 = ^PPguint64;
  PPguint64 = ^Pguint64;
  Pguint64 = ^guint64;
  TGAsyncQueue = object
    function length: gint; cdecl; inline;
    function length_unlocked: gint; cdecl; inline;
    procedure lock; cdecl; inline;
    function pop: gpointer; cdecl; inline;
    function pop_unlocked: gpointer; cdecl; inline;
    procedure push(data: gpointer); cdecl; inline;
    procedure push_sorted(data: gpointer; func: TGCompareDataFunc; user_data: gpointer); cdecl; inline;
    procedure push_sorted_unlocked(data: gpointer; func: TGCompareDataFunc; user_data: gpointer); cdecl; inline;
    procedure push_unlocked(data: gpointer); cdecl; inline;
    function ref: PGAsyncQueue; cdecl; inline;
    procedure sort(func: TGCompareDataFunc; user_data: gpointer); cdecl; inline;
    procedure sort_unlocked(func: TGCompareDataFunc; user_data: gpointer); cdecl; inline;
    function timeout_pop(timeout: guint64): gpointer; cdecl; inline;
    function timeout_pop_unlocked(timeout: guint64): gpointer; cdecl; inline;
    function try_pop: gpointer; cdecl; inline;
    function try_pop_unlocked: gpointer; cdecl; inline;
    procedure unlock; cdecl; inline;
    procedure unref; cdecl; inline;
    function new: PGAsyncQueue; cdecl; inline; static;
    function new_full(item_free_func: TGDestroyNotify): PGAsyncQueue; cdecl; inline; static;
  end;

  PPGTimeVal = ^PGTimeVal;
  PGTimeVal = ^TGTimeVal;

  PPPglong = ^PPglong;
  PPglong = ^Pglong;
  Pglong = ^glong;
  TGTimeVal = object
    tv_sec: glong;
    tv_usec: glong;
    procedure add(microseconds: glong); cdecl; inline;
    function to_iso8601: Pgchar; cdecl; inline;
    function from_iso8601(iso_date: Pgchar; time_: PGTimeVal): gboolean; cdecl; inline; static;
  end;

  PPGBookmarkFile = ^PGBookmarkFile;
  PGBookmarkFile = ^TGBookmarkFile;

  PPGError = ^PGError;
  PGError = ^TGError;

  PPPgsize = ^PPgsize;
  PPgsize = ^Pgsize;
  Pgsize = ^gsize;
  TGBookmarkFile = object
    procedure add_application(uri: Pgchar; name: Pgchar; exec: Pgchar); cdecl; inline;
    procedure add_group(uri: Pgchar; group: Pgchar); cdecl; inline;
    procedure free; cdecl; inline;
    function get_added(uri: Pgchar; error: PPGError): glong; cdecl; inline;
    function get_app_info(uri: Pgchar; name: Pgchar; exec: PPgchar; count: Pguint; stamp: Pglong; error: PPGError): gboolean; cdecl; inline;
    function get_applications(uri: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; inline;
    function get_description(uri: Pgchar; error: PPGError): Pgchar; cdecl; inline;
    function get_groups(uri: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; inline;
    function get_icon(uri: Pgchar; href: PPgchar; mime_type: PPgchar; error: PPGError): gboolean; cdecl; inline;
    function get_is_private(uri: Pgchar; error: PPGError): gboolean; cdecl; inline;
    function get_mime_type(uri: Pgchar; error: PPGError): Pgchar; cdecl; inline;
    function get_modified(uri: Pgchar; error: PPGError): glong; cdecl; inline;
    function get_size: gint; cdecl; inline;
    function get_title(uri: Pgchar; error: PPGError): Pgchar; cdecl; inline;
    function get_uris(length: Pgsize): PPgchar; cdecl; inline;
    function get_visited(uri: Pgchar; error: PPGError): glong; cdecl; inline;
    function has_application(uri: Pgchar; name: Pgchar; error: PPGError): gboolean; cdecl; inline;
    function has_group(uri: Pgchar; group: Pgchar; error: PPGError): gboolean; cdecl; inline;
    function has_item(uri: Pgchar): gboolean; cdecl; inline;
    function load_from_data(data: Pgchar; length: gsize; error: PPGError): gboolean; cdecl; inline;
    function load_from_data_dirs(file_: Pgchar; full_path: PPgchar; error: PPGError): gboolean; cdecl; inline;
    function load_from_file(filename: Pgchar; error: PPGError): gboolean; cdecl; inline;
    function move_item(old_uri: Pgchar; new_uri: Pgchar; error: PPGError): gboolean; cdecl; inline;
    function remove_application(uri: Pgchar; name: Pgchar; error: PPGError): gboolean; cdecl; inline;
    function remove_group(uri: Pgchar; group: Pgchar; error: PPGError): gboolean; cdecl; inline;
    function remove_item(uri: Pgchar; error: PPGError): gboolean; cdecl; inline;
    procedure set_added(uri: Pgchar; added: glong); cdecl; inline;
    function set_app_info(uri: Pgchar; name: Pgchar; exec: Pgchar; count: gint; stamp: glong; error: PPGError): gboolean; cdecl; inline;
    procedure set_description(uri: Pgchar; description: Pgchar); cdecl; inline;
    procedure set_groups(uri: Pgchar; groups: PPgchar; length: gsize); cdecl; inline;
    procedure set_icon(uri: Pgchar; href: Pgchar; mime_type: Pgchar); cdecl; inline;
    procedure set_is_private(uri: Pgchar; is_private: gboolean); cdecl; inline;
    procedure set_mime_type(uri: Pgchar; mime_type: Pgchar); cdecl; inline;
    procedure set_modified(uri: Pgchar; modified: glong); cdecl; inline;
    procedure set_title(uri: Pgchar; title: Pgchar); cdecl; inline;
    procedure set_visited(uri: Pgchar; visited: glong); cdecl; inline;
    function to_data(length: Pgsize; error: PPGError): Pgchar; cdecl; inline;
    function to_file(filename: Pgchar; error: PPGError): gboolean; cdecl; inline;
    function error_quark: TGQuark; cdecl; inline; static;
    function new: PGBookmarkFile; cdecl; inline; static;
  end;

  Pva_list = ^Tva_list;

  { va_list }
  Tva_list = record
    { opaque type }
    Unknown: Pointer;
  end;

  TGError = object
    domain: TGQuark;
    code: gint;
    message: Pgchar;
    //function new(domain: TGQuark; code: gint; format: Pgchar; args: array of const): PGError; cdecl; inline; static;
    function new_literal(domain: TGQuark; code: gint; message: Pgchar): PGError; cdecl; inline; static;
    //function new_valist(domain: TGQuark; code: gint; format: Pgchar; args: Tva_list): PGError; cdecl; inline; static;
    function copy: PGError; cdecl; inline;
    procedure free; cdecl; inline;
    function matches(domain: TGQuark; code: gint): gboolean; cdecl; inline;
  end;

  PPGBookmarkFileError = ^PGBookmarkFileError;
  PGBookmarkFileError = ^TGBookmarkFileError;

  PPGBytes = ^PGBytes;
  PGBytes = ^TGBytes;

  PPPguint8 = ^PPguint8;
  PPguint8 = ^Pguint8;
  Pguint8 = ^guint8;
  TGBytes = object
    function new(data: guint8; size: gsize): PGBytes; cdecl; inline; static;
    function new_static(data: guint8; size: gsize): PGBytes; cdecl; inline; static;
    function new_take(data: guint8; size: gsize): PGBytes; cdecl; inline; static;
    function new_with_free_func(data: gpointer; size: gsize; free_func: TGDestroyNotify; user_data: gpointer): PGBytes; cdecl; inline; static;
    function compare(bytes2: PGBytes): gint; cdecl; inline;
    function equal(bytes2: PGBytes): gboolean; cdecl; inline;
    function get_data(size: Pgsize): guint8; cdecl; inline;
    function get_size: gsize; cdecl; inline;
    function hash: guint; cdecl; inline;
    function new_from_bytes(offset: gsize; length: gsize): PGBytes; cdecl; inline;
    function ref: PGBytes; cdecl; inline;
    procedure unref; cdecl; inline;
    function unref_to_array: Pguint8; cdecl; inline;
    function unref_to_data(size: Pgsize): gpointer; cdecl; inline;
  end;

  PPGByteArray = ^PGByteArray;
  PGByteArray = ^TGByteArray;
  TGByteArray = object
    data: Pguint8;
    len: guint;
    function append(array_: Pguint8; data: Pguint8; len: guint): Pguint8; cdecl; inline; static;
    function free(array_: Pguint8; free_segment: gboolean): Pguint8; cdecl; inline; static;
    function free_to_bytes(array_: Pguint8): PGBytes; cdecl; inline; static;
    function new: Pguint8; cdecl; inline; static;
    function new_take(data: Pguint8; len: gsize): Pguint8; cdecl; inline; static;
    function prepend(array_: Pguint8; data: Pguint8; len: guint): Pguint8; cdecl; inline; static;
    function ref(array_: Pguint8): Pguint8; cdecl; inline; static;
    function remove_index(array_: Pguint8; index_: guint): Pguint8; cdecl; inline; static;
    function remove_index_fast(array_: Pguint8; index_: guint): Pguint8; cdecl; inline; static;
    function remove_range(array_: Pguint8; index_: guint; length: guint): Pguint8; cdecl; inline; static;
    function set_size(array_: Pguint8; length: guint): Pguint8; cdecl; inline; static;
    function sized_new(reserved_size: guint): Pguint8; cdecl; inline; static;
    procedure sort(array_: Pguint8; compare_func: TGCompareFunc); cdecl; inline; static;
    procedure sort_with_data(array_: Pguint8; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; inline; static;
    procedure unref(array_: Pguint8); cdecl; inline; static;
  end;

  PPGChecksum = ^PGChecksum;
  PGChecksum = ^TGChecksum;

  PPGChecksumType = ^PGChecksumType;
  PGChecksumType = ^TGChecksumType;

  PPPgssize = ^PPgssize;
  PPgssize = ^Pgssize;
  Pgssize = ^gssize;
  TGChecksum = object
    function new(checksum_type: TGChecksumType): PGChecksum; cdecl; inline; static;
    function copy: PGChecksum; cdecl; inline;
    procedure free; cdecl; inline;
    procedure get_digest(buffer: Pguint8; digest_len: Pgsize); cdecl; inline;
    function get_string: Pgchar; cdecl; inline;
    procedure reset; cdecl; inline;
    procedure update(data: Pguint8; length: gssize); cdecl; inline;
    function type_get_length(checksum_type: TGChecksumType): gssize; cdecl; inline; static;
  end;
  TGChildWatchFunc = procedure(pid: TGPid; status: gint; user_data: gpointer); cdecl;

  PPGCond = ^PGCond;
  PGCond = ^TGCond;

  PPGMutex = ^PGMutex;
  PGMutex = ^TGMutex;

  PPPgint64 = ^PPgint64;
  PPgint64 = ^Pgint64;
  Pgint64 = ^gint64;
  TGCond = object
    p: gpointer;
    i: array [0..1] of guint;
    procedure broadcast; cdecl; inline;
    procedure clear; cdecl; inline;
    procedure init; cdecl; inline;
    procedure signal; cdecl; inline;
    procedure wait(mutex: PGMutex); cdecl; inline;
    function wait_until(mutex: PGMutex; end_time: gint64): gboolean; cdecl; inline;
  end;
  TGMutex = record
    case longint of
      0 : (p: gpointer);
      1 : (i: array [0..1] of guint);
    //procedure clear; cdecl;
    //procedure init; cdecl;
    //procedure lock; cdecl;
    //function trylock: gboolean; cdecl;
    //procedure unlock; cdecl;
  end;



  PPGConvertError = ^PGConvertError;
  PGConvertError = ^TGConvertError;
  TGCopyFunc = function(src: Pgpointer; data: gpointer): gpointer; cdecl;

  PPGData = ^PGData;
  PGData = ^TGData;

  TGData = record
  end;


  TGDataForeachFunc = procedure(key_id: TGQuark; data: gpointer; user_data: gpointer); cdecl;

  PPGDate = ^PGDate;
  PGDate = ^TGDate;

  PPGDateMonth = ^PGDateMonth;
  PGDateMonth = ^TGDateMonth;

  PPPguint32 = ^PPguint32;
  PPguint32 = ^Pguint32;
  Pguint32 = ^guint32;

  PPGDateWeekday = ^PGDateWeekday;
  PGDateWeekday = ^TGDateWeekday;
  TGDateBitfield0 = bitpacked record
    julian_days: guint32 { changed from guint to accomodate 32 bitsize requirement };
    julian: guint1 { changed from guint to accomodate 1 bitsize requirement };
    dmy: guint1 { changed from guint to accomodate 1 bitsize requirement };
    day: guint6 { changed from guint to accomodate 6 bitsize requirement };
    month: guint4 { changed from guint to accomodate 4 bitsize requirement };
    year: guint16 { changed from guint to accomodate 16 bitsize requirement };
  end;

  TGDate = object
    Bitfield0 : TGDateBitfield0; { auto generated type }
    function new: PGDate; cdecl; inline; static;
    function new_dmy(day: TGDateDay; month: TGDateMonth; year: TGDateYear): PGDate; cdecl; inline; static;
    function new_julian(julian_day: guint32): PGDate; cdecl; inline; static;
    procedure add_days(n_days: guint); cdecl; inline;
    procedure add_months(n_months: guint); cdecl; inline;
    procedure add_years(n_years: guint); cdecl; inline;
    procedure clamp(min_date: PGDate; max_date: PGDate); cdecl; inline;
    procedure clear(n_dates: guint); cdecl; inline;
    function compare(rhs: PGDate): gint; cdecl; inline;
    function days_between(date2: PGDate): gint; cdecl; inline;
    procedure free; cdecl; inline;
    function get_day: TGDateDay; cdecl; inline;
    function get_day_of_year: guint; cdecl; inline;
    function get_iso8601_week_of_year: guint; cdecl; inline;
    function get_julian: guint32; cdecl; inline;
    function get_monday_week_of_year: guint; cdecl; inline;
    function get_month: TGDateMonth; cdecl; inline;
    function get_sunday_week_of_year: guint; cdecl; inline;
    function get_weekday: TGDateWeekday; cdecl; inline;
    function get_year: TGDateYear; cdecl; inline;
    function is_first_of_month: gboolean; cdecl; inline;
    function is_last_of_month: gboolean; cdecl; inline;
    procedure order(date2: PGDate); cdecl; inline;
    procedure set_day(day: TGDateDay); cdecl; inline;
    procedure set_dmy(day: TGDateDay; month: TGDateMonth; y: TGDateYear); cdecl; inline;
    procedure set_julian(julian_date: guint32); cdecl; inline;
    procedure set_month(month: TGDateMonth); cdecl; inline;
    procedure set_parse(str: Pgchar); cdecl; inline;
    procedure set_time_t(timet: glong); cdecl; inline;
    procedure set_time_val(timeval: PGTimeVal); cdecl; inline;
    procedure set_year(year: TGDateYear); cdecl; inline;
    procedure subtract_days(n_days: guint); cdecl; inline;
    procedure subtract_months(n_months: guint); cdecl; inline;
    procedure subtract_years(n_years: guint); cdecl; inline;
    procedure to_struct_tm(tm: Pgpointer); cdecl; inline;
    function valid: gboolean; cdecl; inline;
    function get_days_in_month(month: TGDateMonth; year: TGDateYear): guint8; cdecl; inline; static;
    function get_monday_weeks_in_year(year: TGDateYear): guint8; cdecl; inline; static;
    function get_sunday_weeks_in_year(year: TGDateYear): guint8; cdecl; inline; static;
    function is_leap_year(year: TGDateYear): gboolean; cdecl; inline; static;
    function strftime(s: Pgchar; slen: gsize; format: Pgchar; date: PGDate): gsize; cdecl; inline; static;
    function valid_day(day: TGDateDay): gboolean; cdecl; inline; static;
    function valid_dmy(day: TGDateDay; month: TGDateMonth; year: TGDateYear): gboolean; cdecl; inline; static;
    function valid_julian(julian_date: guint32): gboolean; cdecl; inline; static;
    function valid_month(month: TGDateMonth): gboolean; cdecl; inline; static;
    function valid_weekday(weekday: TGDateWeekday): gboolean; cdecl; inline; static;
    function valid_year(year: TGDateYear): gboolean; cdecl; inline; static;
  end;

  PPGDateDMY = ^PGDateDMY;
  PGDateDMY = ^TGDateDMY;

  PPGDateTime = ^PGDateTime;
  PGDateTime = ^TGDateTime;

  PPGTimeZone = ^PGTimeZone;
  PGTimeZone = ^TGTimeZone;

  PPPgdouble = ^PPgdouble;
  PPgdouble = ^Pgdouble;
  Pgdouble = ^gdouble;
  TGDateTime = object
    function new(tz: PGTimeZone; year: gint; month: gint; day: gint; hour: gint; minute: gint; seconds: gdouble): PGDateTime; cdecl; inline; static;
    function new_from_timeval_local(tv: PGTimeVal): PGDateTime; cdecl; inline; static;
    function new_from_timeval_utc(tv: PGTimeVal): PGDateTime; cdecl; inline; static;
    function new_from_unix_local(t: gint64): PGDateTime; cdecl; inline; static;
    function new_from_unix_utc(t: gint64): PGDateTime; cdecl; inline; static;
    function new_local(year: gint; month: gint; day: gint; hour: gint; minute: gint; seconds: gdouble): PGDateTime; cdecl; inline; static;
    function new_now(tz: PGTimeZone): PGDateTime; cdecl; inline; static;
    function new_now_local: PGDateTime; cdecl; inline; static;
    function new_now_utc: PGDateTime; cdecl; inline; static;
    function new_utc(year: gint; month: gint; day: gint; hour: gint; minute: gint; seconds: gdouble): PGDateTime; cdecl; inline; static;
    function add(timespan: TGTimeSpan): PGDateTime; cdecl; inline;
    function add_days(days: gint): PGDateTime; cdecl; inline;
    function add_full(years: gint; months: gint; days: gint; hours: gint; minutes: gint; seconds: gdouble): PGDateTime; cdecl; inline;
    function add_hours(hours: gint): PGDateTime; cdecl; inline;
    function add_minutes(minutes: gint): PGDateTime; cdecl; inline;
    function add_months(months: gint): PGDateTime; cdecl; inline;
    function add_seconds(seconds: gdouble): PGDateTime; cdecl; inline;
    function add_weeks(weeks: gint): PGDateTime; cdecl; inline;
    function add_years(years: gint): PGDateTime; cdecl; inline;
    function difference(begin_: PGDateTime): TGTimeSpan; cdecl; inline;
    function format(format: Pgchar): Pgchar; cdecl; inline;
    function get_day_of_month: gint; cdecl; inline;
    function get_day_of_week: gint; cdecl; inline;
    function get_day_of_year: gint; cdecl; inline;
    function get_hour: gint; cdecl; inline;
    function get_microsecond: gint; cdecl; inline;
    function get_minute: gint; cdecl; inline;
    function get_month: gint; cdecl; inline;
    function get_second: gint; cdecl; inline;
    function get_seconds: gdouble; cdecl; inline;
    function get_timezone_abbreviation: Pgchar; cdecl; inline;
    function get_utc_offset: TGTimeSpan; cdecl; inline;
    function get_week_numbering_year: gint; cdecl; inline;
    function get_week_of_year: gint; cdecl; inline;
    function get_year: gint; cdecl; inline;
    procedure get_ymd(year: Pgint; month: Pgint; day: Pgint); cdecl; inline;
    function is_daylight_savings: gboolean; cdecl; inline;
    function ref: PGDateTime; cdecl; inline;
    function to_local: PGDateTime; cdecl; inline;
    function to_timeval(tv: PGTimeVal): gboolean; cdecl; inline;
    function to_timezone(tz: PGTimeZone): PGDateTime; cdecl; inline;
    function to_unix: gint64; cdecl; inline;
    function to_utc: PGDateTime; cdecl; inline;
    procedure unref; cdecl; inline;
    function compare(dt1: Pgpointer; dt2: Pgpointer): gint; cdecl; inline; static;
    function equal(dt1: Pgpointer; dt2: Pgpointer): gboolean; cdecl; inline; static;
    function hash(datetime: Pgpointer): guint; cdecl; inline; static;
  end;

  PPGTimeType = ^PGTimeType;
  PGTimeType = ^TGTimeType;

  PPPgint32 = ^PPgint32;
  PPgint32 = ^Pgint32;
  Pgint32 = ^gint32;
  TGTimeZone = object
    function new(identifier: Pgchar): PGTimeZone; cdecl; inline; static;
    function new_local: PGTimeZone; cdecl; inline; static;
    function new_utc: PGTimeZone; cdecl; inline; static;
    function adjust_time(type_: TGTimeType; time_: Pgint64): gint; cdecl; inline;
    function find_interval(type_: TGTimeType; time_: gint64): gint; cdecl; inline;
    function get_abbreviation(interval: gint): Pgchar; cdecl; inline;
    function get_offset(interval: gint): gint32; cdecl; inline;
    function is_dst(interval: gint): gboolean; cdecl; inline;
    function ref: PGTimeZone; cdecl; inline;
    procedure unref; cdecl; inline;
  end;

  PPGDebugKey = ^PGDebugKey;
  PGDebugKey = ^TGDebugKey;

  TGDebugKey = record
    key: Pgchar;
    value: guint;
  end;



  PPGDir = ^PGDir;
  PGDir = ^TGDir;
  TGDir = object
    procedure close; cdecl; inline;
    function read_name: Pgchar; cdecl; inline;
    procedure rewind; cdecl; inline;
    function make_tmp(tmpl: Pgchar; error: PPGError): Pgchar; cdecl; inline; static;
    function open(path: Pgchar; flags: guint; error: PPGError): PGDir; cdecl; inline; static;
  end;
  TGDoubleIEEE754 = record
    case longint of
      0 : (v_double: gdouble);
      1 : (
        mpn : record
          mantissa_low: guint32 { changed from guint to accomodate 32 bitsize requirement };
          mantissa_high: guint20 { changed from guint to accomodate 20 bitsize requirement };
          biased_exponent: guint11 { changed from guint to accomodate 11 bitsize requirement };
          sign: guint1 { changed from guint to accomodate 1 bitsize requirement };
        end;

);
  end;


  TGDuplicateFunc = function(data: gpointer; user_data: gpointer): gpointer; cdecl;
  TGEqualFunc = function(a: Pgpointer; b: Pgpointer): gboolean; cdecl;

  PPGErrorType = ^PGErrorType;
  PGErrorType = ^TGErrorType;

  PPGFileError = ^PGFileError;
  PGFileError = ^TGFileError;

  PPGFileTest = ^PGFileTest;
  PGFileTest = ^TGFileTest;

  PPPgfloat = ^PPgfloat;
  PPgfloat = ^Pgfloat;
  Pgfloat = ^gfloat;
  TGFloatIEEE754 = record
    case longint of
      0 : (v_float: gfloat);
      1 : (
        mpn : record
          mantissa: guint23 { changed from guint to accomodate 23 bitsize requirement };
          biased_exponent: guint8 { changed from guint to accomodate 8 bitsize requirement };
          sign: guint1 { changed from guint to accomodate 1 bitsize requirement };
        end;

);
  end;



  PPGFormatSizeFlags = ^PGFormatSizeFlags;
  PGFormatSizeFlags = ^TGFormatSizeFlags;
  TGFreeFunc = procedure(data: gpointer); cdecl;
  TGFunc = procedure(data: gpointer; user_data: gpointer); cdecl;
  TGHFunc = procedure(key: gpointer; value: gpointer; user_data: gpointer); cdecl;
  TGHRFunc = function(key: gpointer; value: gpointer; user_data: gpointer): gboolean; cdecl;
  TGHashFunc = function(key: Pgpointer): guint; cdecl;

  PPGHashTable = ^PGHashTable;
  PGHashTable = ^TGHashTable;

  PPGHRFunc = ^PGHRFunc;
  PGHRFunc = ^TGHRFunc;

  PPGHFunc = ^PGHFunc;
  PGHFunc = ^TGHFunc;

  PPGList = ^PGList;
  PGList = ^TGList;

  PPGHashFunc = ^PGHashFunc;
  PGHashFunc = ^TGHashFunc;

  PPGEqualFunc = ^PGEqualFunc;
  PGEqualFunc = ^TGEqualFunc;
  TGHashTable = object
    procedure add(hash_table: PGHashTable; key: gpointer); cdecl; inline; static;
    function contains(hash_table: PGHashTable; key: Pgpointer): gboolean; cdecl; inline; static;
    procedure destroy_(hash_table: PGHashTable); cdecl; inline; static;
    function find(hash_table: PGHashTable; predicate: TGHRFunc; user_data: gpointer): gpointer; cdecl; inline; static;
    procedure foreach(hash_table: PGHashTable; func: TGHFunc; user_data: gpointer); cdecl; inline; static;
    function foreach_remove(hash_table: PGHashTable; func: TGHRFunc; user_data: gpointer): guint; cdecl; inline; static;
    function foreach_steal(hash_table: PGHashTable; func: TGHRFunc; user_data: gpointer): guint; cdecl; inline; static;
    function get_keys(hash_table: PGHashTable): PGList; cdecl; inline; static;
    function get_values(hash_table: PGHashTable): PGList; cdecl; inline; static;
    procedure insert(hash_table: PGHashTable; key: gpointer; value: gpointer); cdecl; inline; static;
    function lookup(hash_table: PGHashTable; key: Pgpointer): gpointer; cdecl; inline; static;
    function lookup_extended(hash_table: PGHashTable; lookup_key: Pgpointer; orig_key: Pgpointer; value: Pgpointer): gboolean; cdecl; inline; static;
    function new(hash_func: TGHashFunc; key_equal_func: TGEqualFunc): PGHashTable; cdecl; inline; static;
    function new_full(hash_func: TGHashFunc; key_equal_func: TGEqualFunc; key_destroy_func: TGDestroyNotify; value_destroy_func: TGDestroyNotify): PGHashTable; cdecl; inline; static;
    function ref(hash_table: PGHashTable): PGHashTable; cdecl; inline; static;
    function remove(hash_table: PGHashTable; key: Pgpointer): gboolean; cdecl; inline; static;
    procedure remove_all(hash_table: PGHashTable); cdecl; inline; static;
    procedure replace(hash_table: PGHashTable; key: gpointer; value: gpointer); cdecl; inline; static;
    function size(hash_table: PGHashTable): guint; cdecl; inline; static;
    function steal(hash_table: PGHashTable; key: Pgpointer): gboolean; cdecl; inline; static;
    procedure steal_all(hash_table: PGHashTable); cdecl; inline; static;
    procedure unref(hash_table: PGHashTable); cdecl; inline; static;
  end;

  PPGCopyFunc = ^PGCopyFunc;
  PGCopyFunc = ^TGCopyFunc;

  PPGFunc = ^PGFunc;
  PGFunc = ^TGFunc;
  TGList = object
    data: gpointer;
    next: PGList;
    prev: PGList;
    function alloc: PGList; cdecl; inline; static;
    function append(list: PGList; data: gpointer): PGList; cdecl; inline; static;
    function concat(list1: PGList; list2: PGList): PGList; cdecl; inline; static;
    function copy(list: PGList): PGList; cdecl; inline; static;
    function copy_deep(list: PGList; func: TGCopyFunc; user_data: gpointer): PGList; cdecl; inline; static;
    function delete_link(list: PGList; link_: PGList): PGList; cdecl; inline; static;
    function find(list: PGList; data: Pgpointer): PGList; cdecl; inline; static;
    function find_custom(list: PGList; data: Pgpointer; func: TGCompareFunc): PGList; cdecl; inline; static;
    function first(list: PGList): PGList; cdecl; inline; static;
    procedure foreach(list: PGList; func: TGFunc; user_data: gpointer); cdecl; inline; static;
    procedure free(list: PGList); cdecl; inline; static;
    procedure free_1(list: PGList); cdecl; inline; static;
    procedure free_full(list: PGList; free_func: TGDestroyNotify); cdecl; inline; static;
    function index(list: PGList; data: Pgpointer): gint; cdecl; inline; static;
    function insert(list: PGList; data: gpointer; position: gint): PGList; cdecl; inline; static;
    function insert_before(list: PGList; sibling: PGList; data: gpointer): PGList; cdecl; inline; static;
    function insert_sorted(list: PGList; data: gpointer; func: TGCompareFunc): PGList; cdecl; inline; static;
    function insert_sorted_with_data(list: PGList; data: gpointer; func: TGCompareDataFunc; user_data: gpointer): PGList; cdecl; inline; static;
    function last(list: PGList): PGList; cdecl; inline; static;
    function length(list: PGList): guint; cdecl; inline; static;
    function nth(list: PGList; n: guint): PGList; cdecl; inline; static;
    function nth_data(list: PGList; n: guint): gpointer; cdecl; inline; static;
    function nth_prev(list: PGList; n: guint): PGList; cdecl; inline; static;
    function position(list: PGList; llink: PGList): gint; cdecl; inline; static;
    function prepend(list: PGList; data: gpointer): PGList; cdecl; inline; static;
    function remove(list: PGList; data: Pgpointer): PGList; cdecl; inline; static;
    function remove_all(list: PGList; data: Pgpointer): PGList; cdecl; inline; static;
    function remove_link(list: PGList; llink: PGList): PGList; cdecl; inline; static;
    function reverse(list: PGList): PGList; cdecl; inline; static;
    function sort(list: PGList; compare_func: TGCompareFunc): PGList; cdecl; inline; static;
    function sort_with_data(list: PGList; compare_func: TGCompareDataFunc; user_data: gpointer): PGList; cdecl; inline; static;
  end;

  PPGHashTableIter = ^PGHashTableIter;
  PGHashTableIter = ^TGHashTableIter;
  TGHashTableIter = object
    dummy1: gpointer;
    dummy2: gpointer;
    dummy3: gpointer;
    dummy4: gint;
    dummy5: gboolean;
    dummy6: gpointer;
    function get_hash_table: PGHashTable; cdecl; inline;
    procedure init(hash_table: PGHashTable); cdecl; inline;
    function next(key: Pgpointer; value: Pgpointer): gboolean; cdecl; inline;
    procedure remove; cdecl; inline;
    procedure replace(value: gpointer); cdecl; inline;
    procedure steal; cdecl; inline;
  end;

  PPGHmac = ^PGHmac;
  PGHmac = ^TGHmac;
  TGHmac = object
    function copy: PGHmac; cdecl; inline;
    procedure get_digest(buffer: Pguint8; digest_len: Pgsize); cdecl; inline;
    function get_string: Pgchar; cdecl; inline;
    function ref: PGHmac; cdecl; inline;
    procedure unref; cdecl; inline;
    procedure update(data: Pguint8; length: gssize); cdecl; inline;
    function new(digest_type: TGChecksumType; key: Pguint8; key_len: gsize): PGHmac; cdecl; inline; static;
  end;

  PPGHook = ^PGHook;
  PGHook = ^TGHook;

  PPGHookList = ^PGHookList;
  PGHookList = ^TGHookList;

  PPPgulong = ^PPgulong;
  PPgulong = ^Pgulong;
  Pgulong = ^gulong;

  PPGHookFindFunc = ^PGHookFindFunc;
  PGHookFindFunc = ^TGHookFindFunc;
  TGHookFindFunc = function(hook: PGHook; data: gpointer): gboolean; cdecl;

  PPGHookCompareFunc = ^PGHookCompareFunc;
  PGHookCompareFunc = ^TGHookCompareFunc;
  TGHookCompareFunc = function(new_hook: PGHook; sibling: PGHook): gint; cdecl;
  TGHook = object
    data: gpointer;
    next: PGHook;
    prev: PGHook;
    ref_count: guint;
    hook_id: gulong;
    flags: guint;
    func: gpointer;
    destroy_1: TGDestroyNotify;
    function compare_ids(sibling: PGHook): gint; cdecl; inline;
    function alloc(hook_list: PGHookList): PGHook; cdecl; inline; static;
    function destroy_(hook_list: PGHookList; hook_id: gulong): gboolean; cdecl; inline; static;
    procedure destroy_link(hook_list: PGHookList; hook: PGHook); cdecl; inline; static;
    function find(hook_list: PGHookList; need_valids: gboolean; func: TGHookFindFunc; data: gpointer): PGHook; cdecl; inline; static;
    function find_data(hook_list: PGHookList; need_valids: gboolean; data: gpointer): PGHook; cdecl; inline; static;
    function find_func(hook_list: PGHookList; need_valids: gboolean; func: gpointer): PGHook; cdecl; inline; static;
    function find_func_data(hook_list: PGHookList; need_valids: gboolean; func: gpointer; data: gpointer): PGHook; cdecl; inline; static;
    function first_valid(hook_list: PGHookList; may_be_in_call: gboolean): PGHook; cdecl; inline; static;
    procedure free(hook_list: PGHookList; hook: PGHook); cdecl; inline; static;
    function get(hook_list: PGHookList; hook_id: gulong): PGHook; cdecl; inline; static;
    procedure insert_before(hook_list: PGHookList; sibling: PGHook; hook: PGHook); cdecl; inline; static;
    procedure insert_sorted(hook_list: PGHookList; hook: PGHook; func: TGHookCompareFunc); cdecl; inline; static;
    function next_valid(hook_list: PGHookList; hook: PGHook; may_be_in_call: gboolean): PGHook; cdecl; inline; static;
    procedure prepend(hook_list: PGHookList; hook: PGHook); cdecl; inline; static;
    function ref(hook_list: PGHookList; hook: PGHook): PGHook; cdecl; inline; static;
    procedure unref(hook_list: PGHookList; hook: PGHook); cdecl; inline; static;
  end;

  PPGHookMarshaller = ^PGHookMarshaller;
  PGHookMarshaller = ^TGHookMarshaller;
  TGHookMarshaller = procedure(hook: PGHook; marshal_data: gpointer); cdecl;

  PPGHookCheckMarshaller = ^PGHookCheckMarshaller;
  PGHookCheckMarshaller = ^TGHookCheckMarshaller;
  TGHookCheckMarshaller = function(hook: PGHook; marshal_data: gpointer): gboolean; cdecl;
  TGHookListBitfield0 = bitpacked record
    hook_size: guint16 { changed from guint to accomodate 16 bitsize requirement };
    is_setup: guint1 { changed from guint to accomodate 1 bitsize requirement };
  end;


  PPGHookFinalizeFunc = ^PGHookFinalizeFunc;
  PGHookFinalizeFunc = ^TGHookFinalizeFunc;
  TGHookFinalizeFunc = procedure(hook_list: PGHookList; hook: PGHook); cdecl;
  TGHookList = object
    seq_id: gulong;
    Bitfield0 : TGHookListBitfield0; { auto generated type }
    hooks: PGHook;
    dummy3: gpointer;
    finalize_hook: TGHookFinalizeFunc;
    dummy: array [0..1] of gpointer;
    procedure clear; cdecl; inline;
    procedure init(hook_size: guint); cdecl; inline;
    procedure invoke(may_recurse: gboolean); cdecl; inline;
    procedure invoke_check(may_recurse: gboolean); cdecl; inline;
    procedure marshal(may_recurse: gboolean; marshaller: TGHookMarshaller; marshal_data: gpointer); cdecl; inline;
    procedure marshal_check(may_recurse: gboolean; marshaller: TGHookCheckMarshaller; marshal_data: gpointer); cdecl; inline;
  end;
  TGHookCheckFunc = function(data: gpointer): gboolean; cdecl;

  PPGHookFlagMask = ^PGHookFlagMask;
  PGHookFlagMask = ^TGHookFlagMask;
  TGHookFunc = procedure(data: gpointer); cdecl;

  PPGIConv = ^PGIConv;
  PGIConv = ^TGIConv;
  TGIConv = object
    function g_iconv(inbuf: PPgchar; inbytes_left: Pgsize; outbuf: PPgchar; outbytes_left: Pgsize): gsize; cdecl; inline;
    function close: gint; cdecl; inline;
    function open(to_codeset: Pgchar; from_codeset: Pgchar): TGIConv; cdecl; inline; static;
  end;

  PPGIOFuncs = ^PGIOFuncs;
  PGIOFuncs = ^TGIOFuncs;

  PPGIOStatus = ^PGIOStatus;
  PGIOStatus = ^TGIOStatus;

  PPGIOChannel = ^PGIOChannel;
  PGIOChannel = ^TGIOChannel;

  PPGSeekType = ^PGSeekType;
  PGSeekType = ^TGSeekType;

  PPGSource = ^PGSource;
  PGSource = ^TGSource;

  PPGIOCondition = ^PGIOCondition;
  PGIOCondition = ^TGIOCondition;

  PPGIOFlags = ^PGIOFlags;
  PGIOFlags = ^TGIOFlags;

  TGIOFuncs = record
    io_read: function(channel: PGIOChannel; buf: Pgchar; count: gsize; bytes_read: Pgsize; error: PPGError): TGIOStatus; cdecl;
    io_write: function(channel: PGIOChannel; buf: Pgchar; count: gsize; bytes_written: Pgsize; error: PPGError): TGIOStatus; cdecl;
    io_seek: function(channel: PGIOChannel; offset: gint64; type_: TGSeekType; error: PPGError): TGIOStatus; cdecl;
    io_close: function(channel: PGIOChannel; error: PPGError): TGIOStatus; cdecl;
    io_create_watch: function(channel: PGIOChannel; condition: TGIOCondition): PGSource; cdecl;
    io_free: procedure(channel: PGIOChannel); cdecl;
    io_set_flags: function(channel: PGIOChannel; flags: TGIOFlags; error: PPGError): TGIOStatus; cdecl;
    io_get_flags: function(channel: PGIOChannel): TGIOFlags; cdecl;
  end;



  PPGString = ^PGString;
  PGString = ^TGString;

  PPPgunichar = ^PPgunichar;
  PPgunichar = ^Pgunichar;
  Pgunichar = ^gunichar;
  TGString = object
    str: Pgchar;
    len: gsize;
    allocated_len: gsize;
    function append(val: Pgchar): PGString; cdecl; inline;
    function append_c(c: gchar): PGString; cdecl; inline;
    function append_len(val: Pgchar; len: gssize): PGString; cdecl; inline;
    //procedure append_printf(format: Pgchar; args: array of const); cdecl; inline;
    function append_unichar(wc: gunichar): PGString; cdecl; inline;
    function append_uri_escaped(unescaped: Pgchar; reserved_chars_allowed: Pgchar; allow_utf8: gboolean): PGString; cdecl; inline;
    //procedure append_vprintf(format: Pgchar; args: Tva_list); cdecl; inline;
    function ascii_down: PGString; cdecl; inline;
    function ascii_up: PGString; cdecl; inline;
    function assign(rval: Pgchar): PGString; cdecl; inline;
    function equal(v2: PGString): gboolean; cdecl; inline;
    function erase(pos: gssize; len: gssize): PGString; cdecl; inline;
    function free(free_segment: gboolean): Pgchar; cdecl; inline;
    function free_to_bytes: PGBytes; cdecl; inline;
    function hash: guint; cdecl; inline;
    function insert(pos: gssize; val: Pgchar): PGString; cdecl; inline;
    function insert_c(pos: gssize; c: gchar): PGString; cdecl; inline;
    function insert_len(pos: gssize; val: Pgchar; len: gssize): PGString; cdecl; inline;
    function insert_unichar(pos: gssize; wc: gunichar): PGString; cdecl; inline;
    function overwrite(pos: gsize; val: Pgchar): PGString; cdecl; inline;
    function overwrite_len(pos: gsize; val: Pgchar; len: gssize): PGString; cdecl; inline;
    function prepend(val: Pgchar): PGString; cdecl; inline;
    function prepend_c(c: gchar): PGString; cdecl; inline;
    function prepend_len(val: Pgchar; len: gssize): PGString; cdecl; inline;
    function prepend_unichar(wc: gunichar): PGString; cdecl; inline;
    //procedure printf(format: Pgchar; args: array of const); cdecl; inline;
    function set_size(len: gsize): PGString; cdecl; inline;
    function truncate(len: gsize): PGString; cdecl; inline;
    //procedure vprintf(format: Pgchar; args: Tva_list); cdecl; inline;
  end;

  PPGIOChannelError = ^PGIOChannelError;
  PGIOChannelError = ^TGIOChannelError;
  TGIOChannelBitfield0 = bitpacked record
    use_buffer: guint1 { changed from guint to accomodate 1 bitsize requirement };
    do_encode: guint1 { changed from guint to accomodate 1 bitsize requirement };
    close_on_unref: guint1 { changed from guint to accomodate 1 bitsize requirement };
    is_readable: guint1 { changed from guint to accomodate 1 bitsize requirement };
    is_writeable: guint1 { changed from guint to accomodate 1 bitsize requirement };
    is_seekable: guint1 { changed from guint to accomodate 1 bitsize requirement };
  end;

  TGIOChannel = object
    ref_count: gint;
    funcs: PGIOFuncs;
    encoding: Pgchar;
    read_cd: TGIConv;
    write_cd: TGIConv;
    line_term: Pgchar;
    line_term_len: guint;
    buf_size: gsize;
    read_buf: PGString;
    encoded_read_buf: PGString;
    write_buf: PGString;
    partial_write_buf: array [0..5] of gchar;
    Bitfield0 : TGIOChannelBitfield0; { auto generated type }
    reserved1: gpointer;
    reserved2: gpointer;
    function new_file(filename: Pgchar; mode: Pgchar; error: PPGError): PGIOChannel; cdecl; inline; static;
    function unix_new(fd: gint): PGIOChannel; cdecl; inline; static;
    function flush(error: PPGError): TGIOStatus; cdecl; inline;
    function get_buffer_condition: TGIOCondition; cdecl; inline;
    function get_buffer_size: gsize; cdecl; inline;
    function get_buffered: gboolean; cdecl; inline;
    function get_close_on_unref: gboolean; cdecl; inline;
    function get_encoding: Pgchar; cdecl; inline;
    function get_flags: TGIOFlags; cdecl; inline;
    function get_line_term(length: Pgint): Pgchar; cdecl; inline;
    procedure init; cdecl; inline;
    function read_chars(buf: Pgchar; count: gsize; bytes_read: Pgsize; error: PPGError): TGIOStatus; cdecl; inline;
    function read_line(str_return: PPgchar; length: Pgsize; terminator_pos: Pgsize; error: PPGError): TGIOStatus; cdecl; inline;
    function read_line_string(buffer: PGString; terminator_pos: Pgsize; error: PPGError): TGIOStatus; cdecl; inline;
    function read_to_end(str_return: PPgchar; length: Pgsize; error: PPGError): TGIOStatus; cdecl; inline;
    function read_unichar(thechar: Pgunichar; error: PPGError): TGIOStatus; cdecl; inline;
    function ref: PGIOChannel; cdecl; inline;
    function seek_position(offset: gint64; type_: TGSeekType; error: PPGError): TGIOStatus; cdecl; inline;
    procedure set_buffer_size(size: gsize); cdecl; inline;
    procedure set_buffered(buffered: gboolean); cdecl; inline;
    procedure set_close_on_unref(do_close: gboolean); cdecl; inline;
    function set_encoding(encoding: Pgchar; error: PPGError): TGIOStatus; cdecl; inline;
    function set_flags(flags: TGIOFlags; error: PPGError): TGIOStatus; cdecl; inline;
    procedure set_line_term(line_term: Pgchar; length: gint); cdecl; inline;
    function shutdown(flush: gboolean; error: PPGError): TGIOStatus; cdecl; inline;
    function unix_get_fd: gint; cdecl; inline;
    procedure unref; cdecl; inline;
    function write_chars(buf: Pgchar; count: gssize; bytes_written: Pgsize; error: PPGError): TGIOStatus; cdecl; inline;
    function write_unichar(thechar: gunichar; error: PPGError): TGIOStatus; cdecl; inline;
    function error_from_errno(en: gint): TGIOChannelError; cdecl; inline; static;
    function error_quark: TGQuark; cdecl; inline; static;
  end;

  PPGIOError = ^PGIOError;
  PGIOError = ^TGIOError;
  TGIOFunc = function(source: PGIOChannel; condition: TGIOCondition; data: gpointer): gboolean; cdecl;

  PPGSourceFuncs = ^PGSourceFuncs;
  PGSourceFuncs = ^TGSourceFuncs;

  PPPGPollFD = ^PPGPollFD;
  PPGPollFD = ^PGPollFD;
  PGPollFD = ^TGPollFD;

  PPGMainContext = ^PGMainContext;
  PGMainContext = ^TGMainContext;

  PPGSourceFunc = ^PGSourceFunc;
  PGSourceFunc = ^TGSourceFunc;
  TGSourceFunc = function(user_data: gpointer): gboolean; cdecl;

  PPGSourceCallbackFuncs = ^PGSourceCallbackFuncs;
  PGSourceCallbackFuncs = ^TGSourceCallbackFuncs;

  PPGSList = ^PGSList;
  PGSList = ^TGSList;

  PPGSourcePrivate = ^PGSourcePrivate;
  PGSourcePrivate = ^TGSourcePrivate;
  TGSource = object
    callback_data: gpointer;
    callback_funcs: PGSourceCallbackFuncs;
    source_funcs: PGSourceFuncs;
    ref_count: guint;
    context: PGMainContext;
    priority: gint;
    flags: guint;
    source_id: guint;
    poll_fds: PGSList;
    prev: PGSource;
    next: PGSource;
    name: Pgchar;
    priv: PGSourcePrivate;
    function new(source_funcs: PGSourceFuncs; struct_size: guint): PGSource; cdecl; inline; static;
    procedure add_child_source(child_source: PGSource); cdecl; inline;
    procedure add_poll(fd: PGPollFD); cdecl; inline;
    function add_unix_fd(fd: gint; events: TGIOCondition): gpointer; cdecl; inline;
    function attach(context: PGMainContext): guint; cdecl; inline;
    procedure destroy_; cdecl; inline;
    function get_can_recurse: gboolean; cdecl; inline;
    function get_context: PGMainContext; cdecl; inline;
    function get_id: guint; cdecl; inline;
    function get_name: Pgchar; cdecl; inline;
    function get_priority: gint; cdecl; inline;
    function get_ready_time: gint64; cdecl; inline;
    function get_time: gint64; cdecl; inline;
    function is_destroyed: gboolean; cdecl; inline;
    procedure modify_unix_fd(tag: gpointer; new_events: TGIOCondition); cdecl; inline;
    function query_unix_fd(tag: gpointer): TGIOCondition; cdecl; inline;
    function ref: PGSource; cdecl; inline;
    procedure remove_child_source(child_source: PGSource); cdecl; inline;
    procedure remove_poll(fd: PGPollFD); cdecl; inline;
    procedure remove_unix_fd(tag: gpointer); cdecl; inline;
    procedure set_callback(func: TGSourceFunc; data: gpointer; notify: TGDestroyNotify); cdecl; inline;
    procedure set_callback_indirect(callback_data: gpointer; callback_funcs: PGSourceCallbackFuncs); cdecl; inline;
    procedure set_can_recurse(can_recurse: gboolean); cdecl; inline;
    procedure set_funcs(funcs: PGSourceFuncs); cdecl; inline;
    procedure set_name(name: Pgchar); cdecl; inline;
    procedure set_priority(priority: gint); cdecl; inline;
    procedure set_ready_time(ready_time: gint64); cdecl; inline;
    procedure unref; cdecl; inline;
    function remove(tag: guint): gboolean; cdecl; inline; static;
    function remove_by_funcs_user_data(funcs: PGSourceFuncs; user_data: gpointer): gboolean; cdecl; inline; static;
    function remove_by_user_data(user_data: gpointer): gboolean; cdecl; inline; static;
    procedure set_name_by_id(tag: guint; name: Pgchar); cdecl; inline; static;
  end;

  PPGKeyFile = ^PGKeyFile;
  PGKeyFile = ^TGKeyFile;

  PPGKeyFileFlags = ^PGKeyFileFlags;
  PGKeyFileFlags = ^TGKeyFileFlags;
  TGKeyFile = object
    function new: PGKeyFile; cdecl; inline; static;
    procedure free; cdecl; inline;
    function get_boolean(group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl; inline;
    function get_boolean_list(group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): Pgboolean; cdecl; inline;
    function get_comment(group_name: Pgchar; key: Pgchar; error: PPGError): Pgchar; cdecl; inline;
    function get_double(group_name: Pgchar; key: Pgchar; error: PPGError): gdouble; cdecl; inline;
    function get_double_list(group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): Pgdouble; cdecl; inline;
    function get_groups(length: Pgsize): PPgchar; cdecl; inline;
    function get_int64(group_name: Pgchar; key: Pgchar; error: PPGError): gint64; cdecl; inline;
    function get_integer(group_name: Pgchar; key: Pgchar; error: PPGError): gint; cdecl; inline;
    function get_integer_list(group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): Pgint; cdecl; inline;
    function get_keys(group_name: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; inline;
    function get_locale_string(group_name: Pgchar; key: Pgchar; locale: Pgchar; error: PPGError): Pgchar; cdecl; inline;
    function get_locale_string_list(group_name: Pgchar; key: Pgchar; locale: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; inline;
    function get_start_group: Pgchar; cdecl; inline;
    function get_string(group_name: Pgchar; key: Pgchar; error: PPGError): Pgchar; cdecl; inline;
    function get_string_list(group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; inline;
    function get_uint64(group_name: Pgchar; key: Pgchar; error: PPGError): guint64; cdecl; inline;
    function get_value(group_name: Pgchar; key: Pgchar; error: PPGError): Pgchar; cdecl; inline;
    function has_group(group_name: Pgchar): gboolean; cdecl; inline;
    function has_key(group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl; inline;
    function load_from_data(data: Pgchar; length: gsize; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl; inline;
    function load_from_data_dirs(file_: Pgchar; full_path: PPgchar; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl; inline;
    function load_from_dirs(file_: Pgchar; search_dirs: PPgchar; full_path: PPgchar; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl; inline;
    function load_from_file(file_: Pgchar; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl; inline;
    function ref: PGKeyFile; cdecl; inline;
    function remove_comment(group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl; inline;
    function remove_group(group_name: Pgchar; error: PPGError): gboolean; cdecl; inline;
    function remove_key(group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl; inline;
    procedure set_boolean(group_name: Pgchar; key: Pgchar; value: gboolean); cdecl; inline;
    procedure set_boolean_list(group_name: Pgchar; key: Pgchar; list: gboolean; length: gsize); cdecl; inline;
    function set_comment(group_name: Pgchar; key: Pgchar; comment: Pgchar; error: PPGError): gboolean; cdecl; inline;
    procedure set_double(group_name: Pgchar; key: Pgchar; value: gdouble); cdecl; inline;
    procedure set_double_list(group_name: Pgchar; key: Pgchar; list: gdouble; length: gsize); cdecl; inline;
    procedure set_int64(group_name: Pgchar; key: Pgchar; value: gint64); cdecl; inline;
    procedure set_integer(group_name: Pgchar; key: Pgchar; value: gint); cdecl; inline;
    procedure set_integer_list(group_name: Pgchar; key: Pgchar; list: gint; length: gsize); cdecl; inline;
    procedure set_list_separator(separator: gchar); cdecl; inline;
    procedure set_locale_string(group_name: Pgchar; key: Pgchar; locale: Pgchar; string_: Pgchar); cdecl; inline;
    procedure set_locale_string_list(group_name: Pgchar; key: Pgchar; locale: Pgchar; list: Pgchar; length: gsize); cdecl; inline;
    procedure set_string(group_name: Pgchar; key: Pgchar; string_: Pgchar); cdecl; inline;
    procedure set_string_list(group_name: Pgchar; key: Pgchar; list: Pgchar; length: gsize); cdecl; inline;
    procedure set_uint64(group_name: Pgchar; key: Pgchar; value: guint64); cdecl; inline;
    procedure set_value(group_name: Pgchar; key: Pgchar; value: Pgchar); cdecl; inline;
    function to_data(length: Pgsize; error: PPGError): Pgchar; cdecl; inline;
    procedure unref; cdecl; inline;
    function error_quark: TGQuark; cdecl; inline; static;
  end;

  PPGKeyFileError = ^PGKeyFileError;
  PGKeyFileError = ^TGKeyFileError;

  PPGLogLevelFlags = ^PGLogLevelFlags;
  PGLogLevelFlags = ^TGLogLevelFlags;
  TGLogFunc = procedure(log_domain: Pgchar; log_level: TGLogLevelFlags; message: Pgchar; user_data: gpointer); cdecl;

  PPGPollFunc = ^PGPollFunc;
  PGPollFunc = ^TGPollFunc;
  TGPollFunc = function(ufds: PGPollFD; nfsd: guint; timeout_: gint): gint; cdecl;
  TGMainContext = object
    function new: PGMainContext; cdecl; inline; static;
    function acquire: gboolean; cdecl; inline;
    procedure add_poll(fd: PGPollFD; priority: gint); cdecl; inline;
    function check(max_priority: gint; fds: PGPollFD; n_fds: gint): gint; cdecl; inline;
    procedure dispatch; cdecl; inline;
    function find_source_by_funcs_user_data(funcs: PGSourceFuncs; user_data: gpointer): PGSource; cdecl; inline;
    function find_source_by_id(source_id: guint): PGSource; cdecl; inline;
    function find_source_by_user_data(user_data: gpointer): PGSource; cdecl; inline;
    function get_poll_func: TGPollFunc; cdecl; inline;
    procedure invoke(function_: TGSourceFunc; data: gpointer); cdecl; inline;
    procedure invoke_full(priority: gint; function_: TGSourceFunc; data: gpointer; notify: TGDestroyNotify); cdecl; inline;
    function is_owner: gboolean; cdecl; inline;
    function iteration(may_block: gboolean): gboolean; cdecl; inline;
    function pending: gboolean; cdecl; inline;
    procedure pop_thread_default; cdecl; inline;
    function prepare(priority: Pgint): gboolean; cdecl; inline;
    procedure push_thread_default; cdecl; inline;
    function query(max_priority: gint; timeout_: Pgint; fds: PGPollFD; n_fds: gint): gint; cdecl; inline;
    function ref: PGMainContext; cdecl; inline;
    procedure release; cdecl; inline;
    procedure remove_poll(fd: PGPollFD); cdecl; inline;
    procedure set_poll_func(func: TGPollFunc); cdecl; inline;
    procedure unref; cdecl; inline;
    function wait(cond: PGCond; mutex: PGMutex): gboolean; cdecl; inline;
    procedure wakeup; cdecl; inline;
    function default_: PGMainContext; cdecl; inline; static;
    function get_thread_default: PGMainContext; cdecl; inline; static;
    function ref_thread_default: PGMainContext; cdecl; inline; static;
  end;

  PPPgushort = ^PPgushort;
  PPgushort = ^Pgushort;
  Pgushort = ^gushort;
  TGPollFD = object
    fd: gint;
    events: gushort;
    revents: gushort;
  end;

  PPGSourceDummyMarshal = ^PGSourceDummyMarshal;
  PGSourceDummyMarshal = ^TGSourceDummyMarshal;
  TGSourceDummyMarshal = procedure; cdecl;

  TGSourceFuncs = record
    prepare: function(source: PGSource; timeout_: Pgint): gboolean; cdecl;
    check: function(source: PGSource): gboolean; cdecl;
    dispatch: function(source: PGSource; callback: TGSourceFunc; user_data: gpointer): gboolean; cdecl;
    finalize: procedure(source: PGSource); cdecl;
    closure_callback: TGSourceFunc;
    closure_marshal: TGSourceDummyMarshal;
  end;



  PPGMainLoop = ^PGMainLoop;
  PGMainLoop = ^TGMainLoop;
  TGMainLoop = object
    function new(context: PGMainContext; is_running: gboolean): PGMainLoop; cdecl; inline; static;
    function get_context: PGMainContext; cdecl; inline;
    function is_running: gboolean; cdecl; inline;
    procedure quit; cdecl; inline;
    function ref: PGMainLoop; cdecl; inline;
    procedure run; cdecl; inline;
    procedure unref; cdecl; inline;
  end;

  PPGMappedFile = ^PGMappedFile;
  PGMappedFile = ^TGMappedFile;
  TGMappedFile = object
    function get_bytes: PGBytes; cdecl; inline;
    function get_contents: Pgchar; cdecl; inline;
    function get_length: gsize; cdecl; inline;
    function ref: PGMappedFile; cdecl; inline;
    procedure unref; cdecl; inline;
    function new(filename: Pgchar; writable: gboolean; error: PPGError): PGMappedFile; cdecl; inline; static;
    function new_from_fd(fd: gint; writable: gboolean; error: PPGError): PGMappedFile; cdecl; inline; static;
  end;

  PPGMarkupCollectType = ^PGMarkupCollectType;
  PGMarkupCollectType = ^TGMarkupCollectType;

  PPGMarkupError = ^PGMarkupError;
  PGMarkupError = ^TGMarkupError;

  PPGMarkupParseContext = ^PGMarkupParseContext;
  PGMarkupParseContext = ^TGMarkupParseContext;

  PPGMarkupParser = ^PGMarkupParser;
  PGMarkupParser = ^TGMarkupParser;

  PPGMarkupParseFlags = ^PGMarkupParseFlags;
  PGMarkupParseFlags = ^TGMarkupParseFlags;
  TGMarkupParseContext = object
    function new(parser: PGMarkupParser; flags: TGMarkupParseFlags; user_data: gpointer; user_data_dnotify: TGDestroyNotify): PGMarkupParseContext; cdecl; inline; static;
    function end_parse(error: PPGError): gboolean; cdecl; inline;
    procedure free; cdecl; inline;
    function get_element: Pgchar; cdecl; inline;
    function get_element_stack: PGSList; cdecl; inline;
    procedure get_position(line_number: Pgint; char_number: Pgint); cdecl; inline;
    function get_user_data: gpointer; cdecl; inline;
    function parse(text: Pgchar; text_len: gssize; error: PPGError): gboolean; cdecl; inline;
    function pop: gpointer; cdecl; inline;
    procedure push(parser: PGMarkupParser; user_data: gpointer); cdecl; inline;
    function ref: PGMarkupParseContext; cdecl; inline;
    procedure unref; cdecl; inline;
  end;

  TGMarkupParser = record
    start_element: procedure(context: PGMarkupParseContext; element_name: Pgchar; attribute_names: PPgchar; attribute_values: PPgchar; user_data: gpointer; error: PPGError); cdecl;
    end_element: procedure(context: PGMarkupParseContext; element_name: Pgchar; user_data: gpointer; error: PPGError); cdecl;
    text: procedure(context: PGMarkupParseContext; text: Pgchar; text_len: gsize; user_data: gpointer; error: PPGError); cdecl;
    passthrough: procedure(context: PGMarkupParseContext; passthrough_text: Pgchar; text_len: gsize; user_data: gpointer; error: PPGError); cdecl;
    error: procedure(context: PGMarkupParseContext; error: PGError; user_data: gpointer); cdecl;
  end;


  TGSList = object
    data: gpointer;
    next: PGSList;
    function alloc: PGSList; cdecl; inline; static;
    function append(list: PGSList; data: gpointer): PGSList; cdecl; inline; static;
    function concat(list1: PGSList; list2: PGSList): PGSList; cdecl; inline; static;
    function copy(list: PGSList): PGSList; cdecl; inline; static;
    function copy_deep(list: PGSList; func: TGCopyFunc; user_data: gpointer): PGSList; cdecl; inline; static;
    function delete_link(list: PGSList; link_: PGSList): PGSList; cdecl; inline; static;
    function find(list: PGSList; data: Pgpointer): PGSList; cdecl; inline; static;
    function find_custom(list: PGSList; data: Pgpointer; func: TGCompareFunc): PGSList; cdecl; inline; static;
    procedure foreach(list: PGSList; func: TGFunc; user_data: gpointer); cdecl; inline; static;
    procedure free(list: PGSList); cdecl; inline; static;
    procedure free_1(list: PGSList); cdecl; inline; static;
    procedure free_full(list: PGSList; free_func: TGDestroyNotify); cdecl; inline; static;
    function index(list: PGSList; data: Pgpointer): gint; cdecl; inline; static;
    function insert(list: PGSList; data: gpointer; position: gint): PGSList; cdecl; inline; static;
    function insert_before(slist: PGSList; sibling: PGSList; data: gpointer): PGSList; cdecl; inline; static;
    function insert_sorted(list: PGSList; data: gpointer; func: TGCompareFunc): PGSList; cdecl; inline; static;
    function insert_sorted_with_data(list: PGSList; data: gpointer; func: TGCompareDataFunc; user_data: gpointer): PGSList; cdecl; inline; static;
    function last(list: PGSList): PGSList; cdecl; inline; static;
    function length(list: PGSList): guint; cdecl; inline; static;
    function nth(list: PGSList; n: guint): PGSList; cdecl; inline; static;
    function nth_data(list: PGSList; n: guint): gpointer; cdecl; inline; static;
    function position(list: PGSList; llink: PGSList): gint; cdecl; inline; static;
    function prepend(list: PGSList; data: gpointer): PGSList; cdecl; inline; static;
    function remove(list: PGSList; data: Pgpointer): PGSList; cdecl; inline; static;
    function remove_all(list: PGSList; data: Pgpointer): PGSList; cdecl; inline; static;
    function remove_link(list: PGSList; link_: PGSList): PGSList; cdecl; inline; static;
    function reverse(list: PGSList): PGSList; cdecl; inline; static;
    function sort(list: PGSList; compare_func: TGCompareFunc): PGSList; cdecl; inline; static;
    function sort_with_data(list: PGSList; compare_func: TGCompareDataFunc; user_data: gpointer): PGSList; cdecl; inline; static;
  end;

  PPGMatchInfo = ^PGMatchInfo;
  PGMatchInfo = ^TGMatchInfo;

  PPGRegex = ^PGRegex;
  PGRegex = ^TGRegex;
  TGMatchInfo = object
    function expand_references(string_to_expand: Pgchar; error: PPGError): Pgchar; cdecl; inline;
    function fetch(match_num: gint): Pgchar; cdecl; inline;
    function fetch_all: PPgchar; cdecl; inline;
    function fetch_named(name: Pgchar): Pgchar; cdecl; inline;
    function fetch_named_pos(name: Pgchar; start_pos: Pgint; end_pos: Pgint): gboolean; cdecl; inline;
    function fetch_pos(match_num: gint; start_pos: Pgint; end_pos: Pgint): gboolean; cdecl; inline;
    procedure free; cdecl; inline;
    function get_match_count: gint; cdecl; inline;
    function get_regex: PGRegex; cdecl; inline;
    function get_string: Pgchar; cdecl; inline;
    function is_partial_match: gboolean; cdecl; inline;
    function matches: gboolean; cdecl; inline;
    function next(error: PPGError): gboolean; cdecl; inline;
    function ref: PGMatchInfo; cdecl; inline;
    procedure unref; cdecl; inline;
  end;

  PPGRegexCompileFlags = ^PGRegexCompileFlags;
  PGRegexCompileFlags = ^TGRegexCompileFlags;

  PPGRegexMatchFlags = ^PGRegexMatchFlags;
  PGRegexMatchFlags = ^TGRegexMatchFlags;

  PPGRegexEvalCallback = ^PGRegexEvalCallback;
  PGRegexEvalCallback = ^TGRegexEvalCallback;
  TGRegexEvalCallback = function(match_info: PGMatchInfo; result_: PGString; user_data: gpointer): gboolean; cdecl;
  TGRegex = object
    function new(pattern: Pgchar; compile_options: TGRegexCompileFlags; match_options: TGRegexMatchFlags; error: PPGError): PGRegex; cdecl; inline; static;
    function get_capture_count: gint; cdecl; inline;
    function get_compile_flags: TGRegexCompileFlags; cdecl; inline;
    function get_has_cr_or_lf: gboolean; cdecl; inline;
    function get_match_flags: TGRegexMatchFlags; cdecl; inline;
    function get_max_backref: gint; cdecl; inline;
    function get_pattern: Pgchar; cdecl; inline;
    function get_string_number(name: Pgchar): gint; cdecl; inline;
    function match(string_: Pgchar; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo): gboolean; cdecl; inline;
    function match_all(string_: Pgchar; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo): gboolean; cdecl; inline;
    function match_all_full(string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo; error: PPGError): gboolean; cdecl; inline;
    function match_full(string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo; error: PPGError): gboolean; cdecl; inline;
    function ref: PGRegex; cdecl; inline;
    function replace(string_: Pgchar; string_len: gssize; start_position: gint; replacement: Pgchar; match_options: TGRegexMatchFlags; error: PPGError): Pgchar; cdecl; inline;
    function replace_eval(string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; eval: TGRegexEvalCallback; user_data: gpointer; error: PPGError): Pgchar; cdecl; inline;
    function replace_literal(string_: Pgchar; string_len: gssize; start_position: gint; replacement: Pgchar; match_options: TGRegexMatchFlags; error: PPGError): Pgchar; cdecl; inline;
    function split(string_: Pgchar; match_options: TGRegexMatchFlags): PPgchar; cdecl; inline;
    function split_full(string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; max_tokens: gint; error: PPGError): PPgchar; cdecl; inline;
    procedure unref; cdecl; inline;
    function check_replacement(replacement: Pgchar; has_references: Pgboolean; error: PPGError): gboolean; cdecl; inline; static;
    function error_quark: TGQuark; cdecl; inline; static;
    function escape_nul(string_: Pgchar; length: gint): Pgchar; cdecl; inline; static;
    function escape_string(string_: Pgchar; length: gint): Pgchar; cdecl; inline; static;
    function match_simple(pattern: Pgchar; string_: Pgchar; compile_options: TGRegexCompileFlags; match_options: TGRegexMatchFlags): gboolean; cdecl; inline; static;
    function split_simple(pattern: Pgchar; string_: Pgchar; compile_options: TGRegexCompileFlags; match_options: TGRegexMatchFlags): PPgchar; cdecl; inline; static;
  end;

  PPGMemVTable = ^PGMemVTable;
  PGMemVTable = ^TGMemVTable;

  TGMemVTable = record
    malloc: function(n_bytes: gsize): gpointer; cdecl;
    realloc: function(mem: gpointer; n_bytes: gsize): gpointer; cdecl;
    free: procedure(mem: gpointer); cdecl;
    calloc: function(n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl;
    try_malloc: function(n_bytes: gsize): gpointer; cdecl;
    try_realloc: function(mem: gpointer; n_bytes: gsize): gpointer; cdecl;
  end;



  PPGNode = ^PGNode;
  PGNode = ^TGNode;

  PPGTraverseFlags = ^PGTraverseFlags;
  PGTraverseFlags = ^TGTraverseFlags;

  PPGNodeForeachFunc = ^PGNodeForeachFunc;
  PGNodeForeachFunc = ^TGNodeForeachFunc;
  TGNodeForeachFunc = procedure(node: PGNode; data: gpointer); cdecl;

  PPGTraverseType = ^PGTraverseType;
  PGTraverseType = ^TGTraverseType;

  PPGNodeTraverseFunc = ^PGNodeTraverseFunc;
  PGNodeTraverseFunc = ^TGNodeTraverseFunc;
  TGNodeTraverseFunc = function(node: PGNode; data: gpointer): gboolean; cdecl;
  TGNode = object
    data: gpointer;
    next: PGNode;
    prev: PGNode;
    parent: PGNode;
    children: PGNode;
    function child_index(data: gpointer): gint; cdecl; inline;
    function child_position(child: PGNode): gint; cdecl; inline;
    procedure children_foreach(flags: TGTraverseFlags; func: TGNodeForeachFunc; data: gpointer); cdecl; inline;
    function copy: PGNode; cdecl; inline;
    function copy_deep(copy_func: TGCopyFunc; data: gpointer): PGNode; cdecl; inline;
    function depth: guint; cdecl; inline;
    procedure destroy_; cdecl; inline;
    function find(order: TGTraverseType; flags: TGTraverseFlags; data: gpointer): PGNode; cdecl; inline;
    function find_child(flags: TGTraverseFlags; data: gpointer): PGNode; cdecl; inline;
    function first_sibling: PGNode; cdecl; inline;
    function get_root: PGNode; cdecl; inline;
    function insert(position: gint; node: PGNode): PGNode; cdecl; inline;
    function insert_after(sibling: PGNode; node: PGNode): PGNode; cdecl; inline;
    function insert_before(sibling: PGNode; node: PGNode): PGNode; cdecl; inline;
    function is_ancestor(descendant: PGNode): gboolean; cdecl; inline;
    function last_child: PGNode; cdecl; inline;
    function last_sibling: PGNode; cdecl; inline;
    function max_height: guint; cdecl; inline;
    function n_children: guint; cdecl; inline;
    function n_nodes(flags: TGTraverseFlags): guint; cdecl; inline;
    function nth_child(n: guint): PGNode; cdecl; inline;
    function prepend(node: PGNode): PGNode; cdecl; inline;
    procedure reverse_children; cdecl; inline;
    procedure traverse(order: TGTraverseType; flags: TGTraverseFlags; max_depth: gint; func: TGNodeTraverseFunc; data: gpointer); cdecl; inline;
    procedure unlink; cdecl; inline;
    function new(data: gpointer): PGNode; cdecl; inline; static;
  end;

  PPGNormalizeMode = ^PGNormalizeMode;
  PGNormalizeMode = ^TGNormalizeMode;

  PPGOnceStatus = ^PGOnceStatus;
  PGOnceStatus = ^TGOnceStatus;

  PPGOnce = ^PGOnce;
  PGOnce = ^TGOnce;

  PPGThreadFunc = ^PGThreadFunc;
  PGThreadFunc = ^TGThreadFunc;
  TGThreadFunc = function(data: gpointer): gpointer; cdecl;
  TGOnce = object
    status: TGOnceStatus;
    retval: gpointer;
    function impl(func: TGThreadFunc; arg: gpointer): gpointer; cdecl; inline;
    function init_enter(location: Pgpointer): gboolean; cdecl; inline; static;
    procedure init_leave(location: Pgpointer; result_: gsize); cdecl; inline; static;
  end;

  PPGOptionArg = ^PGOptionArg;
  PGOptionArg = ^TGOptionArg;
  TGOptionArgFunc = function(option_name: Pgchar; value: Pgchar; data: gpointer; error: PPGError): gboolean; cdecl;

  PPGOptionContext = ^PGOptionContext;
  PGOptionContext = ^TGOptionContext;

  PPGOptionGroup = ^PGOptionGroup;
  PGOptionGroup = ^TGOptionGroup;

  PPGOptionEntry = ^PGOptionEntry;
  PGOptionEntry = ^TGOptionEntry;

  PPGTranslateFunc = ^PGTranslateFunc;
  PGTranslateFunc = ^TGTranslateFunc;
  TGTranslateFunc = function(str: Pgchar; data: gpointer): Pgchar; cdecl;
  TGOptionContext = object
    procedure add_group(group: PGOptionGroup); cdecl; inline;
    procedure add_main_entries(entries: PGOptionEntry; translation_domain: Pgchar); cdecl; inline;
    procedure free; cdecl; inline;
    function get_description: Pgchar; cdecl; inline;
    function get_help(main_help: gboolean; group: PGOptionGroup): Pgchar; cdecl; inline;
    function get_help_enabled: gboolean; cdecl; inline;
    function get_ignore_unknown_options: gboolean; cdecl; inline;
    function get_main_group: PGOptionGroup; cdecl; inline;
    function get_summary: Pgchar; cdecl; inline;
    function parse(argc: Pgint; argv: PPPgchar; error: PPGError): gboolean; cdecl; inline;
    procedure set_description(description: Pgchar); cdecl; inline;
    procedure set_help_enabled(help_enabled: gboolean); cdecl; inline;
    procedure set_ignore_unknown_options(ignore_unknown: gboolean); cdecl; inline;
    procedure set_main_group(group: PGOptionGroup); cdecl; inline;
    procedure set_summary(summary: Pgchar); cdecl; inline;
    procedure set_translate_func(func: TGTranslateFunc; data: gpointer; destroy_notify: TGDestroyNotify); cdecl; inline;
    procedure set_translation_domain(domain: Pgchar); cdecl; inline;
    function new(parameter_string: Pgchar): PGOptionContext; cdecl; inline; static;
  end;

  PPGOptionErrorFunc = ^PGOptionErrorFunc;
  PGOptionErrorFunc = ^TGOptionErrorFunc;
  TGOptionErrorFunc = procedure(context: PGOptionContext; group: PGOptionGroup; data: gpointer; error: PPGError); cdecl;

  PPGOptionParseFunc = ^PGOptionParseFunc;
  PGOptionParseFunc = ^TGOptionParseFunc;
  TGOptionParseFunc = function(context: PGOptionContext; group: PGOptionGroup; data: gpointer; error: PPGError): gboolean; cdecl;
  TGOptionGroup = object
    procedure add_entries(entries: PGOptionEntry); cdecl; inline;
    procedure free; cdecl; inline;
    procedure set_error_hook(error_func: TGOptionErrorFunc); cdecl; inline;
    procedure set_parse_hooks(pre_parse_func: TGOptionParseFunc; post_parse_func: TGOptionParseFunc); cdecl; inline;
    procedure set_translate_func(func: TGTranslateFunc; data: gpointer; destroy_notify: TGDestroyNotify); cdecl; inline;
    procedure set_translation_domain(domain: Pgchar); cdecl; inline;
    function new(name: Pgchar; description: Pgchar; help_description: Pgchar; user_data: gpointer; destroy_: TGDestroyNotify): PGOptionGroup; cdecl; inline; static;
  end;

  TGOptionEntry = record
    long_name: Pgchar;
    short_name: gchar;
    flags: gint;
    arg: TGOptionArg;
    arg_data: gpointer;
    description: Pgchar;
    arg_description: Pgchar;
  end;



  PPGOptionError = ^PGOptionError;
  PGOptionError = ^TGOptionError;

  PPGOptionFlags = ^PGOptionFlags;
  PGOptionFlags = ^TGOptionFlags;

  PPGPatternSpec = ^PGPatternSpec;
  PGPatternSpec = ^TGPatternSpec;
  TGPatternSpec = object
    function equal(pspec2: PGPatternSpec): gboolean; cdecl; inline;
    procedure free; cdecl; inline;
    function new(pattern: Pgchar): PGPatternSpec; cdecl; inline; static;
  end;
  TGPrintFunc = procedure(string_: Pgchar); cdecl;

  PPGPrivate = ^PGPrivate;
  PGPrivate = ^TGPrivate;
  TGPrivate = object
    p: gpointer;
    notify: TGDestroyNotify;
    future: array [0..1] of gpointer;
    function get: gpointer; cdecl; inline;
    procedure replace(value: gpointer); cdecl; inline;
    procedure set_(value: gpointer); cdecl; inline;
  end;

  PPGPtrArray = ^PGPtrArray;
  PGPtrArray = ^TGPtrArray;
  TGPtrArray = object
    pdata: Pgpointer;
    len: guint;
    procedure add(array_: Pgpointer; data: gpointer); cdecl; inline; static;
    procedure foreach(array_: Pgpointer; func: TGFunc; user_data: gpointer); cdecl; inline; static;
    function free(array_: Pgpointer; free_seg: gboolean): Pgpointer; cdecl; inline; static;
    function new: Pgpointer; cdecl; inline; static;
    function new_full(reserved_size: guint; element_free_func: TGDestroyNotify): Pgpointer; cdecl; inline; static;
    function new_with_free_func(element_free_func: TGDestroyNotify): Pgpointer; cdecl; inline; static;
    function ref(array_: Pgpointer): Pgpointer; cdecl; inline; static;
    function remove(array_: Pgpointer; data: gpointer): gboolean; cdecl; inline; static;
    function remove_fast(array_: Pgpointer; data: gpointer): gboolean; cdecl; inline; static;
    function remove_index(array_: Pgpointer; index_: guint): gpointer; cdecl; inline; static;
    function remove_index_fast(array_: Pgpointer; index_: guint): gpointer; cdecl; inline; static;
    procedure remove_range(array_: Pgpointer; index_: guint; length: guint); cdecl; inline; static;
    procedure set_free_func(array_: Pgpointer; element_free_func: TGDestroyNotify); cdecl; inline; static;
    procedure set_size(array_: Pgpointer; length: gint); cdecl; inline; static;
    function sized_new(reserved_size: guint): Pgpointer; cdecl; inline; static;
    procedure sort(array_: Pgpointer; compare_func: TGCompareFunc); cdecl; inline; static;
    procedure sort_with_data(array_: Pgpointer; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; inline; static;
    procedure unref(array_: Pgpointer); cdecl; inline; static;
  end;

  PPGQueue = ^PGQueue;
  PGQueue = ^TGQueue;
  TGQueue = object
    head: PGList;
    tail: PGList;
    length: guint;
    procedure clear; cdecl; inline;
    function copy: PGQueue; cdecl; inline;
    procedure delete_link(link_: PGList); cdecl; inline;
    function find(data: Pgpointer): PGList; cdecl; inline;
    function find_custom(data: Pgpointer; func: TGCompareFunc): PGList; cdecl; inline;
    procedure foreach(func: TGFunc; user_data: gpointer); cdecl; inline;
    procedure free; cdecl; inline;
    procedure free_full(free_func: TGDestroyNotify); cdecl; inline;
    function get_length: guint; cdecl; inline;
    function index(data: Pgpointer): gint; cdecl; inline;
    procedure init; cdecl; inline;
    procedure insert_after(sibling: PGList; data: gpointer); cdecl; inline;
    procedure insert_before(sibling: PGList; data: gpointer); cdecl; inline;
    procedure insert_sorted(data: gpointer; func: TGCompareDataFunc; user_data: gpointer); cdecl; inline;
    function is_empty: gboolean; cdecl; inline;
    function link_index(link_: PGList): gint; cdecl; inline;
    function peek_head: gpointer; cdecl; inline;
    function peek_head_link: PGList; cdecl; inline;
    function peek_nth(n: guint): gpointer; cdecl; inline;
    function peek_nth_link(n: guint): PGList; cdecl; inline;
    function peek_tail: gpointer; cdecl; inline;
    function peek_tail_link: PGList; cdecl; inline;
    function pop_head: gpointer; cdecl; inline;
    function pop_head_link: PGList; cdecl; inline;
    function pop_nth(n: guint): gpointer; cdecl; inline;
    function pop_nth_link(n: guint): PGList; cdecl; inline;
    function pop_tail: gpointer; cdecl; inline;
    function pop_tail_link: PGList; cdecl; inline;
    procedure push_head(data: gpointer); cdecl; inline;
    procedure push_head_link(link_: PGList); cdecl; inline;
    procedure push_nth(data: gpointer; n: gint); cdecl; inline;
    procedure push_nth_link(n: gint; link_: PGList); cdecl; inline;
    procedure push_tail(data: gpointer); cdecl; inline;
    procedure push_tail_link(link_: PGList); cdecl; inline;
    function remove(data: Pgpointer): gboolean; cdecl; inline;
    function remove_all(data: Pgpointer): guint; cdecl; inline;
    procedure reverse; cdecl; inline;
    procedure sort(compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; inline;
    procedure unlink(link_: PGList); cdecl; inline;
    function new: PGQueue; cdecl; inline; static;
  end;

  PPGRWLock = ^PGRWLock;
  PGRWLock = ^TGRWLock;
  TGRWLock = object
    p: gpointer;
    i: array [0..1] of guint;
    procedure clear; cdecl; inline;
    procedure init; cdecl; inline;
    procedure reader_lock; cdecl; inline;
    function reader_trylock: gboolean; cdecl; inline;
    procedure reader_unlock; cdecl; inline;
    procedure writer_lock; cdecl; inline;
    function writer_trylock: gboolean; cdecl; inline;
    procedure writer_unlock; cdecl; inline;
  end;

  PPGRand = ^PGRand;
  PGRand = ^TGRand;
  TGRand = object
    function copy: PGRand; cdecl; inline;
    function double: gdouble; cdecl; inline;
    function double_range(begin_: gdouble; end_: gdouble): gdouble; cdecl; inline;
    procedure free; cdecl; inline;
    function int: guint32; cdecl; inline;
    function int_range(begin_: gint32; end_: gint32): gint32; cdecl; inline;
    procedure set_seed(seed: guint32); cdecl; inline;
    procedure set_seed_array(seed: Pguint32; seed_length: guint); cdecl; inline;
    function new: PGRand; cdecl; inline; static;
    function new_with_seed(seed: guint32): PGRand; cdecl; inline; static;
    function new_with_seed_array(seed: Pguint32; seed_length: guint): PGRand; cdecl; inline; static;
  end;

  PPGRecMutex = ^PGRecMutex;
  PGRecMutex = ^TGRecMutex;
  TGRecMutex = object
    p: gpointer;
    i: array [0..1] of guint;
    procedure clear; cdecl; inline;
    procedure init; cdecl; inline;
    procedure lock; cdecl; inline;
    function trylock: gboolean; cdecl; inline;
    procedure unlock; cdecl; inline;
  end;

  PPGRegexError = ^PGRegexError;
  PGRegexError = ^TGRegexError;

  PPGScannerConfig = ^PGScannerConfig;
  PGScannerConfig = ^TGScannerConfig;
  TGScannerConfigBitfield0 = bitpacked record
    case_sensitive: guint1 { changed from guint to accomodate 1 bitsize requirement };
    skip_comment_multi: guint1 { changed from guint to accomodate 1 bitsize requirement };
    skip_comment_single: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_comment_multi: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_identifier: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_identifier_1char: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_identifier_NULL: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_symbols: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_binary: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_octal: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_float: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_hex: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_hex_dollar: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_string_sq: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_string_dq: guint1 { changed from guint to accomodate 1 bitsize requirement };
    numbers_2_int: guint1 { changed from guint to accomodate 1 bitsize requirement };
    int_2_float: guint1 { changed from guint to accomodate 1 bitsize requirement };
    identifier_2_string: guint1 { changed from guint to accomodate 1 bitsize requirement };
    char_2_token: guint1 { changed from guint to accomodate 1 bitsize requirement };
    symbol_2_token: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scope_0_fallback: guint1 { changed from guint to accomodate 1 bitsize requirement };
    store_int64: guint1 { changed from guint to accomodate 1 bitsize requirement };
  end;


  TGScannerConfig = record
    cset_skip_characters: Pgchar;
    cset_identifier_first: Pgchar;
    cset_identifier_nth: Pgchar;
    cpair_comment_single: Pgchar;
    Bitfield0 : TGScannerConfigBitfield0; { auto generated type }
    padding_dummy: guint;
  end;



  PPGTokenType = ^PGTokenType;
  PGTokenType = ^TGTokenType;
  TGTokenValue = record
    case longint of
      0 : (v_symbol: gpointer);
      1 : (v_identifier: Pgchar);
      2 : (v_binary: gulong);
      3 : (v_octal: gulong);
      4 : (v_int: gulong);
      5 : (v_int64: guint64);
      6 : (v_float: gdouble);
      7 : (v_hex: gulong);
      8 : (v_string: Pgchar);
      9 : (v_comment: Pgchar);
      10 : (v_char: guint8);
      11 : (v_error: guint);
  end;



  PPGScanner = ^PGScanner;
  PGScanner = ^TGScanner;
  TGScannerMsgFunc = procedure(scanner: PGScanner; message: Pgchar; error: gboolean); cdecl;

  PPGTokenValue = ^PGTokenValue;
  PGTokenValue = ^TGTokenValue;

  PPGScannerMsgFunc = ^PGScannerMsgFunc;
  PGScannerMsgFunc = ^TGScannerMsgFunc;
  TGScanner = object
    user_data: gpointer;
    max_parse_errors: guint;
    parse_errors: guint;
    input_name: Pgchar;
    qdata: PGData;
    config: PGScannerConfig;
    token: TGTokenType;
    value: TGTokenValue;
    line: guint;
    position: guint;
    next_token: TGTokenType;
    next_value: TGTokenValue;
    next_line: guint;
    next_position: guint;
    symbol_table: PGHashTable;
    input_fd: gint;
    text: Pgchar;
    text_end: Pgchar;
    buffer: Pgchar;
    scope_id: guint;
    msg_handler: TGScannerMsgFunc;
    function cur_line: guint; cdecl; inline;
    function cur_position: guint; cdecl; inline;
    function cur_token: TGTokenType; cdecl; inline;
    function cur_value: TGTokenValue; cdecl; inline;
    procedure destroy_; cdecl; inline;
    function eof: gboolean; cdecl; inline;
    //procedure error(format: Pgchar; args: array of const); cdecl; inline;
    function get_next_token: TGTokenType; cdecl; inline;
    procedure input_file(input_fd: gint); cdecl; inline;
    procedure input_text(text: Pgchar; text_len: guint); cdecl; inline;
    function lookup_symbol(symbol: Pgchar): gpointer; cdecl; inline;
    function peek_next_token: TGTokenType; cdecl; inline;
    procedure scope_add_symbol(scope_id: guint; symbol: Pgchar; value: gpointer); cdecl; inline;
    procedure scope_foreach_symbol(scope_id: guint; func: TGHFunc; user_data: gpointer); cdecl; inline;
    function scope_lookup_symbol(scope_id: guint; symbol: Pgchar): gpointer; cdecl; inline;
    procedure scope_remove_symbol(scope_id: guint; symbol: Pgchar); cdecl; inline;
    function set_scope(scope_id: guint): guint; cdecl; inline;
    procedure sync_file_offset; cdecl; inline;
    procedure unexp_token(expected_token: TGTokenType; identifier_spec: Pgchar; symbol_spec: Pgchar; symbol_name: Pgchar; message: Pgchar; is_error: gint); cdecl; inline;
    //procedure warn(format: Pgchar; args: array of const); cdecl; inline;
    function new(config_templ: PGScannerConfig): PGScanner; cdecl; inline; static;
  end;

  PPGSequenceIter = ^PGSequenceIter;
  PGSequenceIter = ^TGSequenceIter;

  PPGSequence = ^PGSequence;
  PGSequence = ^TGSequence;
  TGSequenceIter = object
    function compare(b: PGSequenceIter): gint; cdecl; inline;
    function get_position: gint; cdecl; inline;
    function get_sequence: PGSequence; cdecl; inline;
    function is_begin: gboolean; cdecl; inline;
    function is_end: gboolean; cdecl; inline;
    function move(delta: gint): PGSequenceIter; cdecl; inline;
    function next: PGSequenceIter; cdecl; inline;
    function prev: PGSequenceIter; cdecl; inline;
  end;

  PPGSequenceIterCompareFunc = ^PGSequenceIterCompareFunc;
  PGSequenceIterCompareFunc = ^TGSequenceIterCompareFunc;
  TGSequenceIterCompareFunc = function(a: PGSequenceIter; b: PGSequenceIter; data: gpointer): gint; cdecl;
  TGSequence = object
    function append(data: gpointer): PGSequenceIter; cdecl; inline;
    procedure foreach(func: TGFunc; user_data: gpointer); cdecl; inline;
    procedure free; cdecl; inline;
    function get_begin_iter: PGSequenceIter; cdecl; inline;
    function get_end_iter: PGSequenceIter; cdecl; inline;
    function get_iter_at_pos(pos: gint): PGSequenceIter; cdecl; inline;
    function get_length: gint; cdecl; inline;
    function insert_sorted(data: gpointer; cmp_func: TGCompareDataFunc; cmp_data: gpointer): PGSequenceIter; cdecl; inline;
    function insert_sorted_iter(data: gpointer; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer): PGSequenceIter; cdecl; inline;
    function lookup(data: gpointer; cmp_func: TGCompareDataFunc; cmp_data: gpointer): PGSequenceIter; cdecl; inline;
    function lookup_iter(data: gpointer; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer): PGSequenceIter; cdecl; inline;
    function prepend(data: gpointer): PGSequenceIter; cdecl; inline;
    function search(data: gpointer; cmp_func: TGCompareDataFunc; cmp_data: gpointer): PGSequenceIter; cdecl; inline;
    function search_iter(data: gpointer; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer): PGSequenceIter; cdecl; inline;
    procedure sort(cmp_func: TGCompareDataFunc; cmp_data: gpointer); cdecl; inline;
    procedure sort_iter(cmp_func: TGSequenceIterCompareFunc; cmp_data: gpointer); cdecl; inline;
    procedure foreach_range(begin_: PGSequenceIter; end_: PGSequenceIter; func: TGFunc; user_data: gpointer); cdecl; inline; static;
    function get(iter: PGSequenceIter): gpointer; cdecl; inline; static;
    function insert_before(iter: PGSequenceIter; data: gpointer): PGSequenceIter; cdecl; inline; static;
    procedure move(src: PGSequenceIter; dest: PGSequenceIter); cdecl; inline; static;
    procedure move_range(dest: PGSequenceIter; begin_: PGSequenceIter; end_: PGSequenceIter); cdecl; inline; static;
    function new(data_destroy: TGDestroyNotify): PGSequence; cdecl; inline; static;
    function range_get_midpoint(begin_: PGSequenceIter; end_: PGSequenceIter): PGSequenceIter; cdecl; inline; static;
    procedure remove(iter: PGSequenceIter); cdecl; inline; static;
    procedure remove_range(begin_: PGSequenceIter; end_: PGSequenceIter); cdecl; inline; static;
    procedure set_(iter: PGSequenceIter; data: gpointer); cdecl; inline; static;
    procedure sort_changed(iter: PGSequenceIter; cmp_func: TGCompareDataFunc; cmp_data: gpointer); cdecl; inline; static;
    procedure sort_changed_iter(iter: PGSequenceIter; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer); cdecl; inline; static;
    procedure swap(a: PGSequenceIter; b: PGSequenceIter); cdecl; inline; static;
  end;

  PPGShellError = ^PGShellError;
  PGShellError = ^TGShellError;

  PPGSliceConfig = ^PGSliceConfig;
  PGSliceConfig = ^TGSliceConfig;

  TGSourceCallbackFuncs = record
    ref: procedure(cb_data: gpointer); cdecl;
    unref: procedure(cb_data: gpointer); cdecl;
    get: procedure(cb_data: gpointer; source: PGSource; func: PGSourceFunc; data: Pgpointer); cdecl;
  end;



  TGSourcePrivate = record
  end;


  TGSpawnChildSetupFunc = procedure(user_data: gpointer); cdecl;

  PPGSpawnError = ^PGSpawnError;
  PGSpawnError = ^TGSpawnError;

  PPGSpawnFlags = ^PGSpawnFlags;
  PGSpawnFlags = ^TGSpawnFlags;

  PPGStatBuf = ^PGStatBuf;
  PGStatBuf = ^TGStatBuf;

  TGStatBuf = record
  end;



  PPGStringChunk = ^PGStringChunk;
  PGStringChunk = ^TGStringChunk;
  TGStringChunk = object
    procedure clear; cdecl; inline;
    procedure free; cdecl; inline;
    function insert(string_: Pgchar): Pgchar; cdecl; inline;
    function insert_const(string_: Pgchar): Pgchar; cdecl; inline;
    function insert_len(string_: Pgchar; len: gssize): Pgchar; cdecl; inline;
    function new(size: gsize): PGStringChunk; cdecl; inline; static;
  end;

  PPGTestCase = ^PGTestCase;
  PGTestCase = ^TGTestCase;

  TGTestCase = record
  end;



  PPGTestConfig = ^PGTestConfig;
  PGTestConfig = ^TGTestConfig;

  TGTestConfig = record
    test_initialized: gboolean;
    test_quick: gboolean;
    test_perf: gboolean;
    test_verbose: gboolean;
    test_quiet: gboolean;
    test_undefined: gboolean;
  end;


  TGTestDataFunc = procedure(user_data: Pgpointer); cdecl;
  TGTestFixtureFunc = procedure(fixture: gpointer; user_data: Pgpointer); cdecl;
  TGTestFunc = procedure; cdecl;

  PPGTestLogBuffer = ^PGTestLogBuffer;
  PGTestLogBuffer = ^TGTestLogBuffer;

  PPGTestLogMsg = ^PGTestLogMsg;
  PGTestLogMsg = ^TGTestLogMsg;
  TGTestLogBuffer = object
    data: PGString;
    msgs: PGSList;
    procedure free; cdecl; inline;
    function pop: PGTestLogMsg; cdecl; inline;
    procedure push(n_bytes: guint; bytes: Pguint8); cdecl; inline;
    function new: PGTestLogBuffer; cdecl; inline; static;
  end;

  PPGTestLogType = ^PGTestLogType;
  PGTestLogType = ^TGTestLogType;
  TGTestLogMsg = object
    log_type: TGTestLogType;
    n_strings: guint;
    strings: PPgchar;
    n_nums: guint;
    nums: Pglong;
    procedure free; cdecl; inline;
  end;
  TGTestLogFatalFunc = function(log_domain: Pgchar; log_level: TGLogLevelFlags; message: Pgchar; user_data: gpointer): gboolean; cdecl;

  PPGTestSuite = ^PGTestSuite;
  PGTestSuite = ^TGTestSuite;
  TGTestSuite = object
    procedure add(test_case: PGTestCase); cdecl; inline;
    procedure add_suite(nestedsuite: PGTestSuite); cdecl; inline;
  end;

  PPGTestTrapFlags = ^PGTestTrapFlags;
  PGTestTrapFlags = ^TGTestTrapFlags;

  PPGThread = ^PGThread;
  PGThread = ^TGThread;
  TGThread = object
    function new(name: Pgchar; func: TGThreadFunc; data: gpointer): PGThread; cdecl; inline; static;
    function try_new(name: Pgchar; func: TGThreadFunc; data: gpointer; error: PPGError): PGThread; cdecl; inline; static;
    function join: gpointer; cdecl; inline;
    function ref: PGThread; cdecl; inline;
    procedure unref; cdecl; inline;
    function error_quark: TGQuark; cdecl; inline; static;
    procedure exit(retval: gpointer); cdecl; inline; static;
    function self: PGThread; cdecl; inline; static;
    procedure yield; cdecl; inline; static;
  end;

  PPGThreadError = ^PGThreadError;
  PGThreadError = ^TGThreadError;

  PPGThreadPool = ^PGThreadPool;
  PGThreadPool = ^TGThreadPool;
  TGThreadPool = object
    func: TGFunc;
    user_data: gpointer;
    exclusive: gboolean;
    procedure free(immediate: gboolean; wait_: gboolean); cdecl; inline;
    function get_max_threads: gint; cdecl; inline;
    function get_num_threads: guint; cdecl; inline;
    function push(data: gpointer; error: PPGError): gboolean; cdecl; inline;
    function set_max_threads(max_threads: gint; error: PPGError): gboolean; cdecl; inline;
    procedure set_sort_function(func: TGCompareDataFunc; user_data: gpointer); cdecl; inline;
    function unprocessed: guint; cdecl; inline;
    function get_max_idle_time: guint; cdecl; inline; static;
    function get_max_unused_threads: gint; cdecl; inline; static;
    function get_num_unused_threads: guint; cdecl; inline; static;
    function new(func: TGFunc; user_data: gpointer; max_threads: gint; exclusive: gboolean; error: PPGError): PGThreadPool; cdecl; inline; static;
    procedure set_max_idle_time(interval: guint); cdecl; inline; static;
    procedure set_max_unused_threads(max_threads: gint); cdecl; inline; static;
    procedure stop_unused_threads; cdecl; inline; static;
  end;

  PPGTimer = ^PGTimer;
  PGTimer = ^TGTimer;
  TGTimer = object
    procedure continue; cdecl; inline;
    procedure destroy_; cdecl; inline;
    function elapsed(microseconds: Pgulong): gdouble; cdecl; inline;
    procedure reset; cdecl; inline;
    procedure start; cdecl; inline;
    procedure stop; cdecl; inline;
    function new: PGTimer; cdecl; inline; static;
  end;

  PPGTrashStack = ^PGTrashStack;
  PGTrashStack = ^TGTrashStack;
  TGTrashStack = object
    next: PGTrashStack;
    function height(stack_p: PPGTrashStack): guint; cdecl; inline; static;
    function peek(stack_p: PPGTrashStack): gpointer; cdecl; inline; static;
    function pop(stack_p: PPGTrashStack): gpointer; cdecl; inline; static;
    procedure push(stack_p: PPGTrashStack; data_p: gpointer); cdecl; inline; static;
  end;
  TGTraverseFunc = function(key: gpointer; value: gpointer; data: gpointer): gboolean; cdecl;

  PPGTree = ^PGTree;
  PGTree = ^TGTree;

  PPGTraverseFunc = ^PGTraverseFunc;
  PGTraverseFunc = ^TGTraverseFunc;
  TGTree = object
    procedure destroy_; cdecl; inline;
    procedure foreach(func: TGTraverseFunc; user_data: gpointer); cdecl; inline;
    function height: gint; cdecl; inline;
    procedure insert(key: gpointer; value: gpointer); cdecl; inline;
    function lookup(key: Pgpointer): gpointer; cdecl; inline;
    function lookup_extended(lookup_key: Pgpointer; orig_key: Pgpointer; value: Pgpointer): gboolean; cdecl; inline;
    function nnodes: gint; cdecl; inline;
    function ref: PGTree; cdecl; inline;
    function remove(key: Pgpointer): gboolean; cdecl; inline;
    procedure replace(key: gpointer; value: gpointer); cdecl; inline;
    function search(search_func: TGCompareFunc; user_data: Pgpointer): gpointer; cdecl; inline;
    function steal(key: Pgpointer): gboolean; cdecl; inline;
    procedure unref; cdecl; inline;
    function new(key_compare_func: TGCompareFunc): PGTree; cdecl; inline; static;
    function new_full(key_compare_func: TGCompareDataFunc; key_compare_data: gpointer; key_destroy_func: TGDestroyNotify; value_destroy_func: TGDestroyNotify): PGTree; cdecl; inline; static;
    function new_with_data(key_compare_func: TGCompareDataFunc; key_compare_data: gpointer): PGTree; cdecl; inline; static;
  end;

  PPGUnicodeBreakType = ^PGUnicodeBreakType;
  PGUnicodeBreakType = ^TGUnicodeBreakType;

  PPGUnicodeScript = ^PGUnicodeScript;
  PGUnicodeScript = ^TGUnicodeScript;

  PPGUnicodeType = ^PGUnicodeType;
  PGUnicodeType = ^TGUnicodeType;
  TGUnixFDSourceFunc = function(fd: gint; condition: TGIOCondition; user_data: gpointer): gboolean; cdecl;

  PPGUserDirectory = ^PGUserDirectory;
  PGUserDirectory = ^TGUserDirectory;

  PPGVariant = ^PGVariant;
  PGVariant = ^TGVariant;

  PPGVariantType = ^PGVariantType;
  PGVariantType = ^TGVariantType;

  PPPgint16 = ^PPgint16;
  PPgint16 = ^Pgint16;
  Pgint16 = ^gint16;

  PPPguint16 = ^PPguint16;
  PPguint16 = ^Pguint16;
  Pguint16 = ^guint16;

  PPGVariantClass = ^PGVariantClass;
  PGVariantClass = ^TGVariantClass;

  PPGVariantIter = ^PGVariantIter;
  PGVariantIter = ^TGVariantIter;
  TGVariant = object
    //function new(format_string: Pgchar; args: array of const): PGVariant; cdecl; inline; static;
    function new_array(child_type: PGVariantType; children: PPGVariant; n_children: gsize): PGVariant; cdecl; inline; static;
    function new_boolean(value: gboolean): PGVariant; cdecl; inline; static;
    function new_byte(value: guint8): PGVariant; cdecl; inline; static;
    function new_bytestring(string_: Pgchar): PGVariant; cdecl; inline; static;
    function new_bytestring_array(strv: PPgchar; length: gssize): PGVariant; cdecl; inline; static;
    function new_dict_entry(key: PGVariant; value: PGVariant): PGVariant; cdecl; inline; static;
    function new_double(value: gdouble): PGVariant; cdecl; inline; static;
    function new_fixed_array(element_type: PGVariantType; elements: Pgpointer; n_elements: gsize; element_size: gsize): PGVariant; cdecl; inline; static;
    function new_from_bytes(type_: PGVariantType; bytes: PGBytes; trusted: gboolean): PGVariant; cdecl; inline; static;
    function new_from_data(type_: PGVariantType; data: guint8; size: gsize; trusted: gboolean; notify: TGDestroyNotify; user_data: gpointer): PGVariant; cdecl; inline; static;
    function new_handle(value: gint32): PGVariant; cdecl; inline; static;
    function new_int16(value: gint16): PGVariant; cdecl; inline; static;
    function new_int32(value: gint32): PGVariant; cdecl; inline; static;
    function new_int64(value: gint64): PGVariant; cdecl; inline; static;
    function new_maybe(child_type: PGVariantType; child: PGVariant): PGVariant; cdecl; inline; static;
    function new_object_path(object_path: Pgchar): PGVariant; cdecl; inline; static;
    function new_objv(strv: PPgchar; length: gssize): PGVariant; cdecl; inline; static;
    //function new_parsed(format: Pgchar; args: array of const): PGVariant; cdecl; inline; static;
    //function new_parsed_va(format: Pgchar; app: Pva_list): PGVariant; cdecl; inline; static;
    function new_signature(signature: Pgchar): PGVariant; cdecl; inline; static;
    function new_string(string_: Pgchar): PGVariant; cdecl; inline; static;
    function new_strv(strv: PPgchar; length: gssize): PGVariant; cdecl; inline; static;
    function new_tuple(children: PPGVariant; n_children: gsize): PGVariant; cdecl; inline; static;
    function new_uint16(value: guint16): PGVariant; cdecl; inline; static;
    function new_uint32(value: guint32): PGVariant; cdecl; inline; static;
    function new_uint64(value: guint64): PGVariant; cdecl; inline; static;
    //function new_va(format_string: Pgchar; endptr: PPgchar; app: Pva_list): PGVariant; cdecl; inline; static;
    function new_variant(value: PGVariant): PGVariant; cdecl; inline; static;
    function byteswap: PGVariant; cdecl; inline;
    function check_format_string(format_string: Pgchar; copy_only: gboolean): gboolean; cdecl; inline;
    function classify: TGVariantClass; cdecl; inline;
    function compare(two: PGVariant): gint; cdecl; inline;
    function dup_bytestring(length: Pgsize): Pgchar; cdecl; inline;
    function dup_bytestring_array(length: Pgsize): PPgchar; cdecl; inline;
    function dup_objv(length: Pgsize): PPgchar; cdecl; inline;
    function dup_string(length: Pgsize): Pgchar; cdecl; inline;
    function dup_strv(length: Pgsize): PPgchar; cdecl; inline;
    function equal(two: PGVariant): gboolean; cdecl; inline;
    //procedure get(format_string: Pgchar; args: array of const); cdecl; inline;
    function get_boolean: gboolean; cdecl; inline;
    function get_byte: guint8; cdecl; inline;
    function get_bytestring: Pgchar; cdecl; inline;
    function get_bytestring_array(length: Pgsize): PPgchar; cdecl; inline;
    //procedure get_child(index_: gsize; format_string: Pgchar; args: array of const); cdecl; inline;
    function get_child_value(index_: gsize): PGVariant; cdecl; inline;
    function get_data: Pgpointer; cdecl; inline;
    function get_data_as_bytes: PGBytes; cdecl; inline;
    function get_double: gdouble; cdecl; inline;
    function get_fixed_array(n_elements: Pgsize; element_size: gsize): gpointer; cdecl; inline;
    function get_handle: gint32; cdecl; inline;
    function get_int16: gint16; cdecl; inline;
    function get_int32: gint32; cdecl; inline;
    function get_int64: gint64; cdecl; inline;
    function get_maybe: PGVariant; cdecl; inline;
    function get_normal_form: PGVariant; cdecl; inline;
    function get_objv(length: Pgsize): PPgchar; cdecl; inline;
    function get_size: gsize; cdecl; inline;
    function get_string(length: Pgsize): Pgchar; cdecl; inline;
    function get_strv(length: Pgsize): PPgchar; cdecl; inline;
    function get_type: PGVariantType; cdecl; inline;
    function get_type_string: Pgchar; cdecl; inline;
    function get_uint16: guint16; cdecl; inline;
    function get_uint32: guint32; cdecl; inline;
    function get_uint64: guint64; cdecl; inline;
    //procedure get_va(format_string: Pgchar; endptr: PPgchar; app: Pva_list); cdecl; inline;
    function get_variant: PGVariant; cdecl; inline;
    function hash: guint; cdecl; inline;
    function is_container: gboolean; cdecl; inline;
    function is_floating: gboolean; cdecl; inline;
    function is_normal_form: gboolean; cdecl; inline;
    function is_of_type(type_: PGVariantType): gboolean; cdecl; inline;
    function iter_new: PGVariantIter; cdecl; inline;
    //function lookup(key: Pgchar; format_string: Pgchar; args: array of const): gboolean; cdecl; inline;
    function lookup_value(key: Pgchar; expected_type: PGVariantType): PGVariant; cdecl; inline;
    function n_children: gsize; cdecl; inline;
    function print(type_annotate: gboolean): Pgchar; cdecl; inline;
    function print_string(string_: PGString; type_annotate: gboolean): PGString; cdecl; inline;
    function ref: PGVariant; cdecl; inline;
    function ref_sink: PGVariant; cdecl; inline;
    procedure store(data: gpointer); cdecl; inline;
    function take_ref: PGVariant; cdecl; inline;
    procedure unref; cdecl; inline;
    function is_object_path(string_: Pgchar): gboolean; cdecl; inline; static;
    function is_signature(string_: Pgchar): gboolean; cdecl; inline; static;
    function parse(type_: PGVariantType; text: Pgchar; limit: Pgchar; endptr: PPgchar; error: PPGError): PGVariant; cdecl; inline; static;
    function parser_get_error_quark: TGQuark; cdecl; inline; static;
  end;
  TGVariantType = object
    function new(type_string: Pgchar): PGVariantType; cdecl; inline; static;
    function new_array(element: PGVariantType): PGVariantType; cdecl; inline; static;
    function new_dict_entry(key: PGVariantType; value: PGVariantType): PGVariantType; cdecl; inline; static;
    function new_maybe(element: PGVariantType): PGVariantType; cdecl; inline; static;
    function new_tuple(items: PPGVariantType; length: gint): PGVariantType; cdecl; inline; static;
    function copy: PGVariantType; cdecl; inline;
    function dup_string: Pgchar; cdecl; inline;
    function element: PGVariantType; cdecl; inline;
    function equal(type2: PGVariantType): gboolean; cdecl; inline;
    function first: PGVariantType; cdecl; inline;
    procedure free; cdecl; inline;
    function get_string_length: gsize; cdecl; inline;
    function hash: guint; cdecl; inline;
    function is_array: gboolean; cdecl; inline;
    function is_basic: gboolean; cdecl; inline;
    function is_container: gboolean; cdecl; inline;
    function is_definite: gboolean; cdecl; inline;
    function is_dict_entry: gboolean; cdecl; inline;
    function is_maybe: gboolean; cdecl; inline;
    function is_subtype_of(supertype: PGVariantType): gboolean; cdecl; inline;
    function is_tuple: gboolean; cdecl; inline;
    function is_variant: gboolean; cdecl; inline;
    function key: PGVariantType; cdecl; inline;
    function n_items: gsize; cdecl; inline;
    function next: PGVariantType; cdecl; inline;
    function peek_string: Pgchar; cdecl; inline;
    function value: PGVariantType; cdecl; inline;
    function checked_(arg0: Pgchar): PGVariantType; cdecl; inline; static;
    function string_is_valid(type_string: Pgchar): gboolean; cdecl; inline; static;
    function string_scan(string_: Pgchar; limit: Pgchar; endptr: PPgchar): gboolean; cdecl; inline; static;
  end;
  TGVariantIter = object
    x: array [0..15] of gsize;
    function copy: PGVariantIter; cdecl; inline;
    procedure free; cdecl; inline;
    function init(value: PGVariant): gsize; cdecl; inline;
    //function loop(format_string: Pgchar; args: array of const): gboolean; cdecl; inline;
    function n_children: gsize; cdecl; inline;
    //function next(format_string: Pgchar; args: array of const): gboolean; cdecl; inline;
    function next_value: PGVariant; cdecl; inline;
  end;

  PPGVariantBuilder = ^PGVariantBuilder;
  PGVariantBuilder = ^TGVariantBuilder;
  TGVariantBuilder = object
    x: array [0..15] of gsize;
    function new(type_: PGVariantType): PGVariantBuilder; cdecl; inline; static;
    //procedure add(format_string: Pgchar; args: array of const); cdecl; inline;
    //procedure add_parsed(format: Pgchar; args: array of const); cdecl; inline;
    procedure add_value(value: PGVariant); cdecl; inline;
    procedure clear; cdecl; inline;
    procedure close; cdecl; inline;
    function end_: PGVariant; cdecl; inline;
    procedure init(type_: PGVariantType); cdecl; inline;
    procedure open(type_: PGVariantType); cdecl; inline;
    function ref: PGVariantBuilder; cdecl; inline;
    procedure unref; cdecl; inline;
  end;

  PPGVariantParseError = ^PGVariantParseError;
  PGVariantParseError = ^TGVariantParseError;
  TGVoidFunc = procedure; cdecl;

function g_access(filename: Pgchar; mode: gint): gint; cdecl; external;
function g_array_append_vals(array_: Pgpointer; data: Pgpointer; len: guint): Pgpointer; cdecl; external;
function g_array_free(array_: Pgpointer; free_segment: gboolean): Pgchar; cdecl; external;
function g_array_get_element_size(array_: Pgpointer): guint; cdecl; external;
function g_array_get_type: TGType; cdecl; external;
function g_array_insert_vals(array_: Pgpointer; index_: guint; data: Pgpointer; len: guint): Pgpointer; cdecl; external;
function g_array_new(zero_terminated: gboolean; clear_: gboolean; element_size: guint): Pgpointer; cdecl; external;
function g_array_prepend_vals(array_: Pgpointer; data: Pgpointer; len: guint): Pgpointer; cdecl; external;
function g_array_ref(array_: Pgpointer): Pgpointer; cdecl; external;
function g_array_remove_index(array_: Pgpointer; index_: guint): Pgpointer; cdecl; external;
function g_array_remove_index_fast(array_: Pgpointer; index_: guint): Pgpointer; cdecl; external;
function g_array_remove_range(array_: Pgpointer; index_: guint; length: guint): Pgpointer; cdecl; external;
function g_array_set_size(array_: Pgpointer; length: guint): Pgpointer; cdecl; external;
function g_array_sized_new(zero_terminated: gboolean; clear_: gboolean; element_size: guint; reserved_size: guint): Pgpointer; cdecl; external;
function g_ascii_digit_value(c: gchar): gint; cdecl; external;
function g_ascii_dtostr(buffer: Pgchar; buf_len: gint; d: gdouble): Pgchar; cdecl; external;
function g_ascii_formatd(buffer: Pgchar; buf_len: gint; format: Pgchar; d: gdouble): Pgchar; cdecl; external;
function g_ascii_strcasecmp(s1: Pgchar; s2: Pgchar): gint; cdecl; external;
function g_ascii_strdown(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_ascii_strncasecmp(s1: Pgchar; s2: Pgchar; n: gsize): gint; cdecl; external;
function g_ascii_strtod(nptr: Pgchar; endptr: PPgchar): gdouble; cdecl; external;
function g_ascii_strtoll(nptr: Pgchar; endptr: PPgchar; base: guint): gint64; cdecl; external;
function g_ascii_strtoull(nptr: Pgchar; endptr: PPgchar; base: guint): guint64; cdecl; external;
function g_ascii_strup(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_ascii_tolower(c: gchar): gchar; cdecl; external;
function g_ascii_toupper(c: gchar): gchar; cdecl; external;
function g_ascii_xdigit_value(c: gchar): gint; cdecl; external;
function g_async_queue_length(queue: PGAsyncQueue): gint; cdecl; external;
function g_async_queue_length_unlocked(queue: PGAsyncQueue): gint; cdecl; external;
function g_async_queue_new: PGAsyncQueue; cdecl; external;
function g_async_queue_new_full(item_free_func: TGDestroyNotify): PGAsyncQueue; cdecl; external;
function g_async_queue_pop(queue: PGAsyncQueue): gpointer; cdecl; external;
function g_async_queue_pop_unlocked(queue: PGAsyncQueue): gpointer; cdecl; external;
function g_async_queue_ref(queue: PGAsyncQueue): PGAsyncQueue; cdecl; external;
function g_async_queue_timeout_pop(queue: PGAsyncQueue; timeout: guint64): gpointer; cdecl; external;
function g_async_queue_timeout_pop_unlocked(queue: PGAsyncQueue; timeout: guint64): gpointer; cdecl; external;
function g_async_queue_try_pop(queue: PGAsyncQueue): gpointer; cdecl; external;
function g_async_queue_try_pop_unlocked(queue: PGAsyncQueue): gpointer; cdecl; external;
function g_atomic_int_add(atomic: Pgint; val: gint): gint; cdecl; external;
function g_atomic_int_and(atomic: Pguint; val: guint): guint; cdecl; external;
function g_atomic_int_compare_and_exchange(atomic: Pgint; oldval: gint; newval: gint): gboolean; cdecl; external;
function g_atomic_int_dec_and_test(atomic: Pgint): gboolean; cdecl; external;
function g_atomic_int_exchange_and_add(atomic: Pgint; val: gint): gint; cdecl; external;
function g_atomic_int_get(atomic: Pgint): gint; cdecl; external;
function g_atomic_int_or(atomic: Pguint; val: guint): guint; cdecl; external;
function g_atomic_int_xor(atomic: Pguint; val: guint): guint; cdecl; external;
function g_atomic_pointer_add(atomic: Pgpointer; val: gssize): gssize; cdecl; external;
function g_atomic_pointer_and(atomic: Pgpointer; val: gsize): gsize; cdecl; external;
function g_atomic_pointer_compare_and_exchange(atomic: Pgpointer; oldval: gpointer; newval: gpointer): gboolean; cdecl; external;
function g_atomic_pointer_get(atomic: Pgpointer): gpointer; cdecl; external;
function g_atomic_pointer_or(atomic: Pgpointer; val: gsize): gsize; cdecl; external;
function g_atomic_pointer_xor(atomic: Pgpointer; val: gsize): gsize; cdecl; external;
function g_base64_decode(text: Pgchar; out_len: Pgsize): Pguint8; cdecl; external;
function g_base64_decode_inplace(text: Pgchar; out_len: Pgsize): Pguint8; cdecl; external;
function g_base64_decode_step(in_: Pgchar; len: gsize; out_: Pguint8; state: Pgint; save: Pguint): gsize; cdecl; external;
function g_base64_encode(data: Pguint8; len: gsize): Pgchar; cdecl; external;
function g_base64_encode_close(break_lines: gboolean; out_: Pgchar; state: Pgint; save: Pgint): gsize; cdecl; external;
function g_base64_encode_step(in_: Pguint8; len: gsize; break_lines: gboolean; out_: Pgchar; state: Pgint; save: Pgint): gsize; cdecl; external;
function g_basename(file_name: Pgchar): Pgchar; cdecl; external;
function g_bit_nth_lsf(mask: gulong; nth_bit: gint): gint; cdecl; external;
function g_bit_nth_msf(mask: gulong; nth_bit: gint): gint; cdecl; external;
function g_bit_storage(number: gulong): guint; cdecl; external;
function g_bit_trylock(address: Pgint; lock_bit: gint): gboolean; cdecl; external;
function g_bookmark_file_error_quark: TGQuark; cdecl; external;
function g_bookmark_file_get_added(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): glong; cdecl; external;
function g_bookmark_file_get_app_info(bookmark: PGBookmarkFile; uri: Pgchar; name: Pgchar; exec: PPgchar; count: Pguint; stamp: Pglong; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_get_applications(bookmark: PGBookmarkFile; uri: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; external;
function g_bookmark_file_get_description(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_bookmark_file_get_groups(bookmark: PGBookmarkFile; uri: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; external;
function g_bookmark_file_get_icon(bookmark: PGBookmarkFile; uri: Pgchar; href: PPgchar; mime_type: PPgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_get_is_private(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_get_mime_type(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_bookmark_file_get_modified(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): glong; cdecl; external;
function g_bookmark_file_get_size(bookmark: PGBookmarkFile): gint; cdecl; external;
function g_bookmark_file_get_title(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_bookmark_file_get_uris(bookmark: PGBookmarkFile; length: Pgsize): PPgchar; cdecl; external;
function g_bookmark_file_get_visited(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): glong; cdecl; external;
function g_bookmark_file_has_application(bookmark: PGBookmarkFile; uri: Pgchar; name: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_has_group(bookmark: PGBookmarkFile; uri: Pgchar; group: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_has_item(bookmark: PGBookmarkFile; uri: Pgchar): gboolean; cdecl; external;
function g_bookmark_file_load_from_data(bookmark: PGBookmarkFile; data: Pgchar; length: gsize; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_load_from_data_dirs(bookmark: PGBookmarkFile; file_: Pgchar; full_path: PPgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_load_from_file(bookmark: PGBookmarkFile; filename: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_move_item(bookmark: PGBookmarkFile; old_uri: Pgchar; new_uri: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_new: PGBookmarkFile; cdecl; external;
function g_bookmark_file_remove_application(bookmark: PGBookmarkFile; uri: Pgchar; name: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_remove_group(bookmark: PGBookmarkFile; uri: Pgchar; group: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_remove_item(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_set_app_info(bookmark: PGBookmarkFile; uri: Pgchar; name: Pgchar; exec: Pgchar; count: gint; stamp: glong; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_to_data(bookmark: PGBookmarkFile; length: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_bookmark_file_to_file(bookmark: PGBookmarkFile; filename: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_build_filename(first_element: Pgchar; args: array of const): Pgchar; cdecl; external;
function g_build_filenamev(args: PPgchar): Pgchar; cdecl; external;
function g_build_path(separator: Pgchar; first_element: Pgchar; args: array of const): Pgchar; cdecl; external;
function g_build_pathv(separator: Pgchar; args: PPgchar): Pgchar; cdecl; external;
function g_byte_array_append(array_: Pguint8; data: Pguint8; len: guint): Pguint8; cdecl; external;
function g_byte_array_free(array_: Pguint8; free_segment: gboolean): Pguint8; cdecl; external;
function g_byte_array_free_to_bytes(array_: Pguint8): PGBytes; cdecl; external;
function g_byte_array_get_type: TGType; cdecl; external;
function g_byte_array_new: Pguint8; cdecl; external;
function g_byte_array_new_take(data: Pguint8; len: gsize): Pguint8; cdecl; external;
function g_byte_array_prepend(array_: Pguint8; data: Pguint8; len: guint): Pguint8; cdecl; external;
function g_byte_array_ref(array_: Pguint8): Pguint8; cdecl; external;
function g_byte_array_remove_index(array_: Pguint8; index_: guint): Pguint8; cdecl; external;
function g_byte_array_remove_index_fast(array_: Pguint8; index_: guint): Pguint8; cdecl; external;
function g_byte_array_remove_range(array_: Pguint8; index_: guint; length: guint): Pguint8; cdecl; external;
function g_byte_array_set_size(array_: Pguint8; length: guint): Pguint8; cdecl; external;
function g_byte_array_sized_new(reserved_size: guint): Pguint8; cdecl; external;
function g_bytes_compare(bytes1: PGBytes; bytes2: PGBytes): gint; cdecl; external;
function g_bytes_equal(bytes1: PGBytes; bytes2: PGBytes): gboolean; cdecl; external;
function g_bytes_get_data(bytes: PGBytes; size: Pgsize): guint8; cdecl; external;
function g_bytes_get_size(bytes: PGBytes): gsize; cdecl; external;
function g_bytes_get_type: TGType; cdecl; external;
function g_bytes_hash(bytes: PGBytes): guint; cdecl; external;
function g_bytes_new(data: guint8; size: gsize): PGBytes; cdecl; external;
function g_bytes_new_from_bytes(bytes: PGBytes; offset: gsize; length: gsize): PGBytes; cdecl; external;
function g_bytes_new_static(data: guint8; size: gsize): PGBytes; cdecl; external;
function g_bytes_new_take(data: guint8; size: gsize): PGBytes; cdecl; external;
function g_bytes_new_with_free_func(data: gpointer; size: gsize; free_func: TGDestroyNotify; user_data: gpointer): PGBytes; cdecl; external;
function g_bytes_ref(bytes: PGBytes): PGBytes; cdecl; external;
function g_bytes_unref_to_array(bytes: PGBytes): Pguint8; cdecl; external;
function g_bytes_unref_to_data(bytes: PGBytes; size: Pgsize): gpointer; cdecl; external;
function g_chdir(path: Pgchar): gint; cdecl; external;
function g_checksum_copy(checksum: PGChecksum): PGChecksum; cdecl; external;
function g_checksum_get_string(checksum: PGChecksum): Pgchar; cdecl; external;
function g_checksum_get_type: TGType; cdecl; external;
function g_checksum_new(checksum_type: TGChecksumType): PGChecksum; cdecl; external;
function g_checksum_type_get_length(checksum_type: TGChecksumType): gssize; cdecl; external;
function g_child_watch_add(pid: TGPid; function_: TGChildWatchFunc; data: gpointer): guint; cdecl; external;
function g_child_watch_add_full(priority: gint; pid: TGPid; function_: TGChildWatchFunc; data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_child_watch_source_new(pid: TGPid): PGSource; cdecl; external;
function g_close(fd: gint; error: PPGError): gboolean; cdecl; external;
function g_compute_checksum_for_bytes(checksum_type: TGChecksumType; data: PGBytes): Pgchar; cdecl; external;
function g_compute_checksum_for_data(checksum_type: TGChecksumType; data: Pguint8; length: gsize): Pgchar; cdecl; external;
function g_compute_checksum_for_string(checksum_type: TGChecksumType; str: Pgchar; length: gssize): Pgchar; cdecl; external;
function g_compute_hmac_for_data(digest_type: TGChecksumType; key: Pguint8; key_len: gsize; data: Pguint8; length: gsize): Pgchar; cdecl; external;
function g_compute_hmac_for_string(digest_type: TGChecksumType; key: Pguint8; key_len: gsize; str: Pgchar; length: gssize): Pgchar; cdecl; external;
function g_cond_wait_until(cond: PGCond; mutex: PGMutex; end_time: gint64): gboolean; cdecl; external;
function g_convert(str: Pgchar; len: gssize; to_codeset: Pgchar; from_codeset: Pgchar; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_convert_error_quark: TGQuark; cdecl; external;
function g_convert_with_fallback(str: Pgchar; len: gssize; to_codeset: Pgchar; from_codeset: Pgchar; fallback: Pgchar; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_convert_with_iconv(str: Pgchar; len: gssize; converter: TGIConv; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_datalist_get_data(datalist: PPGData; key: Pgchar): gpointer; cdecl; external;
function g_datalist_get_flags(datalist: PPGData): guint; cdecl; external;
function g_datalist_id_dup_data(datalist: PPGData; key_id: TGQuark; dup_func: TGDuplicateFunc; user_data: gpointer): gpointer; cdecl; external;
function g_datalist_id_get_data(datalist: PPGData; key_id: TGQuark): gpointer; cdecl; external;
function g_datalist_id_remove_no_notify(datalist: PPGData; key_id: TGQuark): gpointer; cdecl; external;
function g_datalist_id_replace_data(datalist: PPGData; key_id: TGQuark; oldval: gpointer; newval: gpointer; destroy_: TGDestroyNotify; old_destroy: PGDestroyNotify): gboolean; cdecl; external;
function g_dataset_id_get_data(dataset_location: Pgpointer; key_id: TGQuark): gpointer; cdecl; external;
function g_dataset_id_remove_no_notify(dataset_location: Pgpointer; key_id: TGQuark): gpointer; cdecl; external;
function g_date_compare(lhs: PGDate; rhs: PGDate): gint; cdecl; external;
function g_date_days_between(date1: PGDate; date2: PGDate): gint; cdecl; external;
function g_date_get_day(date: PGDate): TGDateDay; cdecl; external;
function g_date_get_day_of_year(date: PGDate): guint; cdecl; external;
function g_date_get_days_in_month(month: TGDateMonth; year: TGDateYear): guint8; cdecl; external;
function g_date_get_iso8601_week_of_year(date: PGDate): guint; cdecl; external;
function g_date_get_julian(date: PGDate): guint32; cdecl; external;
function g_date_get_monday_week_of_year(date: PGDate): guint; cdecl; external;
function g_date_get_monday_weeks_in_year(year: TGDateYear): guint8; cdecl; external;
function g_date_get_month(date: PGDate): TGDateMonth; cdecl; external;
function g_date_get_sunday_week_of_year(date: PGDate): guint; cdecl; external;
function g_date_get_sunday_weeks_in_year(year: TGDateYear): guint8; cdecl; external;
function g_date_get_type: TGType; cdecl; external;
function g_date_get_weekday(date: PGDate): TGDateWeekday; cdecl; external;
function g_date_get_year(date: PGDate): TGDateYear; cdecl; external;
function g_date_is_first_of_month(date: PGDate): gboolean; cdecl; external;
function g_date_is_last_of_month(date: PGDate): gboolean; cdecl; external;
function g_date_is_leap_year(year: TGDateYear): gboolean; cdecl; external;
function g_date_new: PGDate; cdecl; external;
function g_date_new_dmy(day: TGDateDay; month: TGDateMonth; year: TGDateYear): PGDate; cdecl; external;
function g_date_new_julian(julian_day: guint32): PGDate; cdecl; external;
function g_date_strftime(s: Pgchar; slen: gsize; format: Pgchar; date: PGDate): gsize; cdecl; external;
function g_date_time_add(datetime: PGDateTime; timespan: TGTimeSpan): PGDateTime; cdecl; external;
function g_date_time_add_days(datetime: PGDateTime; days: gint): PGDateTime; cdecl; external;
function g_date_time_add_full(datetime: PGDateTime; years: gint; months: gint; days: gint; hours: gint; minutes: gint; seconds: gdouble): PGDateTime; cdecl; external;
function g_date_time_add_hours(datetime: PGDateTime; hours: gint): PGDateTime; cdecl; external;
function g_date_time_add_minutes(datetime: PGDateTime; minutes: gint): PGDateTime; cdecl; external;
function g_date_time_add_months(datetime: PGDateTime; months: gint): PGDateTime; cdecl; external;
function g_date_time_add_seconds(datetime: PGDateTime; seconds: gdouble): PGDateTime; cdecl; external;
function g_date_time_add_weeks(datetime: PGDateTime; weeks: gint): PGDateTime; cdecl; external;
function g_date_time_add_years(datetime: PGDateTime; years: gint): PGDateTime; cdecl; external;
function g_date_time_compare(dt1: Pgpointer; dt2: Pgpointer): gint; cdecl; external;
function g_date_time_difference(end_: PGDateTime; begin_: PGDateTime): TGTimeSpan; cdecl; external;
function g_date_time_equal(dt1: Pgpointer; dt2: Pgpointer): gboolean; cdecl; external;
function g_date_time_format(datetime: PGDateTime; format: Pgchar): Pgchar; cdecl; external;
function g_date_time_get_day_of_month(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_day_of_week(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_day_of_year(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_hour(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_microsecond(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_minute(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_month(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_second(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_seconds(datetime: PGDateTime): gdouble; cdecl; external;
function g_date_time_get_timezone_abbreviation(datetime: PGDateTime): Pgchar; cdecl; external;
function g_date_time_get_type: TGType; cdecl; external;
function g_date_time_get_utc_offset(datetime: PGDateTime): TGTimeSpan; cdecl; external;
function g_date_time_get_week_numbering_year(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_week_of_year(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_year(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_hash(datetime: Pgpointer): guint; cdecl; external;
function g_date_time_is_daylight_savings(datetime: PGDateTime): gboolean; cdecl; external;
function g_date_time_new(tz: PGTimeZone; year: gint; month: gint; day: gint; hour: gint; minute: gint; seconds: gdouble): PGDateTime; cdecl; external;
function g_date_time_new_from_timeval_local(tv: PGTimeVal): PGDateTime; cdecl; external;
function g_date_time_new_from_timeval_utc(tv: PGTimeVal): PGDateTime; cdecl; external;
function g_date_time_new_from_unix_local(t: gint64): PGDateTime; cdecl; external;
function g_date_time_new_from_unix_utc(t: gint64): PGDateTime; cdecl; external;
function g_date_time_new_local(year: gint; month: gint; day: gint; hour: gint; minute: gint; seconds: gdouble): PGDateTime; cdecl; external;
function g_date_time_new_now(tz: PGTimeZone): PGDateTime; cdecl; external;
function g_date_time_new_now_local: PGDateTime; cdecl; external;
function g_date_time_new_now_utc: PGDateTime; cdecl; external;
function g_date_time_new_utc(year: gint; month: gint; day: gint; hour: gint; minute: gint; seconds: gdouble): PGDateTime; cdecl; external;
function g_date_time_ref(datetime: PGDateTime): PGDateTime; cdecl; external;
function g_date_time_to_local(datetime: PGDateTime): PGDateTime; cdecl; external;
function g_date_time_to_timeval(datetime: PGDateTime; tv: PGTimeVal): gboolean; cdecl; external;
function g_date_time_to_timezone(datetime: PGDateTime; tz: PGTimeZone): PGDateTime; cdecl; external;
function g_date_time_to_unix(datetime: PGDateTime): gint64; cdecl; external;
function g_date_time_to_utc(datetime: PGDateTime): PGDateTime; cdecl; external;
function g_date_valid(date: PGDate): gboolean; cdecl; external;
function g_date_valid_day(day: TGDateDay): gboolean; cdecl; external;
function g_date_valid_dmy(day: TGDateDay; month: TGDateMonth; year: TGDateYear): gboolean; cdecl; external;
function g_date_valid_julian(julian_date: guint32): gboolean; cdecl; external;
function g_date_valid_month(month: TGDateMonth): gboolean; cdecl; external;
function g_date_valid_weekday(weekday: TGDateWeekday): gboolean; cdecl; external;
function g_date_valid_year(year: TGDateYear): gboolean; cdecl; external;
function g_dcgettext(domain: Pgchar; msgid: Pgchar; category: gint): Pgchar; cdecl; external;
function g_dgettext(domain: Pgchar; msgid: Pgchar): Pgchar; cdecl; external;
function g_dir_make_tmp(tmpl: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_dir_open(path: Pgchar; flags: guint; error: PPGError): PGDir; cdecl; external;
function g_dir_read_name(dir: PGDir): Pgchar; cdecl; external;
function g_direct_equal(v1: Pgpointer; v2: Pgpointer): gboolean; cdecl; external;
function g_direct_hash(v: Pgpointer): guint; cdecl; external;
function g_dngettext(domain: Pgchar; msgid: Pgchar; msgid_plural: Pgchar; n: gulong): Pgchar; cdecl; external;
function g_double_equal(v1: Pgpointer; v2: Pgpointer): gboolean; cdecl; external;
function g_double_hash(v: Pgpointer): guint; cdecl; external;
function g_dpgettext(domain: Pgchar; msgctxtid: Pgchar; msgidoffset: gsize): Pgchar; cdecl; external;
function g_dpgettext2(domain: Pgchar; context: Pgchar; msgid: Pgchar): Pgchar; cdecl; external;
function g_environ_getenv(envp: PPgchar; variable: Pgchar): Pgchar; cdecl; external;
function g_environ_setenv(envp: PPgchar; variable: Pgchar; value: Pgchar; overwrite: gboolean): PPgchar; cdecl; external;
function g_environ_unsetenv(envp: PPgchar; variable: Pgchar): PPgchar; cdecl; external;
function g_error_copy(error: PGError): PGError; cdecl; external;
function g_error_get_type: TGType; cdecl; external;
function g_error_matches(error: PGError; domain: TGQuark; code: gint): gboolean; cdecl; external;
function g_error_new(domain: TGQuark; code: gint; format: Pgchar; args: array of const): PGError; cdecl; external;
function g_error_new_literal(domain: TGQuark; code: gint; message: Pgchar): PGError; cdecl; external;
function g_error_new_valist(domain: TGQuark; code: gint; format: Pgchar; args: Tva_list): PGError; cdecl; external;
function g_file_error_from_errno(err_no: gint): TGFileError; cdecl; external;
function g_file_error_quark: TGQuark; cdecl; external;
function g_file_get_contents(filename: Pgchar; contents: PPgchar; length: Pgsize; error: PPGError): gboolean; cdecl; external;
function g_file_open_tmp(tmpl: Pgchar; name_used: PPgchar; error: PPGError): gint; cdecl; external;
function g_file_read_link(filename: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_file_set_contents(filename: Pgchar; contents: Pgchar; length: gssize; error: PPGError): gboolean; cdecl; external;
function g_file_test(filename: Pgchar; test: TGFileTest): gboolean; cdecl; external;
function g_filename_display_basename(filename: Pgchar): Pgchar; cdecl; external;
function g_filename_display_name(filename: Pgchar): Pgchar; cdecl; external;
function g_filename_from_uri(uri: Pgchar; hostname: PPgchar; error: PPGError): Pgchar; cdecl; external;
function g_filename_from_utf8(utf8string: Pgchar; len: gssize; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_filename_to_uri(filename: Pgchar; hostname: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_filename_to_utf8(opsysstring: Pgchar; len: gssize; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_find_program_in_path(program_: Pgchar): Pgchar; cdecl; external;
function g_format_size(size: guint64): Pgchar; cdecl; external;
function g_format_size_for_display(size: gint64): Pgchar; cdecl; external;
function g_format_size_full(size: guint64; flags: TGFormatSizeFlags): Pgchar; cdecl; external;
function g_fprintf(file_: Pgpointer; format: Pgchar; args: array of const): gint; cdecl; external;
function g_get_application_name: Pgchar; cdecl; external;
function g_get_charset(charset: PPgchar): gboolean; cdecl; external;
function g_get_codeset: Pgchar; cdecl; external;
function g_get_current_dir: Pgchar; cdecl; external;
function g_get_environ: PPgchar; cdecl; external;
function g_get_filename_charsets(charsets: PPPgchar): gboolean; cdecl; external;
function g_get_home_dir: Pgchar; cdecl; external;
function g_get_host_name: Pgchar; cdecl; external;
function g_get_language_names: PPgchar; cdecl; external;
function g_get_locale_variants(locale: Pgchar): PPgchar; cdecl; external;
function g_get_monotonic_time: gint64; cdecl; external;
function g_get_num_processors: guint; cdecl; external;
function g_get_prgname: Pgchar; cdecl; external;
function g_get_real_name: Pgchar; cdecl; external;
function g_get_real_time: gint64; cdecl; external;
function g_get_system_config_dirs: PPgchar; cdecl; external;
function g_get_system_data_dirs: PPgchar; cdecl; external;
function g_get_tmp_dir: Pgchar; cdecl; external;
function g_get_user_cache_dir: Pgchar; cdecl; external;
function g_get_user_config_dir: Pgchar; cdecl; external;
function g_get_user_data_dir: Pgchar; cdecl; external;
function g_get_user_name: Pgchar; cdecl; external;
function g_get_user_runtime_dir: Pgchar; cdecl; external;
function g_get_user_special_dir(directory: TGUserDirectory): Pgchar; cdecl; external;
function g_getenv(variable: Pgchar): Pgchar; cdecl; external;
function g_gstring_get_type: TGType; cdecl; external;
function g_hash_table_contains(hash_table: PGHashTable; key: Pgpointer): gboolean; cdecl; external;
function g_hash_table_find(hash_table: PGHashTable; predicate: TGHRFunc; user_data: gpointer): gpointer; cdecl; external;
function g_hash_table_foreach_remove(hash_table: PGHashTable; func: TGHRFunc; user_data: gpointer): guint; cdecl; external;
function g_hash_table_foreach_steal(hash_table: PGHashTable; func: TGHRFunc; user_data: gpointer): guint; cdecl; external;
function g_hash_table_get_keys(hash_table: PGHashTable): PGList; cdecl; external;
function g_hash_table_get_type: TGType; cdecl; external;
function g_hash_table_get_values(hash_table: PGHashTable): PGList; cdecl; external;
function g_hash_table_iter_get_hash_table(iter: PGHashTableIter): PGHashTable; cdecl; external;
function g_hash_table_iter_next(iter: PGHashTableIter; key: Pgpointer; value: Pgpointer): gboolean; cdecl; external;
function g_hash_table_lookup(hash_table: PGHashTable; key: Pgpointer): gpointer; cdecl; external;
function g_hash_table_lookup_extended(hash_table: PGHashTable; lookup_key: Pgpointer; orig_key: Pgpointer; value: Pgpointer): gboolean; cdecl; external;
function g_hash_table_new(hash_func: TGHashFunc; key_equal_func: TGEqualFunc): PGHashTable; cdecl; external;
function g_hash_table_new_full(hash_func: TGHashFunc; key_equal_func: TGEqualFunc; key_destroy_func: TGDestroyNotify; value_destroy_func: TGDestroyNotify): PGHashTable; cdecl; external;
function g_hash_table_ref(hash_table: PGHashTable): PGHashTable; cdecl; external;
function g_hash_table_remove(hash_table: PGHashTable; key: Pgpointer): gboolean; cdecl; external;
function g_hash_table_size(hash_table: PGHashTable): guint; cdecl; external;
function g_hash_table_steal(hash_table: PGHashTable; key: Pgpointer): gboolean; cdecl; external;
function g_hmac_copy(hmac: PGHmac): PGHmac; cdecl; external;
function g_hmac_get_string(hmac: PGHmac): Pgchar; cdecl; external;
function g_hmac_new(digest_type: TGChecksumType; key: Pguint8; key_len: gsize): PGHmac; cdecl; external;
function g_hmac_ref(hmac: PGHmac): PGHmac; cdecl; external;
function g_hook_alloc(hook_list: PGHookList): PGHook; cdecl; external;
function g_hook_compare_ids(new_hook: PGHook; sibling: PGHook): gint; cdecl; external;
function g_hook_destroy(hook_list: PGHookList; hook_id: gulong): gboolean; cdecl; external;
function g_hook_find(hook_list: PGHookList; need_valids: gboolean; func: TGHookFindFunc; data: gpointer): PGHook; cdecl; external;
function g_hook_find_data(hook_list: PGHookList; need_valids: gboolean; data: gpointer): PGHook; cdecl; external;
function g_hook_find_func(hook_list: PGHookList; need_valids: gboolean; func: gpointer): PGHook; cdecl; external;
function g_hook_find_func_data(hook_list: PGHookList; need_valids: gboolean; func: gpointer; data: gpointer): PGHook; cdecl; external;
function g_hook_first_valid(hook_list: PGHookList; may_be_in_call: gboolean): PGHook; cdecl; external;
function g_hook_get(hook_list: PGHookList; hook_id: gulong): PGHook; cdecl; external;
function g_hook_next_valid(hook_list: PGHookList; hook: PGHook; may_be_in_call: gboolean): PGHook; cdecl; external;
function g_hook_ref(hook_list: PGHookList; hook: PGHook): PGHook; cdecl; external;
function g_hostname_is_ascii_encoded(hostname: Pgchar): gboolean; cdecl; external;
function g_hostname_is_ip_address(hostname: Pgchar): gboolean; cdecl; external;
function g_hostname_is_non_ascii(hostname: Pgchar): gboolean; cdecl; external;
function g_hostname_to_ascii(hostname: Pgchar): Pgchar; cdecl; external;
function g_hostname_to_unicode(hostname: Pgchar): Pgchar; cdecl; external;
function g_iconv(converter: TGIConv; inbuf: PPgchar; inbytes_left: Pgsize; outbuf: PPgchar; outbytes_left: Pgsize): gsize; cdecl; external;
function g_iconv_close(converter: TGIConv): gint; cdecl; external;
function g_iconv_open(to_codeset: Pgchar; from_codeset: Pgchar): TGIConv; cdecl; external;
function g_idle_add(function_: TGSourceFunc; data: gpointer): guint; cdecl; external;
function g_idle_add_full(priority: gint; function_: TGSourceFunc; data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_idle_remove_by_data(data: gpointer): gboolean; cdecl; external;
function g_idle_source_new: PGSource; cdecl; external;
function g_int64_equal(v1: Pgpointer; v2: Pgpointer): gboolean; cdecl; external;
function g_int64_hash(v: Pgpointer): guint; cdecl; external;
function g_int_equal(v1: Pgpointer; v2: Pgpointer): gboolean; cdecl; external;
function g_int_hash(v: Pgpointer): guint; cdecl; external;
function g_intern_static_string(string_: Pgchar): Pgchar; cdecl; external;
function g_intern_string(string_: Pgchar): Pgchar; cdecl; external;
function g_io_add_watch(channel: PGIOChannel; condition: TGIOCondition; func: TGIOFunc; user_data: gpointer): guint; cdecl; external;
function g_io_add_watch_full(channel: PGIOChannel; priority: gint; condition: TGIOCondition; func: TGIOFunc; user_data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_io_channel_error_from_errno(en: gint): TGIOChannelError; cdecl; external;
function g_io_channel_error_quark: TGQuark; cdecl; external;
function g_io_channel_flush(channel: PGIOChannel; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_get_buffer_condition(channel: PGIOChannel): TGIOCondition; cdecl; external;
function g_io_channel_get_buffer_size(channel: PGIOChannel): gsize; cdecl; external;
function g_io_channel_get_buffered(channel: PGIOChannel): gboolean; cdecl; external;
function g_io_channel_get_close_on_unref(channel: PGIOChannel): gboolean; cdecl; external;
function g_io_channel_get_encoding(channel: PGIOChannel): Pgchar; cdecl; external;
function g_io_channel_get_flags(channel: PGIOChannel): TGIOFlags; cdecl; external;
function g_io_channel_get_line_term(channel: PGIOChannel; length: Pgint): Pgchar; cdecl; external;
function g_io_channel_get_type: TGType; cdecl; external;
function g_io_channel_new_file(filename: Pgchar; mode: Pgchar; error: PPGError): PGIOChannel; cdecl; external;
function g_io_channel_read_chars(channel: PGIOChannel; buf: Pgchar; count: gsize; bytes_read: Pgsize; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_read_line(channel: PGIOChannel; str_return: PPgchar; length: Pgsize; terminator_pos: Pgsize; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_read_line_string(channel: PGIOChannel; buffer: PGString; terminator_pos: Pgsize; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_read_to_end(channel: PGIOChannel; str_return: PPgchar; length: Pgsize; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_read_unichar(channel: PGIOChannel; thechar: Pgunichar; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_ref(channel: PGIOChannel): PGIOChannel; cdecl; external;
function g_io_channel_seek_position(channel: PGIOChannel; offset: gint64; type_: TGSeekType; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_set_encoding(channel: PGIOChannel; encoding: Pgchar; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_set_flags(channel: PGIOChannel; flags: TGIOFlags; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_shutdown(channel: PGIOChannel; flush: gboolean; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_unix_get_fd(channel: PGIOChannel): gint; cdecl; external;
function g_io_channel_unix_new(fd: gint): PGIOChannel; cdecl; external;
function g_io_channel_write_chars(channel: PGIOChannel; buf: Pgchar; count: gssize; bytes_written: Pgsize; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_write_unichar(channel: PGIOChannel; thechar: gunichar; error: PPGError): TGIOStatus; cdecl; external;
function g_io_create_watch(channel: PGIOChannel; condition: TGIOCondition): PGSource; cdecl; external;
function g_key_file_error_quark: TGQuark; cdecl; external;
function g_key_file_get_boolean(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_key_file_get_boolean_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): Pgboolean; cdecl; external;
function g_key_file_get_comment(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_key_file_get_double(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gdouble; cdecl; external;
function g_key_file_get_double_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): Pgdouble; cdecl; external;
function g_key_file_get_groups(key_file: PGKeyFile; length: Pgsize): PPgchar; cdecl; external;
function g_key_file_get_int64(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gint64; cdecl; external;
function g_key_file_get_integer(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gint; cdecl; external;
function g_key_file_get_integer_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): Pgint; cdecl; external;
function g_key_file_get_keys(key_file: PGKeyFile; group_name: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; external;
function g_key_file_get_locale_string(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; locale: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_key_file_get_locale_string_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; locale: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; external;
function g_key_file_get_start_group(key_file: PGKeyFile): Pgchar; cdecl; external;
function g_key_file_get_string(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_key_file_get_string_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; external;
function g_key_file_get_type: TGType; cdecl; external;
function g_key_file_get_uint64(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): guint64; cdecl; external;
function g_key_file_get_value(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_key_file_has_group(key_file: PGKeyFile; group_name: Pgchar): gboolean; cdecl; external;
function g_key_file_has_key(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_key_file_load_from_data(key_file: PGKeyFile; data: Pgchar; length: gsize; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl; external;
function g_key_file_load_from_data_dirs(key_file: PGKeyFile; file_: Pgchar; full_path: PPgchar; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl; external;
function g_key_file_load_from_dirs(key_file: PGKeyFile; file_: Pgchar; search_dirs: PPgchar; full_path: PPgchar; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl; external;
function g_key_file_load_from_file(key_file: PGKeyFile; file_: Pgchar; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl; external;
function g_key_file_new: PGKeyFile; cdecl; external;
function g_key_file_ref(key_file: PGKeyFile): PGKeyFile; cdecl; external;
function g_key_file_remove_comment(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_key_file_remove_group(key_file: PGKeyFile; group_name: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_key_file_remove_key(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_key_file_set_comment(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; comment: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_key_file_to_data(key_file: PGKeyFile; length: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_list_alloc: PGList; cdecl; external;
function g_list_append(list: PGList; data: gpointer): PGList; cdecl; external;
function g_list_concat(list1: PGList; list2: PGList): PGList; cdecl; external;
function g_list_copy(list: PGList): PGList; cdecl; external;
function g_list_copy_deep(list: PGList; func: TGCopyFunc; user_data: gpointer): PGList; cdecl; external;
function g_list_delete_link(list: PGList; link_: PGList): PGList; cdecl; external;
function g_list_find(list: PGList; data: Pgpointer): PGList; cdecl; external;
function g_list_find_custom(list: PGList; data: Pgpointer; func: TGCompareFunc): PGList; cdecl; external;
function g_list_first(list: PGList): PGList; cdecl; external;
function g_list_index(list: PGList; data: Pgpointer): gint; cdecl; external;
function g_list_insert(list: PGList; data: gpointer; position: gint): PGList; cdecl; external;
function g_list_insert_before(list: PGList; sibling: PGList; data: gpointer): PGList; cdecl; external;
function g_list_insert_sorted(list: PGList; data: gpointer; func: TGCompareFunc): PGList; cdecl; external;
function g_list_insert_sorted_with_data(list: PGList; data: gpointer; func: TGCompareDataFunc; user_data: gpointer): PGList; cdecl; external;
function g_list_last(list: PGList): PGList; cdecl; external;
function g_list_length(list: PGList): guint; cdecl; external;
function g_list_nth(list: PGList; n: guint): PGList; cdecl; external;
function g_list_nth_data(list: PGList; n: guint): gpointer; cdecl; external;
function g_list_nth_prev(list: PGList; n: guint): PGList; cdecl; external;
function g_list_position(list: PGList; llink: PGList): gint; cdecl; external;
function g_list_prepend(list: PGList; data: gpointer): PGList; cdecl; external;
function g_list_remove(list: PGList; data: Pgpointer): PGList; cdecl; external;
function g_list_remove_all(list: PGList; data: Pgpointer): PGList; cdecl; external;
function g_list_remove_link(list: PGList; llink: PGList): PGList; cdecl; external;
function g_list_reverse(list: PGList): PGList; cdecl; external;
function g_list_sort(list: PGList; compare_func: TGCompareFunc): PGList; cdecl; external;
function g_list_sort_with_data(list: PGList; compare_func: TGCompareDataFunc; user_data: gpointer): PGList; cdecl; external;
function g_listenv: PPgchar; cdecl; external;
function g_locale_from_utf8(utf8string: Pgchar; len: gssize; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_locale_to_utf8(opsysstring: Pgchar; len: gssize; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_log_set_always_fatal(fatal_mask: TGLogLevelFlags): TGLogLevelFlags; cdecl; external;
function g_log_set_default_handler(log_func: TGLogFunc; user_data: gpointer): TGLogFunc; cdecl; external;
function g_log_set_fatal_mask(log_domain: Pgchar; fatal_mask: TGLogLevelFlags): TGLogLevelFlags; cdecl; external;
function g_log_set_handler(log_domain: Pgchar; log_levels: TGLogLevelFlags; log_func: TGLogFunc; user_data: gpointer): guint; cdecl; external;
function g_main_context_acquire(context: PGMainContext): gboolean; cdecl; external;
function g_main_context_check(context: PGMainContext; max_priority: gint; fds: PGPollFD; n_fds: gint): gint; cdecl; external;
function g_main_context_default: PGMainContext; cdecl; external;
function g_main_context_find_source_by_funcs_user_data(context: PGMainContext; funcs: PGSourceFuncs; user_data: gpointer): PGSource; cdecl; external;
function g_main_context_find_source_by_id(context: PGMainContext; source_id: guint): PGSource; cdecl; external;
function g_main_context_find_source_by_user_data(context: PGMainContext; user_data: gpointer): PGSource; cdecl; external;
function g_main_context_get_poll_func(context: PGMainContext): TGPollFunc; cdecl; external;
function g_main_context_get_thread_default: PGMainContext; cdecl; external;
function g_main_context_get_type: TGType; cdecl; external;
function g_main_context_is_owner(context: PGMainContext): gboolean; cdecl; external;
function g_main_context_iteration(context: PGMainContext; may_block: gboolean): gboolean; cdecl; external;
function g_main_context_new: PGMainContext; cdecl; external;
function g_main_context_pending(context: PGMainContext): gboolean; cdecl; external;
function g_main_context_prepare(context: PGMainContext; priority: Pgint): gboolean; cdecl; external;
function g_main_context_query(context: PGMainContext; max_priority: gint; timeout_: Pgint; fds: PGPollFD; n_fds: gint): gint; cdecl; external;
function g_main_context_ref(context: PGMainContext): PGMainContext; cdecl; external;
function g_main_context_ref_thread_default: PGMainContext; cdecl; external;
function g_main_context_wait(context: PGMainContext; cond: PGCond; mutex: PGMutex): gboolean; cdecl; external;
function g_main_current_source: PGSource; cdecl; external;
function g_main_depth: gint; cdecl; external;
function g_main_loop_get_context(loop: PGMainLoop): PGMainContext; cdecl; external;
function g_main_loop_get_type: TGType; cdecl; external;
function g_main_loop_is_running(loop: PGMainLoop): gboolean; cdecl; external;
function g_main_loop_new(context: PGMainContext; is_running: gboolean): PGMainLoop; cdecl; external;
function g_main_loop_ref(loop: PGMainLoop): PGMainLoop; cdecl; external;
function g_malloc(n_bytes: gsize): gpointer; cdecl; external;
function g_malloc0(n_bytes: gsize): gpointer; cdecl; external;
function g_malloc0_n(n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl; external;
function g_malloc_n(n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl; external;
function g_mapped_file_get_bytes(file_: PGMappedFile): PGBytes; cdecl; external;
function g_mapped_file_get_contents(file_: PGMappedFile): Pgchar; cdecl; external;
function g_mapped_file_get_length(file_: PGMappedFile): gsize; cdecl; external;
function g_mapped_file_new(filename: Pgchar; writable: gboolean; error: PPGError): PGMappedFile; cdecl; external;
function g_mapped_file_new_from_fd(fd: gint; writable: gboolean; error: PPGError): PGMappedFile; cdecl; external;
function g_mapped_file_ref(file_: PGMappedFile): PGMappedFile; cdecl; external;
function g_markup_collect_attributes(element_name: Pgchar; attribute_names: PPgchar; attribute_values: PPgchar; error: PPGError; first_type: TGMarkupCollectType; first_attr: Pgchar; args: array of const): gboolean; cdecl; external;
function g_markup_error_quark: TGQuark; cdecl; external;
function g_markup_escape_text(text: Pgchar; length: gssize): Pgchar; cdecl; external;
function g_markup_parse_context_end_parse(context: PGMarkupParseContext; error: PPGError): gboolean; cdecl; external;
function g_markup_parse_context_get_element(context: PGMarkupParseContext): Pgchar; cdecl; external;
function g_markup_parse_context_get_element_stack(context: PGMarkupParseContext): PGSList; cdecl; external;
function g_markup_parse_context_get_type: TGType; cdecl; external;
function g_markup_parse_context_get_user_data(context: PGMarkupParseContext): gpointer; cdecl; external;
function g_markup_parse_context_new(parser: PGMarkupParser; flags: TGMarkupParseFlags; user_data: gpointer; user_data_dnotify: TGDestroyNotify): PGMarkupParseContext; cdecl; external;
function g_markup_parse_context_parse(context: PGMarkupParseContext; text: Pgchar; text_len: gssize; error: PPGError): gboolean; cdecl; external;
function g_markup_parse_context_pop(context: PGMarkupParseContext): gpointer; cdecl; external;
function g_markup_parse_context_ref(context: PGMarkupParseContext): PGMarkupParseContext; cdecl; external;
function g_markup_printf_escaped(format: Pgchar; args: array of const): Pgchar; cdecl; external;
function g_markup_vprintf_escaped(format: Pgchar; args: Tva_list): Pgchar; cdecl; external;
function g_match_info_expand_references(match_info: PGMatchInfo; string_to_expand: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_match_info_fetch(match_info: PGMatchInfo; match_num: gint): Pgchar; cdecl; external;
function g_match_info_fetch_all(match_info: PGMatchInfo): PPgchar; cdecl; external;
function g_match_info_fetch_named(match_info: PGMatchInfo; name: Pgchar): Pgchar; cdecl; external;
function g_match_info_fetch_named_pos(match_info: PGMatchInfo; name: Pgchar; start_pos: Pgint; end_pos: Pgint): gboolean; cdecl; external;
function g_match_info_fetch_pos(match_info: PGMatchInfo; match_num: gint; start_pos: Pgint; end_pos: Pgint): gboolean; cdecl; external;
function g_match_info_get_match_count(match_info: PGMatchInfo): gint; cdecl; external;
function g_match_info_get_regex(match_info: PGMatchInfo): PGRegex; cdecl; external;
function g_match_info_get_string(match_info: PGMatchInfo): Pgchar; cdecl; external;
function g_match_info_get_type: TGType; cdecl; external;
function g_match_info_is_partial_match(match_info: PGMatchInfo): gboolean; cdecl; external;
function g_match_info_matches(match_info: PGMatchInfo): gboolean; cdecl; external;
function g_match_info_next(match_info: PGMatchInfo; error: PPGError): gboolean; cdecl; external;
function g_match_info_ref(match_info: PGMatchInfo): PGMatchInfo; cdecl; external;
function g_mem_is_system_malloc: gboolean; cdecl; external;
function g_memdup(mem: Pgpointer; byte_size: guint): gpointer; cdecl; external;
function g_mkdir_with_parents(pathname: Pgchar; mode: gint): gint; cdecl; external;
function g_mkdtemp(tmpl: Pgchar): Pgchar; cdecl; external;
function g_mkdtemp_full(tmpl: Pgchar; mode: gint): Pgchar; cdecl; external;
function g_mkstemp(tmpl: Pgchar): gint; cdecl; external;
function g_mkstemp_full(tmpl: Pgchar; flags: gint; mode: gint): gint; cdecl; external;
function g_mutex_trylock(mutex: PGMutex): gboolean; cdecl; external;
function g_node_child_index(node: PGNode; data: gpointer): gint; cdecl; external;
function g_node_child_position(node: PGNode; child: PGNode): gint; cdecl; external;
function g_node_copy(node: PGNode): PGNode; cdecl; external;
function g_node_copy_deep(node: PGNode; copy_func: TGCopyFunc; data: gpointer): PGNode; cdecl; external;
function g_node_depth(node: PGNode): guint; cdecl; external;
function g_node_find(root: PGNode; order: TGTraverseType; flags: TGTraverseFlags; data: gpointer): PGNode; cdecl; external;
function g_node_find_child(node: PGNode; flags: TGTraverseFlags; data: gpointer): PGNode; cdecl; external;
function g_node_first_sibling(node: PGNode): PGNode; cdecl; external;
function g_node_get_root(node: PGNode): PGNode; cdecl; external;
function g_node_insert(parent: PGNode; position: gint; node: PGNode): PGNode; cdecl; external;
function g_node_insert_after(parent: PGNode; sibling: PGNode; node: PGNode): PGNode; cdecl; external;
function g_node_insert_before(parent: PGNode; sibling: PGNode; node: PGNode): PGNode; cdecl; external;
function g_node_is_ancestor(node: PGNode; descendant: PGNode): gboolean; cdecl; external;
function g_node_last_child(node: PGNode): PGNode; cdecl; external;
function g_node_last_sibling(node: PGNode): PGNode; cdecl; external;
function g_node_max_height(root: PGNode): guint; cdecl; external;
function g_node_n_children(node: PGNode): guint; cdecl; external;
function g_node_n_nodes(root: PGNode; flags: TGTraverseFlags): guint; cdecl; external;
function g_node_new(data: gpointer): PGNode; cdecl; external;
function g_node_nth_child(node: PGNode; n: guint): PGNode; cdecl; external;
function g_node_prepend(parent: PGNode; node: PGNode): PGNode; cdecl; external;
function g_once_impl(once: PGOnce; func: TGThreadFunc; arg: gpointer): gpointer; cdecl; external;
function g_once_init_enter(location: Pgpointer): gboolean; cdecl; external;
function g_option_context_get_description(context: PGOptionContext): Pgchar; cdecl; external;
function g_option_context_get_help(context: PGOptionContext; main_help: gboolean; group: PGOptionGroup): Pgchar; cdecl; external;
function g_option_context_get_help_enabled(context: PGOptionContext): gboolean; cdecl; external;
function g_option_context_get_ignore_unknown_options(context: PGOptionContext): gboolean; cdecl; external;
function g_option_context_get_main_group(context: PGOptionContext): PGOptionGroup; cdecl; external;
function g_option_context_get_summary(context: PGOptionContext): Pgchar; cdecl; external;
function g_option_context_new(parameter_string: Pgchar): PGOptionContext; cdecl; external;
function g_option_context_parse(context: PGOptionContext; argc: Pgint; argv: PPPgchar; error: PPGError): gboolean; cdecl; external;
function g_option_error_quark: TGQuark; cdecl; external;
function g_option_group_new(name: Pgchar; description: Pgchar; help_description: Pgchar; user_data: gpointer; destroy_: TGDestroyNotify): PGOptionGroup; cdecl; external;
function g_parse_debug_string(string_: Pgchar; keys: PGDebugKey; nkeys: guint): guint; cdecl; external;
function g_path_get_basename(file_name: Pgchar): Pgchar; cdecl; external;
function g_path_get_dirname(file_name: Pgchar): Pgchar; cdecl; external;
function g_path_is_absolute(file_name: Pgchar): gboolean; cdecl; external;
function g_path_skip_root(file_name: Pgchar): Pgchar; cdecl; external;
function g_pattern_match(pspec: PGPatternSpec; string_length: guint; string_: Pgchar; string_reversed: Pgchar): gboolean; cdecl; external;
function g_pattern_match_simple(pattern: Pgchar; string_: Pgchar): gboolean; cdecl; external;
function g_pattern_match_string(pspec: PGPatternSpec; string_: Pgchar): gboolean; cdecl; external;
function g_pattern_spec_equal(pspec1: PGPatternSpec; pspec2: PGPatternSpec): gboolean; cdecl; external;
function g_pattern_spec_new(pattern: Pgchar): PGPatternSpec; cdecl; external;
function g_pointer_bit_trylock(address: Pgpointer; lock_bit: gint): gboolean; cdecl; external;
function g_poll(fds: PGPollFD; nfds: guint; timeout: gint): gint; cdecl; external;
function g_pollfd_get_type: TGType; cdecl; external;
function g_printf(format: Pgchar; args: array of const): gint; cdecl; external;
function g_printf_string_upper_bound(format: Pgchar; args: Tva_list): gsize; cdecl; external;
function g_private_get(key: PGPrivate): gpointer; cdecl; external;
function g_ptr_array_free(array_: Pgpointer; free_seg: gboolean): Pgpointer; cdecl; external;
function g_ptr_array_get_type: TGType; cdecl; external;
function g_ptr_array_new: Pgpointer; cdecl; external;
function g_ptr_array_new_full(reserved_size: guint; element_free_func: TGDestroyNotify): Pgpointer; cdecl; external;
function g_ptr_array_new_with_free_func(element_free_func: TGDestroyNotify): Pgpointer; cdecl; external;
function g_ptr_array_ref(array_: Pgpointer): Pgpointer; cdecl; external;
function g_ptr_array_remove(array_: Pgpointer; data: gpointer): gboolean; cdecl; external;
function g_ptr_array_remove_fast(array_: Pgpointer; data: gpointer): gboolean; cdecl; external;
function g_ptr_array_remove_index(array_: Pgpointer; index_: guint): gpointer; cdecl; external;
function g_ptr_array_remove_index_fast(array_: Pgpointer; index_: guint): gpointer; cdecl; external;
function g_ptr_array_sized_new(reserved_size: guint): Pgpointer; cdecl; external;
function g_quark_from_static_string(string_: Pgchar): TGQuark; cdecl; external;
function g_quark_from_string(string_: Pgchar): TGQuark; cdecl; external;
function g_quark_to_string(quark: TGQuark): Pgchar; cdecl; external;
function g_quark_try_string(string_: Pgchar): TGQuark; cdecl; external;
function g_queue_copy(queue: PGQueue): PGQueue; cdecl; external;
function g_queue_find(queue: PGQueue; data: Pgpointer): PGList; cdecl; external;
function g_queue_find_custom(queue: PGQueue; data: Pgpointer; func: TGCompareFunc): PGList; cdecl; external;
function g_queue_get_length(queue: PGQueue): guint; cdecl; external;
function g_queue_index(queue: PGQueue; data: Pgpointer): gint; cdecl; external;
function g_queue_is_empty(queue: PGQueue): gboolean; cdecl; external;
function g_queue_link_index(queue: PGQueue; link_: PGList): gint; cdecl; external;
function g_queue_new: PGQueue; cdecl; external;
function g_queue_peek_head(queue: PGQueue): gpointer; cdecl; external;
function g_queue_peek_head_link(queue: PGQueue): PGList; cdecl; external;
function g_queue_peek_nth(queue: PGQueue; n: guint): gpointer; cdecl; external;
function g_queue_peek_nth_link(queue: PGQueue; n: guint): PGList; cdecl; external;
function g_queue_peek_tail(queue: PGQueue): gpointer; cdecl; external;
function g_queue_peek_tail_link(queue: PGQueue): PGList; cdecl; external;
function g_queue_pop_head(queue: PGQueue): gpointer; cdecl; external;
function g_queue_pop_head_link(queue: PGQueue): PGList; cdecl; external;
function g_queue_pop_nth(queue: PGQueue; n: guint): gpointer; cdecl; external;
function g_queue_pop_nth_link(queue: PGQueue; n: guint): PGList; cdecl; external;
function g_queue_pop_tail(queue: PGQueue): gpointer; cdecl; external;
function g_queue_pop_tail_link(queue: PGQueue): PGList; cdecl; external;
function g_queue_remove(queue: PGQueue; data: Pgpointer): gboolean; cdecl; external;
function g_queue_remove_all(queue: PGQueue; data: Pgpointer): guint; cdecl; external;
function g_rand_copy(rand_: PGRand): PGRand; cdecl; external;
function g_rand_double(rand_: PGRand): gdouble; cdecl; external;
function g_rand_double_range(rand_: PGRand; begin_: gdouble; end_: gdouble): gdouble; cdecl; external;
function g_rand_int(rand_: PGRand): guint32; cdecl; external;
function g_rand_int_range(rand_: PGRand; begin_: gint32; end_: gint32): gint32; cdecl; external;
function g_rand_new: PGRand; cdecl; external;
function g_rand_new_with_seed(seed: guint32): PGRand; cdecl; external;
function g_rand_new_with_seed_array(seed: Pguint32; seed_length: guint): PGRand; cdecl; external;
function g_random_double: gdouble; cdecl; external;
function g_random_double_range(begin_: gdouble; end_: gdouble): gdouble; cdecl; external;
function g_random_int: guint32; cdecl; external;
function g_random_int_range(begin_: gint32; end_: gint32): gint32; cdecl; external;
function g_realloc(mem: gpointer; n_bytes: gsize): gpointer; cdecl; external;
function g_realloc_n(mem: gpointer; n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl; external;
function g_rec_mutex_trylock(rec_mutex: PGRecMutex): gboolean; cdecl; external;
function g_regex_check_replacement(replacement: Pgchar; has_references: Pgboolean; error: PPGError): gboolean; cdecl; external;
function g_regex_error_quark: TGQuark; cdecl; external;
function g_regex_escape_nul(string_: Pgchar; length: gint): Pgchar; cdecl; external;
function g_regex_escape_string(string_: Pgchar; length: gint): Pgchar; cdecl; external;
function g_regex_get_capture_count(regex: PGRegex): gint; cdecl; external;
function g_regex_get_compile_flags(regex: PGRegex): TGRegexCompileFlags; cdecl; external;
function g_regex_get_has_cr_or_lf(regex: PGRegex): gboolean; cdecl; external;
function g_regex_get_match_flags(regex: PGRegex): TGRegexMatchFlags; cdecl; external;
function g_regex_get_max_backref(regex: PGRegex): gint; cdecl; external;
function g_regex_get_pattern(regex: PGRegex): Pgchar; cdecl; external;
function g_regex_get_string_number(regex: PGRegex; name: Pgchar): gint; cdecl; external;
function g_regex_get_type: TGType; cdecl; external;
function g_regex_match(regex: PGRegex; string_: Pgchar; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo): gboolean; cdecl; external;
function g_regex_match_all(regex: PGRegex; string_: Pgchar; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo): gboolean; cdecl; external;
function g_regex_match_all_full(regex: PGRegex; string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo; error: PPGError): gboolean; cdecl; external;
function g_regex_match_full(regex: PGRegex; string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo; error: PPGError): gboolean; cdecl; external;
function g_regex_match_simple(pattern: Pgchar; string_: Pgchar; compile_options: TGRegexCompileFlags; match_options: TGRegexMatchFlags): gboolean; cdecl; external;
function g_regex_new(pattern: Pgchar; compile_options: TGRegexCompileFlags; match_options: TGRegexMatchFlags; error: PPGError): PGRegex; cdecl; external;
function g_regex_ref(regex: PGRegex): PGRegex; cdecl; external;
function g_regex_replace(regex: PGRegex; string_: Pgchar; string_len: gssize; start_position: gint; replacement: Pgchar; match_options: TGRegexMatchFlags; error: PPGError): Pgchar; cdecl; external;
function g_regex_replace_eval(regex: PGRegex; string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; eval: TGRegexEvalCallback; user_data: gpointer; error: PPGError): Pgchar; cdecl; external;
function g_regex_replace_literal(regex: PGRegex; string_: Pgchar; string_len: gssize; start_position: gint; replacement: Pgchar; match_options: TGRegexMatchFlags; error: PPGError): Pgchar; cdecl; external;
function g_regex_split(regex: PGRegex; string_: Pgchar; match_options: TGRegexMatchFlags): PPgchar; cdecl; external;
function g_regex_split_full(regex: PGRegex; string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; max_tokens: gint; error: PPGError): PPgchar; cdecl; external;
function g_regex_split_simple(pattern: Pgchar; string_: Pgchar; compile_options: TGRegexCompileFlags; match_options: TGRegexMatchFlags): PPgchar; cdecl; external;
function g_rmdir(filename: Pgchar): gint; cdecl; external;
function g_rw_lock_reader_trylock(rw_lock: PGRWLock): gboolean; cdecl; external;
function g_rw_lock_writer_trylock(rw_lock: PGRWLock): gboolean; cdecl; external;
function g_scanner_cur_line(scanner: PGScanner): guint; cdecl; external;
function g_scanner_cur_position(scanner: PGScanner): guint; cdecl; external;
function g_scanner_cur_token(scanner: PGScanner): TGTokenType; cdecl; external;
function g_scanner_cur_value(scanner: PGScanner): TGTokenValue; cdecl; external;
function g_scanner_eof(scanner: PGScanner): gboolean; cdecl; external;
function g_scanner_get_next_token(scanner: PGScanner): TGTokenType; cdecl; external;
function g_scanner_lookup_symbol(scanner: PGScanner; symbol: Pgchar): gpointer; cdecl; external;
function g_scanner_new(config_templ: PGScannerConfig): PGScanner; cdecl; external;
function g_scanner_peek_next_token(scanner: PGScanner): TGTokenType; cdecl; external;
function g_scanner_scope_lookup_symbol(scanner: PGScanner; scope_id: guint; symbol: Pgchar): gpointer; cdecl; external;
function g_scanner_set_scope(scanner: PGScanner; scope_id: guint): guint; cdecl; external;
function g_sequence_append(seq: PGSequence; data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_get(iter: PGSequenceIter): gpointer; cdecl; external;
function g_sequence_get_begin_iter(seq: PGSequence): PGSequenceIter; cdecl; external;
function g_sequence_get_end_iter(seq: PGSequence): PGSequenceIter; cdecl; external;
function g_sequence_get_iter_at_pos(seq: PGSequence; pos: gint): PGSequenceIter; cdecl; external;
function g_sequence_get_length(seq: PGSequence): gint; cdecl; external;
function g_sequence_insert_before(iter: PGSequenceIter; data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_insert_sorted(seq: PGSequence; data: gpointer; cmp_func: TGCompareDataFunc; cmp_data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_insert_sorted_iter(seq: PGSequence; data: gpointer; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_iter_compare(a: PGSequenceIter; b: PGSequenceIter): gint; cdecl; external;
function g_sequence_iter_get_position(iter: PGSequenceIter): gint; cdecl; external;
function g_sequence_iter_get_sequence(iter: PGSequenceIter): PGSequence; cdecl; external;
function g_sequence_iter_is_begin(iter: PGSequenceIter): gboolean; cdecl; external;
function g_sequence_iter_is_end(iter: PGSequenceIter): gboolean; cdecl; external;
function g_sequence_iter_move(iter: PGSequenceIter; delta: gint): PGSequenceIter; cdecl; external;
function g_sequence_iter_next(iter: PGSequenceIter): PGSequenceIter; cdecl; external;
function g_sequence_iter_prev(iter: PGSequenceIter): PGSequenceIter; cdecl; external;
function g_sequence_lookup(seq: PGSequence; data: gpointer; cmp_func: TGCompareDataFunc; cmp_data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_lookup_iter(seq: PGSequence; data: gpointer; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_new(data_destroy: TGDestroyNotify): PGSequence; cdecl; external;
function g_sequence_prepend(seq: PGSequence; data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_range_get_midpoint(begin_: PGSequenceIter; end_: PGSequenceIter): PGSequenceIter; cdecl; external;
function g_sequence_search(seq: PGSequence; data: gpointer; cmp_func: TGCompareDataFunc; cmp_data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_search_iter(seq: PGSequence; data: gpointer; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer): PGSequenceIter; cdecl; external;
function g_set_print_handler(func: TGPrintFunc): TGPrintFunc; cdecl; external;
function g_set_printerr_handler(func: TGPrintFunc): TGPrintFunc; cdecl; external;
function g_setenv(variable: Pgchar; value: Pgchar; overwrite: gboolean): gboolean; cdecl; external;
function g_shell_error_quark: TGQuark; cdecl; external;
function g_shell_parse_argv(command_line: Pgchar; argcp: Pgint; argvp: PPPgchar; error: PPGError): gboolean; cdecl; external;
function g_shell_quote(unquoted_string: Pgchar): Pgchar; cdecl; external;
function g_shell_unquote(quoted_string: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_slice_alloc(block_size: gsize): gpointer; cdecl; external;
function g_slice_alloc0(block_size: gsize): gpointer; cdecl; external;
function g_slice_copy(block_size: gsize; mem_block: Pgpointer): gpointer; cdecl; external;
function g_slice_get_config(ckey: TGSliceConfig): gint64; cdecl; external;
function g_slice_get_config_state(ckey: TGSliceConfig; address: gint64; n_values: Pguint): Pgint64; cdecl; external;
function g_slist_alloc: PGSList; cdecl; external;
function g_slist_append(list: PGSList; data: gpointer): PGSList; cdecl; external;
function g_slist_concat(list1: PGSList; list2: PGSList): PGSList; cdecl; external;
function g_slist_copy(list: PGSList): PGSList; cdecl; external;
function g_slist_copy_deep(list: PGSList; func: TGCopyFunc; user_data: gpointer): PGSList; cdecl; external;
function g_slist_delete_link(list: PGSList; link_: PGSList): PGSList; cdecl; external;
function g_slist_find(list: PGSList; data: Pgpointer): PGSList; cdecl; external;
function g_slist_find_custom(list: PGSList; data: Pgpointer; func: TGCompareFunc): PGSList; cdecl; external;
function g_slist_index(list: PGSList; data: Pgpointer): gint; cdecl; external;
function g_slist_insert(list: PGSList; data: gpointer; position: gint): PGSList; cdecl; external;
function g_slist_insert_before(slist: PGSList; sibling: PGSList; data: gpointer): PGSList; cdecl; external;
function g_slist_insert_sorted(list: PGSList; data: gpointer; func: TGCompareFunc): PGSList; cdecl; external;
function g_slist_insert_sorted_with_data(list: PGSList; data: gpointer; func: TGCompareDataFunc; user_data: gpointer): PGSList; cdecl; external;
function g_slist_last(list: PGSList): PGSList; cdecl; external;
function g_slist_length(list: PGSList): guint; cdecl; external;
function g_slist_nth(list: PGSList; n: guint): PGSList; cdecl; external;
function g_slist_nth_data(list: PGSList; n: guint): gpointer; cdecl; external;
function g_slist_position(list: PGSList; llink: PGSList): gint; cdecl; external;
function g_slist_prepend(list: PGSList; data: gpointer): PGSList; cdecl; external;
function g_slist_remove(list: PGSList; data: Pgpointer): PGSList; cdecl; external;
function g_slist_remove_all(list: PGSList; data: Pgpointer): PGSList; cdecl; external;
function g_slist_remove_link(list: PGSList; link_: PGSList): PGSList; cdecl; external;
function g_slist_reverse(list: PGSList): PGSList; cdecl; external;
function g_slist_sort(list: PGSList; compare_func: TGCompareFunc): PGSList; cdecl; external;
function g_slist_sort_with_data(list: PGSList; compare_func: TGCompareDataFunc; user_data: gpointer): PGSList; cdecl; external;
function g_snprintf(string_: Pgchar; n: gulong; format: Pgchar; args: array of const): gint; cdecl; external;
function g_source_add_unix_fd(source: PGSource; fd: gint; events: TGIOCondition): gpointer; cdecl; external;
function g_source_attach(source: PGSource; context: PGMainContext): guint; cdecl; external;
function g_source_get_can_recurse(source: PGSource): gboolean; cdecl; external;
function g_source_get_context(source: PGSource): PGMainContext; cdecl; external;
function g_source_get_id(source: PGSource): guint; cdecl; external;
function g_source_get_name(source: PGSource): Pgchar; cdecl; external;
function g_source_get_priority(source: PGSource): gint; cdecl; external;
function g_source_get_ready_time(source: PGSource): gint64; cdecl; external;
function g_source_get_time(source: PGSource): gint64; cdecl; external;
function g_source_get_type: TGType; cdecl; external;
function g_source_is_destroyed(source: PGSource): gboolean; cdecl; external;
function g_source_new(source_funcs: PGSourceFuncs; struct_size: guint): PGSource; cdecl; external;
function g_source_query_unix_fd(source: PGSource; tag: gpointer): TGIOCondition; cdecl; external;
function g_source_ref(source: PGSource): PGSource; cdecl; external;
function g_source_remove(tag: guint): gboolean; cdecl; external;
function g_source_remove_by_funcs_user_data(funcs: PGSourceFuncs; user_data: gpointer): gboolean; cdecl; external;
function g_source_remove_by_user_data(user_data: gpointer): gboolean; cdecl; external;
function g_spaced_primes_closest(num: guint): guint; cdecl; external;
function g_spawn_async(working_directory: Pgchar; argv: PPgchar; envp: PPgchar; flags: TGSpawnFlags; child_setup: TGSpawnChildSetupFunc; user_data: gpointer; child_pid: PGPid; error: PPGError): gboolean; cdecl; external;
function g_spawn_async_with_pipes(working_directory: Pgchar; argv: PPgchar; envp: PPgchar; flags: TGSpawnFlags; child_setup: TGSpawnChildSetupFunc; user_data: gpointer; child_pid: PGPid; standard_input: Pgint; standard_output: Pgint; standard_error: Pgint; error: PPGError): gboolean; cdecl; external;
function g_spawn_check_exit_status(exit_status: gint; error: PPGError): gboolean; cdecl; external;
function g_spawn_command_line_async(command_line: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_spawn_command_line_sync(command_line: Pgchar; standard_output: PPgchar; standard_error: PPgchar; exit_status: Pgint; error: PPGError): gboolean; cdecl; external;
function g_spawn_error_quark: TGQuark; cdecl; external;
function g_spawn_exit_error_quark: TGQuark; cdecl; external;
function g_spawn_sync(working_directory: Pgchar; argv: PPgchar; envp: PPgchar; flags: TGSpawnFlags; child_setup: TGSpawnChildSetupFunc; user_data: gpointer; standard_output: PPgchar; standard_error: PPgchar; exit_status: Pgint; error: PPGError): gboolean; cdecl; external;
function g_sprintf(string_: Pgchar; format: Pgchar; args: array of const): gint; cdecl; external;
function g_stpcpy(dest: Pgchar; src: Pgchar): Pgchar; cdecl; external;
function g_str_equal(v1: Pgpointer; v2: Pgpointer): gboolean; cdecl; external;
function g_str_has_prefix(str: Pgchar; prefix: Pgchar): gboolean; cdecl; external;
function g_str_has_suffix(str: Pgchar; suffix: Pgchar): gboolean; cdecl; external;
function g_str_hash(v: Pgpointer): guint; cdecl; external;
function g_strcanon(string_: Pgchar; valid_chars: Pgchar; substitutor: gchar): Pgchar; cdecl; external;
function g_strcasecmp(s1: Pgchar; s2: Pgchar): gint; cdecl; external;
function g_strchomp(string_: Pgchar): Pgchar; cdecl; external;
function g_strchug(string_: Pgchar): Pgchar; cdecl; external;
function g_strcmp0(str1: Pgchar; str2: Pgchar): gint; cdecl; external;
function g_strcompress(source: Pgchar): Pgchar; cdecl; external;
function g_strconcat(string1: Pgchar; args: array of const): Pgchar; cdecl; external;
function g_strdelimit(string_: Pgchar; delimiters: Pgchar; new_delimiter: gchar): Pgchar; cdecl; external;
function g_strdown(string_: Pgchar): Pgchar; cdecl; external;
function g_strdup(str: Pgchar): Pgchar; cdecl; external;
function g_strdup_printf(format: Pgchar; args: array of const): Pgchar; cdecl; external;
function g_strdup_vprintf(format: Pgchar; args: Tva_list): Pgchar; cdecl; external;
function g_strdupv(str_array: PPgchar): PPgchar; cdecl; external;
function g_strerror(errnum: gint): Pgchar; cdecl; external;
function g_strescape(source: Pgchar; exceptions: Pgchar): Pgchar; cdecl; external;
function g_string_append(string_: PGString; val: Pgchar): PGString; cdecl; external;
function g_string_append_c(string_: PGString; c: gchar): PGString; cdecl; external;
function g_string_append_len(string_: PGString; val: Pgchar; len: gssize): PGString; cdecl; external;
function g_string_append_unichar(string_: PGString; wc: gunichar): PGString; cdecl; external;
function g_string_append_uri_escaped(string_: PGString; unescaped: Pgchar; reserved_chars_allowed: Pgchar; allow_utf8: gboolean): PGString; cdecl; external;
function g_string_ascii_down(string_: PGString): PGString; cdecl; external;
function g_string_ascii_up(string_: PGString): PGString; cdecl; external;
function g_string_assign(string_: PGString; rval: Pgchar): PGString; cdecl; external;
function g_string_chunk_insert(chunk: PGStringChunk; string_: Pgchar): Pgchar; cdecl; external;
function g_string_chunk_insert_const(chunk: PGStringChunk; string_: Pgchar): Pgchar; cdecl; external;
function g_string_chunk_insert_len(chunk: PGStringChunk; string_: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_string_chunk_new(size: gsize): PGStringChunk; cdecl; external;
function g_string_equal(v: PGString; v2: PGString): gboolean; cdecl; external;
function g_string_erase(string_: PGString; pos: gssize; len: gssize): PGString; cdecl; external;
function g_string_free(string_: PGString; free_segment: gboolean): Pgchar; cdecl; external;
function g_string_free_to_bytes(string_: PGString): PGBytes; cdecl; external;
function g_string_hash(str: PGString): guint; cdecl; external;
function g_string_insert(string_: PGString; pos: gssize; val: Pgchar): PGString; cdecl; external;
function g_string_insert_c(string_: PGString; pos: gssize; c: gchar): PGString; cdecl; external;
function g_string_insert_len(string_: PGString; pos: gssize; val: Pgchar; len: gssize): PGString; cdecl; external;
function g_string_insert_unichar(string_: PGString; pos: gssize; wc: gunichar): PGString; cdecl; external;
function g_string_new(init: Pgchar): PGString; cdecl; external;
function g_string_new_len(init: Pgchar; len: gssize): PGString; cdecl; external;
function g_string_overwrite(string_: PGString; pos: gsize; val: Pgchar): PGString; cdecl; external;
function g_string_overwrite_len(string_: PGString; pos: gsize; val: Pgchar; len: gssize): PGString; cdecl; external;
function g_string_prepend(string_: PGString; val: Pgchar): PGString; cdecl; external;
function g_string_prepend_c(string_: PGString; c: gchar): PGString; cdecl; external;
function g_string_prepend_len(string_: PGString; val: Pgchar; len: gssize): PGString; cdecl; external;
function g_string_prepend_unichar(string_: PGString; wc: gunichar): PGString; cdecl; external;
function g_string_set_size(string_: PGString; len: gsize): PGString; cdecl; external;
function g_string_sized_new(dfl_size: gsize): PGString; cdecl; external;
function g_string_truncate(string_: PGString; len: gsize): PGString; cdecl; external;
function g_strip_context(msgid: Pgchar; msgval: Pgchar): Pgchar; cdecl; external;
function g_strjoin(separator: Pgchar; args: array of const): Pgchar; cdecl; external;
function g_strjoinv(separator: Pgchar; str_array: PPgchar): Pgchar; cdecl; external;
function g_strlcat(dest: Pgchar; src: Pgchar; dest_size: gsize): gsize; cdecl; external;
function g_strlcpy(dest: Pgchar; src: Pgchar; dest_size: gsize): gsize; cdecl; external;
function g_strncasecmp(s1: Pgchar; s2: Pgchar; n: guint): gint; cdecl; external;
function g_strndup(str: Pgchar; n: gsize): Pgchar; cdecl; external;
function g_strnfill(length: gsize; fill_char: gchar): Pgchar; cdecl; external;
function g_strreverse(string_: Pgchar): Pgchar; cdecl; external;
function g_strrstr(haystack: Pgchar; needle: Pgchar): Pgchar; cdecl; external;
function g_strrstr_len(haystack: Pgchar; haystack_len: gssize; needle: Pgchar): Pgchar; cdecl; external;
function g_strsignal(signum: gint): Pgchar; cdecl; external;
function g_strsplit(string_: Pgchar; delimiter: Pgchar; max_tokens: gint): PPgchar; cdecl; external;
function g_strsplit_set(string_: Pgchar; delimiters: Pgchar; max_tokens: gint): PPgchar; cdecl; external;
function g_strstr_len(haystack: Pgchar; haystack_len: gssize; needle: Pgchar): Pgchar; cdecl; external;
function g_strtod(nptr: Pgchar; endptr: PPgchar): gdouble; cdecl; external;
function g_strup(string_: Pgchar): Pgchar; cdecl; external;
function g_strv_get_type: TGType; cdecl; external;
function g_strv_length(str_array: PPgchar): guint; cdecl; external;
function g_test_create_case(test_name: Pgchar; data_size: gsize; test_data: Pgpointer; data_setup: TGTestFixtureFunc; data_test: TGTestFixtureFunc; data_teardown: TGTestFixtureFunc): PGTestCase; cdecl; external;
function g_test_create_suite(suite_name: Pgchar): PGTestSuite; cdecl; external;
function g_test_get_root: PGTestSuite; cdecl; external;
function g_test_log_buffer_new: PGTestLogBuffer; cdecl; external;
function g_test_log_buffer_pop(tbuffer: PGTestLogBuffer): PGTestLogMsg; cdecl; external;
function g_test_log_type_name(log_type: TGTestLogType): Pgchar; cdecl; external;
function g_test_rand_double: gdouble; cdecl; external;
function g_test_rand_double_range(range_start: gdouble; range_end: gdouble): gdouble; cdecl; external;
function g_test_rand_int: gint32; cdecl; external;
function g_test_rand_int_range(begin_: gint32; end_: gint32): gint32; cdecl; external;
function g_test_run: gint; cdecl; external;
function g_test_run_suite(suite: PGTestSuite): gint; cdecl; external;
function g_test_timer_elapsed: gdouble; cdecl; external;
function g_test_timer_last: gdouble; cdecl; external;
function g_test_trap_fork(usec_timeout: guint64; test_trap_flags: TGTestTrapFlags): gboolean; cdecl; external;
function g_test_trap_has_passed: gboolean; cdecl; external;
function g_test_trap_reached_timeout: gboolean; cdecl; external;
function g_thread_error_quark: TGQuark; cdecl; external;
function g_thread_get_type: TGType; cdecl; external;
function g_thread_join(thread: PGThread): gpointer; cdecl; external;
function g_thread_new(name: Pgchar; func: TGThreadFunc; data: gpointer): PGThread; cdecl; external;
function g_thread_pool_get_max_idle_time: guint; cdecl; external;
function g_thread_pool_get_max_threads(pool: PGThreadPool): gint; cdecl; external;
function g_thread_pool_get_max_unused_threads: gint; cdecl; external;
function g_thread_pool_get_num_threads(pool: PGThreadPool): guint; cdecl; external;
function g_thread_pool_get_num_unused_threads: guint; cdecl; external;
function g_thread_pool_new(func: TGFunc; user_data: gpointer; max_threads: gint; exclusive: gboolean; error: PPGError): PGThreadPool; cdecl; external;
function g_thread_pool_push(pool: PGThreadPool; data: gpointer; error: PPGError): gboolean; cdecl; external;
function g_thread_pool_set_max_threads(pool: PGThreadPool; max_threads: gint; error: PPGError): gboolean; cdecl; external;
function g_thread_pool_unprocessed(pool: PGThreadPool): guint; cdecl; external;
function g_thread_ref(thread: PGThread): PGThread; cdecl; external;
function g_thread_self: PGThread; cdecl; external;
function g_thread_try_new(name: Pgchar; func: TGThreadFunc; data: gpointer; error: PPGError): PGThread; cdecl; external;
function g_time_val_from_iso8601(iso_date: Pgchar; time_: PGTimeVal): gboolean; cdecl; external;
function g_time_val_to_iso8601(time_: PGTimeVal): Pgchar; cdecl; external;
function g_time_zone_adjust_time(tz: PGTimeZone; type_: TGTimeType; time_: Pgint64): gint; cdecl; external;
function g_time_zone_find_interval(tz: PGTimeZone; type_: TGTimeType; time_: gint64): gint; cdecl; external;
function g_time_zone_get_abbreviation(tz: PGTimeZone; interval: gint): Pgchar; cdecl; external;
function g_time_zone_get_offset(tz: PGTimeZone; interval: gint): gint32; cdecl; external;
function g_time_zone_get_type: TGType; cdecl; external;
function g_time_zone_is_dst(tz: PGTimeZone; interval: gint): gboolean; cdecl; external;
function g_time_zone_new(identifier: Pgchar): PGTimeZone; cdecl; external;
function g_time_zone_new_local: PGTimeZone; cdecl; external;
function g_time_zone_new_utc: PGTimeZone; cdecl; external;
function g_time_zone_ref(tz: PGTimeZone): PGTimeZone; cdecl; external;
function g_timeout_add(interval: guint; function_: TGSourceFunc; data: gpointer): guint; cdecl; external;
function g_timeout_add_full(priority: gint; interval: guint; function_: TGSourceFunc; data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_timeout_add_seconds(interval: guint; function_: TGSourceFunc; data: gpointer): guint; cdecl; external;
function g_timeout_add_seconds_full(priority: gint; interval: guint; function_: TGSourceFunc; data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_timeout_source_new(interval: guint): PGSource; cdecl; external;
function g_timeout_source_new_seconds(interval: guint): PGSource; cdecl; external;
function g_timer_elapsed(timer: PGTimer; microseconds: Pgulong): gdouble; cdecl; external;
function g_timer_new: PGTimer; cdecl; external;
function g_trash_stack_height(stack_p: PPGTrashStack): guint; cdecl; external;
function g_trash_stack_peek(stack_p: PPGTrashStack): gpointer; cdecl; external;
function g_trash_stack_pop(stack_p: PPGTrashStack): gpointer; cdecl; external;
function g_tree_height(tree: PGTree): gint; cdecl; external;
function g_tree_lookup(tree: PGTree; key: Pgpointer): gpointer; cdecl; external;
function g_tree_lookup_extended(tree: PGTree; lookup_key: Pgpointer; orig_key: Pgpointer; value: Pgpointer): gboolean; cdecl; external;
function g_tree_new(key_compare_func: TGCompareFunc): PGTree; cdecl; external;
function g_tree_new_full(key_compare_func: TGCompareDataFunc; key_compare_data: gpointer; key_destroy_func: TGDestroyNotify; value_destroy_func: TGDestroyNotify): PGTree; cdecl; external;
function g_tree_new_with_data(key_compare_func: TGCompareDataFunc; key_compare_data: gpointer): PGTree; cdecl; external;
function g_tree_nnodes(tree: PGTree): gint; cdecl; external;
function g_tree_ref(tree: PGTree): PGTree; cdecl; external;
function g_tree_remove(tree: PGTree; key: Pgpointer): gboolean; cdecl; external;
function g_tree_search(tree: PGTree; search_func: TGCompareFunc; user_data: Pgpointer): gpointer; cdecl; external;
function g_tree_steal(tree: PGTree; key: Pgpointer): gboolean; cdecl; external;
function g_try_malloc(n_bytes: gsize): gpointer; cdecl; external;
function g_try_malloc0(n_bytes: gsize): gpointer; cdecl; external;
function g_try_malloc0_n(n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl; external;
function g_try_malloc_n(n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl; external;
function g_try_realloc(mem: gpointer; n_bytes: gsize): gpointer; cdecl; external;
function g_try_realloc_n(mem: gpointer; n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl; external;
function g_ucs4_to_utf16(str: Pgunichar; len: glong; items_read: Pglong; items_written: Pglong; error: PPGError): Pguint16; cdecl; external;
function g_ucs4_to_utf8(str: Pgunichar; len: glong; items_read: Pglong; items_written: Pglong; error: PPGError): Pgchar; cdecl; external;
function g_unichar_break_type(c: gunichar): TGUnicodeBreakType; cdecl; external;
function g_unichar_combining_class(uc: gunichar): gint; cdecl; external;
function g_unichar_compose(a: gunichar; b: gunichar; ch: Pgunichar): gboolean; cdecl; external;
function g_unichar_decompose(ch: gunichar; a: Pgunichar; b: Pgunichar): gboolean; cdecl; external;
function g_unichar_digit_value(c: gunichar): gint; cdecl; external;
function g_unichar_fully_decompose(ch: gunichar; compat: gboolean; result_: Pgunichar; result_len: gsize): gsize; cdecl; external;
function g_unichar_get_mirror_char(ch: gunichar; mirrored_ch: Pgunichar): gboolean; cdecl; external;
function g_unichar_get_script(ch: gunichar): TGUnicodeScript; cdecl; external;
function g_unichar_isalnum(c: gunichar): gboolean; cdecl; external;
function g_unichar_isalpha(c: gunichar): gboolean; cdecl; external;
function g_unichar_iscntrl(c: gunichar): gboolean; cdecl; external;
function g_unichar_isdefined(c: gunichar): gboolean; cdecl; external;
function g_unichar_isdigit(c: gunichar): gboolean; cdecl; external;
function g_unichar_isgraph(c: gunichar): gboolean; cdecl; external;
function g_unichar_islower(c: gunichar): gboolean; cdecl; external;
function g_unichar_ismark(c: gunichar): gboolean; cdecl; external;
function g_unichar_isprint(c: gunichar): gboolean; cdecl; external;
function g_unichar_ispunct(c: gunichar): gboolean; cdecl; external;
function g_unichar_isspace(c: gunichar): gboolean; cdecl; external;
function g_unichar_istitle(c: gunichar): gboolean; cdecl; external;
function g_unichar_isupper(c: gunichar): gboolean; cdecl; external;
function g_unichar_iswide(c: gunichar): gboolean; cdecl; external;
function g_unichar_iswide_cjk(c: gunichar): gboolean; cdecl; external;
function g_unichar_isxdigit(c: gunichar): gboolean; cdecl; external;
function g_unichar_iszerowidth(c: gunichar): gboolean; cdecl; external;
function g_unichar_to_utf8(c: gunichar; outbuf: Pgchar): gint; cdecl; external;
function g_unichar_tolower(c: gunichar): gunichar; cdecl; external;
function g_unichar_totitle(c: gunichar): gunichar; cdecl; external;
function g_unichar_toupper(c: gunichar): gunichar; cdecl; external;
function g_unichar_type(c: gunichar): TGUnicodeType; cdecl; external;
function g_unichar_validate(ch: gunichar): gboolean; cdecl; external;
function g_unichar_xdigit_value(c: gunichar): gint; cdecl; external;
function g_unicode_canonical_decomposition(ch: gunichar; result_len: Pgsize): Pgunichar; cdecl; external;
function g_unicode_script_from_iso15924(iso15924: guint32): TGUnicodeScript; cdecl; external;
function g_unicode_script_to_iso15924(script: TGUnicodeScript): guint32; cdecl; external;
function g_unix_error_quark: TGQuark; cdecl; external;
function g_unix_fd_add(fd: gint; condition: TGIOCondition; function_: TGUnixFDSourceFunc; user_data: gpointer): guint; cdecl; external;
function g_unix_fd_add_full(priority: gint; fd: gint; condition: TGIOCondition; function_: TGUnixFDSourceFunc; user_data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_unix_fd_source_new(fd: gint; condition: TGIOCondition): PGSource; cdecl; external;
function g_unix_open_pipe(fds: Pgint; flags: gint; error: PPGError): gboolean; cdecl; external;
function g_unix_set_fd_nonblocking(fd: gint; nonblock: gboolean; error: PPGError): gboolean; cdecl; external;
function g_unix_signal_add(signum: gint; handler: TGSourceFunc; user_data: gpointer): guint; cdecl; external;
function g_unix_signal_add_full(priority: gint; signum: gint; handler: TGSourceFunc; user_data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_unix_signal_source_new(signum: gint): PGSource; cdecl; external;
function g_unlink(filename: Pgchar): gint; cdecl; external;
function g_uri_escape_string(unescaped: Pgchar; reserved_chars_allowed: Pgchar; allow_utf8: gboolean): Pgchar; cdecl; external;
function g_uri_list_extract_uris(uri_list: Pgchar): PPgchar; cdecl; external;
function g_uri_parse_scheme(uri: Pgchar): Pgchar; cdecl; external;
function g_uri_unescape_segment(escaped_string: Pgchar; escaped_string_end: Pgchar; illegal_characters: Pgchar): Pgchar; cdecl; external;
function g_uri_unescape_string(escaped_string: Pgchar; illegal_characters: Pgchar): Pgchar; cdecl; external;
function g_utf16_to_ucs4(str: Pguint16; len: glong; items_read: Pglong; items_written: Pglong; error: PPGError): Pgunichar; cdecl; external;
function g_utf16_to_utf8(str: Pguint16; len: glong; items_read: Pglong; items_written: Pglong; error: PPGError): Pgchar; cdecl; external;
function g_utf8_casefold(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_utf8_collate(str1: Pgchar; str2: Pgchar): gint; cdecl; external;
function g_utf8_collate_key(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_utf8_collate_key_for_filename(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_utf8_find_next_char(p: Pgchar; end_: Pgchar): Pgchar; cdecl; external;
function g_utf8_find_prev_char(str: Pgchar; p: Pgchar): Pgchar; cdecl; external;
function g_utf8_get_char(p: Pgchar): gunichar; cdecl; external;
function g_utf8_get_char_validated(p: Pgchar; max_len: gssize): gunichar; cdecl; external;
function g_utf8_normalize(str: Pgchar; len: gssize; mode: TGNormalizeMode): Pgchar; cdecl; external;
function g_utf8_offset_to_pointer(str: Pgchar; offset: glong): Pgchar; cdecl; external;
function g_utf8_pointer_to_offset(str: Pgchar; pos: Pgchar): glong; cdecl; external;
function g_utf8_prev_char(p: Pgchar): Pgchar; cdecl; external;
function g_utf8_strchr(p: Pgchar; len: gssize; c: gunichar): Pgchar; cdecl; external;
function g_utf8_strdown(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_utf8_strlen(p: Pgchar; max: gssize): glong; cdecl; external;
function g_utf8_strncpy(dest: Pgchar; src: Pgchar; n: gsize): Pgchar; cdecl; external;
function g_utf8_strrchr(p: Pgchar; len: gssize; c: gunichar): Pgchar; cdecl; external;
function g_utf8_strreverse(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_utf8_strup(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_utf8_substring(str: Pgchar; start_pos: glong; end_pos: glong): Pgchar; cdecl; external;
function g_utf8_to_ucs4(str: Pgchar; len: glong; items_read: Pglong; items_written: Pglong; error: PPGError): Pgunichar; cdecl; external;
function g_utf8_to_ucs4_fast(str: Pgchar; len: glong; items_written: Pglong): Pgunichar; cdecl; external;
function g_utf8_to_utf16(str: Pgchar; len: glong; items_read: Pglong; items_written: Pglong; error: PPGError): Pguint16; cdecl; external;
function g_utf8_validate(str: Pgchar; max_len: gssize; end_: PPgchar): gboolean; cdecl; external;
function g_variant_builder_end(builder: PGVariantBuilder): PGVariant; cdecl; external;
function g_variant_builder_get_type: TGType; cdecl; external;
function g_variant_builder_new(type_: PGVariantType): PGVariantBuilder; cdecl; external;
function g_variant_builder_ref(builder: PGVariantBuilder): PGVariantBuilder; cdecl; external;
function g_variant_byteswap(value: PGVariant): PGVariant; cdecl; external;
function g_variant_check_format_string(value: PGVariant; format_string: Pgchar; copy_only: gboolean): gboolean; cdecl; external;
function g_variant_classify(value: PGVariant): TGVariantClass; cdecl; external;
function g_variant_compare(one: PGVariant; two: PGVariant): gint; cdecl; external;
function g_variant_dup_bytestring(value: PGVariant; length: Pgsize): Pgchar; cdecl; external;
function g_variant_dup_bytestring_array(value: PGVariant; length: Pgsize): PPgchar; cdecl; external;
function g_variant_dup_objv(value: PGVariant; length: Pgsize): PPgchar; cdecl; external;
function g_variant_dup_string(value: PGVariant; length: Pgsize): Pgchar; cdecl; external;
function g_variant_dup_strv(value: PGVariant; length: Pgsize): PPgchar; cdecl; external;
function g_variant_equal(one: PGVariant; two: PGVariant): gboolean; cdecl; external;
function g_variant_get_boolean(value: PGVariant): gboolean; cdecl; external;
function g_variant_get_byte(value: PGVariant): guint8; cdecl; external;
function g_variant_get_bytestring(value: PGVariant): Pgchar; cdecl; external;
function g_variant_get_bytestring_array(value: PGVariant; length: Pgsize): PPgchar; cdecl; external;
function g_variant_get_child_value(value: PGVariant; index_: gsize): PGVariant; cdecl; external;
function g_variant_get_data(value: PGVariant): Pgpointer; cdecl; external;
function g_variant_get_data_as_bytes(value: PGVariant): PGBytes; cdecl; external;
function g_variant_get_double(value: PGVariant): gdouble; cdecl; external;
function g_variant_get_fixed_array(value: PGVariant; n_elements: Pgsize; element_size: gsize): gpointer; cdecl; external;
function g_variant_get_gtype: TGType; cdecl; external;
function g_variant_get_handle(value: PGVariant): gint32; cdecl; external;
function g_variant_get_int16(value: PGVariant): gint16; cdecl; external;
function g_variant_get_int32(value: PGVariant): gint32; cdecl; external;
function g_variant_get_int64(value: PGVariant): gint64; cdecl; external;
function g_variant_get_maybe(value: PGVariant): PGVariant; cdecl; external;
function g_variant_get_normal_form(value: PGVariant): PGVariant; cdecl; external;
function g_variant_get_objv(value: PGVariant; length: Pgsize): PPgchar; cdecl; external;
function g_variant_get_size(value: PGVariant): gsize; cdecl; external;
function g_variant_get_string(value: PGVariant; length: Pgsize): Pgchar; cdecl; external;
function g_variant_get_strv(value: PGVariant; length: Pgsize): PPgchar; cdecl; external;
function g_variant_get_type(value: PGVariant): PGVariantType; cdecl; external;
function g_variant_get_type_string(value: PGVariant): Pgchar; cdecl; external;
function g_variant_get_uint16(value: PGVariant): guint16; cdecl; external;
function g_variant_get_uint32(value: PGVariant): guint32; cdecl; external;
function g_variant_get_uint64(value: PGVariant): guint64; cdecl; external;
function g_variant_get_variant(value: PGVariant): PGVariant; cdecl; external;
function g_variant_hash(value: PGVariant): guint; cdecl; external;
function g_variant_is_container(value: PGVariant): gboolean; cdecl; external;
function g_variant_is_floating(value: PGVariant): gboolean; cdecl; external;
function g_variant_is_normal_form(value: PGVariant): gboolean; cdecl; external;
function g_variant_is_object_path(string_: Pgchar): gboolean; cdecl; external;
function g_variant_is_of_type(value: PGVariant; type_: PGVariantType): gboolean; cdecl; external;
function g_variant_is_signature(string_: Pgchar): gboolean; cdecl; external;
function g_variant_iter_copy(iter: PGVariantIter): PGVariantIter; cdecl; external;
function g_variant_iter_init(iter: PGVariantIter; value: PGVariant): gsize; cdecl; external;
function g_variant_iter_loop(iter: PGVariantIter; format_string: Pgchar; args: array of const): gboolean; cdecl; external;
function g_variant_iter_n_children(iter: PGVariantIter): gsize; cdecl; external;
function g_variant_iter_new(value: PGVariant): PGVariantIter; cdecl; external;
function g_variant_iter_next(iter: PGVariantIter; format_string: Pgchar; args: array of const): gboolean; cdecl; external;
function g_variant_iter_next_value(iter: PGVariantIter): PGVariant; cdecl; external;
function g_variant_lookup(dictionary: PGVariant; key: Pgchar; format_string: Pgchar; args: array of const): gboolean; cdecl; external;
function g_variant_lookup_value(dictionary: PGVariant; key: Pgchar; expected_type: PGVariantType): PGVariant; cdecl; external;
function g_variant_n_children(value: PGVariant): gsize; cdecl; external;
function g_variant_new(format_string: Pgchar; args: array of const): PGVariant; cdecl; external;
function g_variant_new_array(child_type: PGVariantType; children: PPGVariant; n_children: gsize): PGVariant; cdecl; external;
function g_variant_new_boolean(value: gboolean): PGVariant; cdecl; external;
function g_variant_new_byte(value: guint8): PGVariant; cdecl; external;
function g_variant_new_bytestring(string_: Pgchar): PGVariant; cdecl; external;
function g_variant_new_bytestring_array(strv: PPgchar; length: gssize): PGVariant; cdecl; external;
function g_variant_new_dict_entry(key: PGVariant; value: PGVariant): PGVariant; cdecl; external;
function g_variant_new_double(value: gdouble): PGVariant; cdecl; external;
function g_variant_new_fixed_array(element_type: PGVariantType; elements: Pgpointer; n_elements: gsize; element_size: gsize): PGVariant; cdecl; external;
function g_variant_new_from_bytes(type_: PGVariantType; bytes: PGBytes; trusted: gboolean): PGVariant; cdecl; external;
function g_variant_new_from_data(type_: PGVariantType; data: guint8; size: gsize; trusted: gboolean; notify: TGDestroyNotify; user_data: gpointer): PGVariant; cdecl; external;
function g_variant_new_handle(value: gint32): PGVariant; cdecl; external;
function g_variant_new_int16(value: gint16): PGVariant; cdecl; external;
function g_variant_new_int32(value: gint32): PGVariant; cdecl; external;
function g_variant_new_int64(value: gint64): PGVariant; cdecl; external;
function g_variant_new_maybe(child_type: PGVariantType; child: PGVariant): PGVariant; cdecl; external;
function g_variant_new_object_path(object_path: Pgchar): PGVariant; cdecl; external;
function g_variant_new_objv(strv: PPgchar; length: gssize): PGVariant; cdecl; external;
function g_variant_new_parsed(format: Pgchar; args: array of const): PGVariant; cdecl; external;
function g_variant_new_parsed_va(format: Pgchar; app: Pva_list): PGVariant; cdecl; external;
function g_variant_new_signature(signature: Pgchar): PGVariant; cdecl; external;
function g_variant_new_string(string_: Pgchar): PGVariant; cdecl; external;
function g_variant_new_strv(strv: PPgchar; length: gssize): PGVariant; cdecl; external;
function g_variant_new_tuple(children: PPGVariant; n_children: gsize): PGVariant; cdecl; external;
function g_variant_new_uint16(value: guint16): PGVariant; cdecl; external;
function g_variant_new_uint32(value: guint32): PGVariant; cdecl; external;
function g_variant_new_uint64(value: guint64): PGVariant; cdecl; external;
function g_variant_new_va(format_string: Pgchar; endptr: PPgchar; app: Pva_list): PGVariant; cdecl; external;
function g_variant_new_variant(value: PGVariant): PGVariant; cdecl; external;
function g_variant_parse(type_: PGVariantType; text: Pgchar; limit: Pgchar; endptr: PPgchar; error: PPGError): PGVariant; cdecl; external;
function g_variant_parser_get_error_quark: TGQuark; cdecl; external;
function g_variant_print(value: PGVariant; type_annotate: gboolean): Pgchar; cdecl; external;
function g_variant_print_string(value: PGVariant; string_: PGString; type_annotate: gboolean): PGString; cdecl; external;
function g_variant_ref(value: PGVariant): PGVariant; cdecl; external;
function g_variant_ref_sink(value: PGVariant): PGVariant; cdecl; external;
function g_variant_take_ref(value: PGVariant): PGVariant; cdecl; external;
function g_variant_type_checked_(arg0: Pgchar): PGVariantType; cdecl; external;
function g_variant_type_copy(type_: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_dup_string(type_: PGVariantType): Pgchar; cdecl; external;
function g_variant_type_element(type_: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_equal(type1: PGVariantType; type2: PGVariantType): gboolean; cdecl; external;
function g_variant_type_first(type_: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_get_gtype: TGType; cdecl; external;
function g_variant_type_get_string_length(type_: PGVariantType): gsize; cdecl; external;
function g_variant_type_hash(type_: PGVariantType): guint; cdecl; external;
function g_variant_type_is_array(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_basic(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_container(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_definite(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_dict_entry(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_maybe(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_subtype_of(type_: PGVariantType; supertype: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_tuple(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_variant(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_key(type_: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_n_items(type_: PGVariantType): gsize; cdecl; external;
function g_variant_type_new(type_string: Pgchar): PGVariantType; cdecl; external;
function g_variant_type_new_array(element: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_new_dict_entry(key: PGVariantType; value: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_new_maybe(element: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_new_tuple(items: PPGVariantType; length: gint): PGVariantType; cdecl; external;
function g_variant_type_next(type_: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_peek_string(type_: PGVariantType): Pgchar; cdecl; external;
function g_variant_type_string_is_valid(type_string: Pgchar): gboolean; cdecl; external;
function g_variant_type_string_scan(string_: Pgchar; limit: Pgchar; endptr: PPgchar): gboolean; cdecl; external;
function g_variant_type_value(type_: PGVariantType): PGVariantType; cdecl; external;
function g_vasprintf(string_: PPgchar; format: Pgchar; args: Tva_list): gint; cdecl; external;
function g_vfprintf(file_: Pgpointer; format: Pgchar; args: Tva_list): gint; cdecl; external;
function g_vprintf(format: Pgchar; args: Tva_list): gint; cdecl; external;
function g_vsnprintf(string_: Pgchar; n: gulong; format: Pgchar; args: Tva_list): gint; cdecl; external;
function g_vsprintf(string_: Pgchar; format: Pgchar; args: Tva_list): gint; cdecl; external;
function glib_check_version(required_major: guint; required_minor: guint; required_micro: guint): Pgchar; cdecl; external;
procedure g_array_set_clear_func(array_: Pgpointer; clear_func: TGDestroyNotify); cdecl; external;
procedure g_array_sort(array_: Pgpointer; compare_func: TGCompareFunc); cdecl; external;
procedure g_array_sort_with_data(array_: Pgpointer; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_array_unref(array_: Pgpointer); cdecl; external;
procedure g_assert_warning(log_domain: Pgchar; file_: Pgchar; line: gint; pretty_function: Pgchar; expression: Pgchar); cdecl; external;
procedure g_assertion_message(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; message: Pgchar); cdecl; external;
procedure g_assertion_message_cmpnum(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; expr: Pgchar; arg1: long_double; cmp: Pgchar; arg2: long_double; numtype: gchar); cdecl; external;
procedure g_assertion_message_cmpstr(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; expr: Pgchar; arg1: Pgchar; cmp: Pgchar; arg2: Pgchar); cdecl; external;
procedure g_assertion_message_error(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; expr: Pgchar; error: PGError; error_domain: TGQuark; error_code: gint); cdecl; external;
procedure g_assertion_message_expr(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; expr: Pgchar); cdecl; external;
procedure g_async_queue_lock(queue: PGAsyncQueue); cdecl; external;
procedure g_async_queue_push(queue: PGAsyncQueue; data: gpointer); cdecl; external;
procedure g_async_queue_push_sorted(queue: PGAsyncQueue; data: gpointer; func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_async_queue_push_sorted_unlocked(queue: PGAsyncQueue; data: gpointer; func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_async_queue_push_unlocked(queue: PGAsyncQueue; data: gpointer); cdecl; external;
procedure g_async_queue_sort(queue: PGAsyncQueue; func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_async_queue_sort_unlocked(queue: PGAsyncQueue; func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_async_queue_unlock(queue: PGAsyncQueue); cdecl; external;
procedure g_async_queue_unref(queue: PGAsyncQueue); cdecl; external;
procedure g_atexit(func: TGVoidFunc); cdecl; external;
procedure g_atomic_int_inc(atomic: Pgint); cdecl; external;
procedure g_atomic_int_set(atomic: Pgint; newval: gint); cdecl; external;
procedure g_atomic_pointer_set(atomic: Pgpointer; newval: gpointer); cdecl; external;
procedure g_bit_lock(address: Pgint; lock_bit: gint); cdecl; external;
procedure g_bit_unlock(address: Pgint; lock_bit: gint); cdecl; external;
procedure g_bookmark_file_add_application(bookmark: PGBookmarkFile; uri: Pgchar; name: Pgchar; exec: Pgchar); cdecl; external;
procedure g_bookmark_file_add_group(bookmark: PGBookmarkFile; uri: Pgchar; group: Pgchar); cdecl; external;
procedure g_bookmark_file_free(bookmark: PGBookmarkFile); cdecl; external;
procedure g_bookmark_file_set_added(bookmark: PGBookmarkFile; uri: Pgchar; added: glong); cdecl; external;
procedure g_bookmark_file_set_description(bookmark: PGBookmarkFile; uri: Pgchar; description: Pgchar); cdecl; external;
procedure g_bookmark_file_set_groups(bookmark: PGBookmarkFile; uri: Pgchar; groups: PPgchar; length: gsize); cdecl; external;
procedure g_bookmark_file_set_icon(bookmark: PGBookmarkFile; uri: Pgchar; href: Pgchar; mime_type: Pgchar); cdecl; external;
procedure g_bookmark_file_set_is_private(bookmark: PGBookmarkFile; uri: Pgchar; is_private: gboolean); cdecl; external;
procedure g_bookmark_file_set_mime_type(bookmark: PGBookmarkFile; uri: Pgchar; mime_type: Pgchar); cdecl; external;
procedure g_bookmark_file_set_modified(bookmark: PGBookmarkFile; uri: Pgchar; modified: glong); cdecl; external;
procedure g_bookmark_file_set_title(bookmark: PGBookmarkFile; uri: Pgchar; title: Pgchar); cdecl; external;
procedure g_bookmark_file_set_visited(bookmark: PGBookmarkFile; uri: Pgchar; visited: glong); cdecl; external;
procedure g_byte_array_sort(array_: Pguint8; compare_func: TGCompareFunc); cdecl; external;
procedure g_byte_array_sort_with_data(array_: Pguint8; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_byte_array_unref(array_: Pguint8); cdecl; external;
procedure g_bytes_unref(bytes: PGBytes); cdecl; external;
procedure g_checksum_free(checksum: PGChecksum); cdecl; external;
procedure g_checksum_get_digest(checksum: PGChecksum; buffer: Pguint8; digest_len: Pgsize); cdecl; external;
procedure g_checksum_reset(checksum: PGChecksum); cdecl; external;
procedure g_checksum_update(checksum: PGChecksum; data: Pguint8; length: gssize); cdecl; external;
procedure g_clear_error; cdecl; external;
procedure g_clear_pointer(pp: Pgpointer; destroy_: TGDestroyNotify); cdecl; external;
procedure g_cond_broadcast(cond: PGCond); cdecl; external;
procedure g_cond_clear(cond: PGCond); cdecl; external;
procedure g_cond_init(cond: PGCond); cdecl; external;
procedure g_cond_signal(cond: PGCond); cdecl; external;
procedure g_cond_wait(cond: PGCond; mutex: PGMutex); cdecl; external;
procedure g_datalist_clear(datalist: PPGData); cdecl; external;
procedure g_datalist_foreach(datalist: PPGData; func: TGDataForeachFunc; user_data: gpointer); cdecl; external;
procedure g_datalist_id_set_data_full(datalist: PPGData; key_id: TGQuark; data: gpointer; destroy_func: TGDestroyNotify); cdecl; external;
procedure g_datalist_init(datalist: PPGData); cdecl; external;
procedure g_datalist_set_flags(datalist: PPGData; flags: guint); cdecl; external;
procedure g_datalist_unset_flags(datalist: PPGData; flags: guint); cdecl; external;
procedure g_dataset_destroy(dataset_location: Pgpointer); cdecl; external;
procedure g_dataset_foreach(dataset_location: Pgpointer; func: TGDataForeachFunc; user_data: gpointer); cdecl; external;
procedure g_dataset_id_set_data_full(dataset_location: Pgpointer; key_id: TGQuark; data: gpointer; destroy_func: TGDestroyNotify); cdecl; external;
procedure g_date_add_days(date: PGDate; n_days: guint); cdecl; external;
procedure g_date_add_months(date: PGDate; n_months: guint); cdecl; external;
procedure g_date_add_years(date: PGDate; n_years: guint); cdecl; external;
procedure g_date_clamp(date: PGDate; min_date: PGDate; max_date: PGDate); cdecl; external;
procedure g_date_clear(date: PGDate; n_dates: guint); cdecl; external;
procedure g_date_free(date: PGDate); cdecl; external;
procedure g_date_order(date1: PGDate; date2: PGDate); cdecl; external;
procedure g_date_set_day(date: PGDate; day: TGDateDay); cdecl; external;
procedure g_date_set_dmy(date: PGDate; day: TGDateDay; month: TGDateMonth; y: TGDateYear); cdecl; external;
procedure g_date_set_julian(date: PGDate; julian_date: guint32); cdecl; external;
procedure g_date_set_month(date: PGDate; month: TGDateMonth); cdecl; external;
procedure g_date_set_parse(date: PGDate; str: Pgchar); cdecl; external;
procedure g_date_set_time_t(date: PGDate; timet: glong); cdecl; external;
procedure g_date_set_time_val(date: PGDate; timeval: PGTimeVal); cdecl; external;
procedure g_date_set_year(date: PGDate; year: TGDateYear); cdecl; external;
procedure g_date_subtract_days(date: PGDate; n_days: guint); cdecl; external;
procedure g_date_subtract_months(date: PGDate; n_months: guint); cdecl; external;
procedure g_date_subtract_years(date: PGDate; n_years: guint); cdecl; external;
procedure g_date_time_get_ymd(datetime: PGDateTime; year: Pgint; month: Pgint; day: Pgint); cdecl; external;
procedure g_date_time_unref(datetime: PGDateTime); cdecl; external;
procedure g_date_to_struct_tm(date: PGDate; tm: Pgpointer); cdecl; external;
procedure g_dir_close(dir: PGDir); cdecl; external;
procedure g_dir_rewind(dir: PGDir); cdecl; external;
procedure g_error_free(error: PGError); cdecl; external;
procedure g_free(mem: gpointer); cdecl; external;
procedure g_get_current_time(result_: PGTimeVal); cdecl; external;
procedure g_hash_table_add(hash_table: PGHashTable; key: gpointer); cdecl; external;
procedure g_hash_table_destroy(hash_table: PGHashTable); cdecl; external;
procedure g_hash_table_foreach(hash_table: PGHashTable; func: TGHFunc; user_data: gpointer); cdecl; external;
procedure g_hash_table_insert(hash_table: PGHashTable; key: gpointer; value: gpointer); cdecl; external;
procedure g_hash_table_iter_init(iter: PGHashTableIter; hash_table: PGHashTable); cdecl; external;
procedure g_hash_table_iter_remove(iter: PGHashTableIter); cdecl; external;
procedure g_hash_table_iter_replace(iter: PGHashTableIter; value: gpointer); cdecl; external;
procedure g_hash_table_iter_steal(iter: PGHashTableIter); cdecl; external;
procedure g_hash_table_remove_all(hash_table: PGHashTable); cdecl; external;
procedure g_hash_table_replace(hash_table: PGHashTable; key: gpointer; value: gpointer); cdecl; external;
procedure g_hash_table_steal_all(hash_table: PGHashTable); cdecl; external;
procedure g_hash_table_unref(hash_table: PGHashTable); cdecl; external;
procedure g_hmac_get_digest(hmac: PGHmac; buffer: Pguint8; digest_len: Pgsize); cdecl; external;
procedure g_hmac_unref(hmac: PGHmac); cdecl; external;
procedure g_hmac_update(hmac: PGHmac; data: Pguint8; length: gssize); cdecl; external;
procedure g_hook_destroy_link(hook_list: PGHookList; hook: PGHook); cdecl; external;
procedure g_hook_free(hook_list: PGHookList; hook: PGHook); cdecl; external;
procedure g_hook_insert_before(hook_list: PGHookList; sibling: PGHook; hook: PGHook); cdecl; external;
procedure g_hook_insert_sorted(hook_list: PGHookList; hook: PGHook; func: TGHookCompareFunc); cdecl; external;
procedure g_hook_list_clear(hook_list: PGHookList); cdecl; external;
procedure g_hook_list_init(hook_list: PGHookList; hook_size: guint); cdecl; external;
procedure g_hook_list_invoke(hook_list: PGHookList; may_recurse: gboolean); cdecl; external;
procedure g_hook_list_invoke_check(hook_list: PGHookList; may_recurse: gboolean); cdecl; external;
procedure g_hook_list_marshal(hook_list: PGHookList; may_recurse: gboolean; marshaller: TGHookMarshaller; marshal_data: gpointer); cdecl; external;
procedure g_hook_list_marshal_check(hook_list: PGHookList; may_recurse: gboolean; marshaller: TGHookCheckMarshaller; marshal_data: gpointer); cdecl; external;
procedure g_hook_prepend(hook_list: PGHookList; hook: PGHook); cdecl; external;
procedure g_hook_unref(hook_list: PGHookList; hook: PGHook); cdecl; external;
procedure g_io_channel_init(channel: PGIOChannel); cdecl; external;
procedure g_io_channel_set_buffer_size(channel: PGIOChannel; size: gsize); cdecl; external;
procedure g_io_channel_set_buffered(channel: PGIOChannel; buffered: gboolean); cdecl; external;
procedure g_io_channel_set_close_on_unref(channel: PGIOChannel; do_close: gboolean); cdecl; external;
procedure g_io_channel_set_line_term(channel: PGIOChannel; line_term: Pgchar; length: gint); cdecl; external;
procedure g_io_channel_unref(channel: PGIOChannel); cdecl; external;
procedure g_key_file_free(key_file: PGKeyFile); cdecl; external;
procedure g_key_file_set_boolean(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; value: gboolean); cdecl; external;
procedure g_key_file_set_boolean_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; list: gboolean; length: gsize); cdecl; external;
procedure g_key_file_set_double(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; value: gdouble); cdecl; external;
procedure g_key_file_set_double_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; list: gdouble; length: gsize); cdecl; external;
procedure g_key_file_set_int64(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; value: gint64); cdecl; external;
procedure g_key_file_set_integer(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; value: gint); cdecl; external;
procedure g_key_file_set_integer_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; list: gint; length: gsize); cdecl; external;
procedure g_key_file_set_list_separator(key_file: PGKeyFile; separator: gchar); cdecl; external;
procedure g_key_file_set_locale_string(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; locale: Pgchar; string_: Pgchar); cdecl; external;
procedure g_key_file_set_locale_string_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; locale: Pgchar; list: Pgchar; length: gsize); cdecl; external;
procedure g_key_file_set_string(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; string_: Pgchar); cdecl; external;
procedure g_key_file_set_string_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; list: Pgchar; length: gsize); cdecl; external;
procedure g_key_file_set_uint64(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; value: guint64); cdecl; external;
procedure g_key_file_set_value(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; value: Pgchar); cdecl; external;
procedure g_key_file_unref(key_file: PGKeyFile); cdecl; external;
procedure g_list_foreach(list: PGList; func: TGFunc; user_data: gpointer); cdecl; external;
procedure g_list_free(list: PGList); cdecl; external;
procedure g_list_free_1(list: PGList); cdecl; external;
procedure g_list_free_full(list: PGList; free_func: TGDestroyNotify); cdecl; external;
procedure g_log(log_domain: Pgchar; log_level: TGLogLevelFlags; format: Pgchar; args: array of const); cdecl; external;
procedure g_log_default_handler(log_domain: Pgchar; log_level: TGLogLevelFlags; message: Pgchar; unused_data: gpointer); cdecl; external;
procedure g_log_remove_handler(log_domain: Pgchar; handler_id: guint); cdecl; external;
procedure g_logv(log_domain: Pgchar; log_level: TGLogLevelFlags; format: Pgchar; args: Tva_list); cdecl; external;
procedure g_main_context_add_poll(context: PGMainContext; fd: PGPollFD; priority: gint); cdecl; external;
procedure g_main_context_dispatch(context: PGMainContext); cdecl; external;
procedure g_main_context_invoke(context: PGMainContext; function_: TGSourceFunc; data: gpointer); cdecl; external;
procedure g_main_context_invoke_full(context: PGMainContext; priority: gint; function_: TGSourceFunc; data: gpointer; notify: TGDestroyNotify); cdecl; external;
procedure g_main_context_pop_thread_default(context: PGMainContext); cdecl; external;
procedure g_main_context_push_thread_default(context: PGMainContext); cdecl; external;
procedure g_main_context_release(context: PGMainContext); cdecl; external;
procedure g_main_context_remove_poll(context: PGMainContext; fd: PGPollFD); cdecl; external;
procedure g_main_context_set_poll_func(context: PGMainContext; func: TGPollFunc); cdecl; external;
procedure g_main_context_unref(context: PGMainContext); cdecl; external;
procedure g_main_context_wakeup(context: PGMainContext); cdecl; external;
procedure g_main_loop_quit(loop: PGMainLoop); cdecl; external;
procedure g_main_loop_run(loop: PGMainLoop); cdecl; external;
procedure g_main_loop_unref(loop: PGMainLoop); cdecl; external;
procedure g_mapped_file_unref(file_: PGMappedFile); cdecl; external;
procedure g_markup_parse_context_free(context: PGMarkupParseContext); cdecl; external;
procedure g_markup_parse_context_get_position(context: PGMarkupParseContext; line_number: Pgint; char_number: Pgint); cdecl; external;
procedure g_markup_parse_context_push(context: PGMarkupParseContext; parser: PGMarkupParser; user_data: gpointer); cdecl; external;
procedure g_markup_parse_context_unref(context: PGMarkupParseContext); cdecl; external;
procedure g_match_info_free(match_info: PGMatchInfo); cdecl; external;
procedure g_match_info_unref(match_info: PGMatchInfo); cdecl; external;
procedure g_mem_profile; cdecl; external;
procedure g_mem_set_vtable(vtable: PGMemVTable); cdecl; external;
procedure g_mutex_clear(mutex: PGMutex); cdecl; external;
procedure g_mutex_init(mutex: PGMutex); cdecl; external;
procedure g_mutex_lock(mutex: PGMutex); cdecl; external;
procedure g_mutex_unlock(mutex: PGMutex); cdecl; external;
procedure g_node_children_foreach(node: PGNode; flags: TGTraverseFlags; func: TGNodeForeachFunc; data: gpointer); cdecl; external;
procedure g_node_destroy(root: PGNode); cdecl; external;
procedure g_node_reverse_children(node: PGNode); cdecl; external;
procedure g_node_traverse(root: PGNode; order: TGTraverseType; flags: TGTraverseFlags; max_depth: gint; func: TGNodeTraverseFunc; data: gpointer); cdecl; external;
procedure g_node_unlink(node: PGNode); cdecl; external;
procedure g_nullify_pointer(nullify_location: Pgpointer); cdecl; external;
procedure g_on_error_query(prg_name: Pgchar); cdecl; external;
procedure g_on_error_stack_trace(prg_name: Pgchar); cdecl; external;
procedure g_once_init_leave(location: Pgpointer; result_: gsize); cdecl; external;
procedure g_option_context_add_group(context: PGOptionContext; group: PGOptionGroup); cdecl; external;
procedure g_option_context_add_main_entries(context: PGOptionContext; entries: PGOptionEntry; translation_domain: Pgchar); cdecl; external;
procedure g_option_context_free(context: PGOptionContext); cdecl; external;
procedure g_option_context_set_description(context: PGOptionContext; description: Pgchar); cdecl; external;
procedure g_option_context_set_help_enabled(context: PGOptionContext; help_enabled: gboolean); cdecl; external;
procedure g_option_context_set_ignore_unknown_options(context: PGOptionContext; ignore_unknown: gboolean); cdecl; external;
procedure g_option_context_set_main_group(context: PGOptionContext; group: PGOptionGroup); cdecl; external;
procedure g_option_context_set_summary(context: PGOptionContext; summary: Pgchar); cdecl; external;
procedure g_option_context_set_translate_func(context: PGOptionContext; func: TGTranslateFunc; data: gpointer; destroy_notify: TGDestroyNotify); cdecl; external;
procedure g_option_context_set_translation_domain(context: PGOptionContext; domain: Pgchar); cdecl; external;
procedure g_option_group_add_entries(group: PGOptionGroup; entries: PGOptionEntry); cdecl; external;
procedure g_option_group_free(group: PGOptionGroup); cdecl; external;
procedure g_option_group_set_error_hook(group: PGOptionGroup; error_func: TGOptionErrorFunc); cdecl; external;
procedure g_option_group_set_parse_hooks(group: PGOptionGroup; pre_parse_func: TGOptionParseFunc; post_parse_func: TGOptionParseFunc); cdecl; external;
procedure g_option_group_set_translate_func(group: PGOptionGroup; func: TGTranslateFunc; data: gpointer; destroy_notify: TGDestroyNotify); cdecl; external;
procedure g_option_group_set_translation_domain(group: PGOptionGroup; domain: Pgchar); cdecl; external;
procedure g_pattern_spec_free(pspec: PGPatternSpec); cdecl; external;
procedure g_pointer_bit_lock(address: Pgpointer; lock_bit: gint); cdecl; external;
procedure g_pointer_bit_unlock(address: Pgpointer; lock_bit: gint); cdecl; external;
procedure g_prefix_error(err: PPGError; format: Pgchar; args: array of const); cdecl; external;
procedure g_print(format: Pgchar; args: array of const); cdecl; external;
procedure g_printerr(format: Pgchar; args: array of const); cdecl; external;
procedure g_private_replace(key: PGPrivate; value: gpointer); cdecl; external;
procedure g_private_set(key: PGPrivate; value: gpointer); cdecl; external;
procedure g_propagate_error(dest: PPGError; src: PGError); cdecl; external;
procedure g_propagate_prefixed_error(dest: PPGError; src: PGError; format: Pgchar; args: array of const); cdecl; external;
procedure g_ptr_array_add(array_: Pgpointer; data: gpointer); cdecl; external;
procedure g_ptr_array_foreach(array_: Pgpointer; func: TGFunc; user_data: gpointer); cdecl; external;
procedure g_ptr_array_remove_range(array_: Pgpointer; index_: guint; length: guint); cdecl; external;
procedure g_ptr_array_set_free_func(array_: Pgpointer; element_free_func: TGDestroyNotify); cdecl; external;
procedure g_ptr_array_set_size(array_: Pgpointer; length: gint); cdecl; external;
procedure g_ptr_array_sort(array_: Pgpointer; compare_func: TGCompareFunc); cdecl; external;
procedure g_ptr_array_sort_with_data(array_: Pgpointer; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_ptr_array_unref(array_: Pgpointer); cdecl; external;
procedure g_qsort_with_data(pbase: Pgpointer; total_elems: gint; size: gsize; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_queue_clear(queue: PGQueue); cdecl; external;
procedure g_queue_delete_link(queue: PGQueue; link_: PGList); cdecl; external;
procedure g_queue_foreach(queue: PGQueue; func: TGFunc; user_data: gpointer); cdecl; external;
procedure g_queue_free(queue: PGQueue); cdecl; external;
procedure g_queue_free_full(queue: PGQueue; free_func: TGDestroyNotify); cdecl; external;
procedure g_queue_init(queue: PGQueue); cdecl; external;
procedure g_queue_insert_after(queue: PGQueue; sibling: PGList; data: gpointer); cdecl; external;
procedure g_queue_insert_before(queue: PGQueue; sibling: PGList; data: gpointer); cdecl; external;
procedure g_queue_insert_sorted(queue: PGQueue; data: gpointer; func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_queue_push_head(queue: PGQueue; data: gpointer); cdecl; external;
procedure g_queue_push_head_link(queue: PGQueue; link_: PGList); cdecl; external;
procedure g_queue_push_nth(queue: PGQueue; data: gpointer; n: gint); cdecl; external;
procedure g_queue_push_nth_link(queue: PGQueue; n: gint; link_: PGList); cdecl; external;
procedure g_queue_push_tail(queue: PGQueue; data: gpointer); cdecl; external;
procedure g_queue_push_tail_link(queue: PGQueue; link_: PGList); cdecl; external;
procedure g_queue_reverse(queue: PGQueue); cdecl; external;
procedure g_queue_sort(queue: PGQueue; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_queue_unlink(queue: PGQueue; link_: PGList); cdecl; external;
procedure g_rand_free(rand_: PGRand); cdecl; external;
procedure g_rand_set_seed(rand_: PGRand; seed: guint32); cdecl; external;
procedure g_rand_set_seed_array(rand_: PGRand; seed: Pguint32; seed_length: guint); cdecl; external;
procedure g_random_set_seed(seed: guint32); cdecl; external;
procedure g_rec_mutex_clear(rec_mutex: PGRecMutex); cdecl; external;
procedure g_rec_mutex_init(rec_mutex: PGRecMutex); cdecl; external;
procedure g_rec_mutex_lock(rec_mutex: PGRecMutex); cdecl; external;
procedure g_rec_mutex_unlock(rec_mutex: PGRecMutex); cdecl; external;
procedure g_regex_unref(regex: PGRegex); cdecl; external;
procedure g_reload_user_special_dirs_cache; cdecl; external;
procedure g_return_if_fail_warning(log_domain: Pgchar; pretty_function: Pgchar; expression: Pgchar); cdecl; external;
procedure g_rw_lock_clear(rw_lock: PGRWLock); cdecl; external;
procedure g_rw_lock_init(rw_lock: PGRWLock); cdecl; external;
procedure g_rw_lock_reader_lock(rw_lock: PGRWLock); cdecl; external;
procedure g_rw_lock_reader_unlock(rw_lock: PGRWLock); cdecl; external;
procedure g_rw_lock_writer_lock(rw_lock: PGRWLock); cdecl; external;
procedure g_rw_lock_writer_unlock(rw_lock: PGRWLock); cdecl; external;
procedure g_scanner_destroy(scanner: PGScanner); cdecl; external;
procedure g_scanner_error(scanner: PGScanner; format: Pgchar; args: array of const); cdecl; external;
procedure g_scanner_input_file(scanner: PGScanner; input_fd: gint); cdecl; external;
procedure g_scanner_input_text(scanner: PGScanner; text: Pgchar; text_len: guint); cdecl; external;
procedure g_scanner_scope_add_symbol(scanner: PGScanner; scope_id: guint; symbol: Pgchar; value: gpointer); cdecl; external;
procedure g_scanner_scope_foreach_symbol(scanner: PGScanner; scope_id: guint; func: TGHFunc; user_data: gpointer); cdecl; external;
procedure g_scanner_scope_remove_symbol(scanner: PGScanner; scope_id: guint; symbol: Pgchar); cdecl; external;
procedure g_scanner_sync_file_offset(scanner: PGScanner); cdecl; external;
procedure g_scanner_unexp_token(scanner: PGScanner; expected_token: TGTokenType; identifier_spec: Pgchar; symbol_spec: Pgchar; symbol_name: Pgchar; message: Pgchar; is_error: gint); cdecl; external;
procedure g_scanner_warn(scanner: PGScanner; format: Pgchar; args: array of const); cdecl; external;
procedure g_sequence_foreach(seq: PGSequence; func: TGFunc; user_data: gpointer); cdecl; external;
procedure g_sequence_foreach_range(begin_: PGSequenceIter; end_: PGSequenceIter; func: TGFunc; user_data: gpointer); cdecl; external;
procedure g_sequence_free(seq: PGSequence); cdecl; external;
procedure g_sequence_move(src: PGSequenceIter; dest: PGSequenceIter); cdecl; external;
procedure g_sequence_move_range(dest: PGSequenceIter; begin_: PGSequenceIter; end_: PGSequenceIter); cdecl; external;
procedure g_sequence_remove(iter: PGSequenceIter); cdecl; external;
procedure g_sequence_remove_range(begin_: PGSequenceIter; end_: PGSequenceIter); cdecl; external;
procedure g_sequence_set(iter: PGSequenceIter; data: gpointer); cdecl; external;
procedure g_sequence_sort(seq: PGSequence; cmp_func: TGCompareDataFunc; cmp_data: gpointer); cdecl; external;
procedure g_sequence_sort_changed(iter: PGSequenceIter; cmp_func: TGCompareDataFunc; cmp_data: gpointer); cdecl; external;
procedure g_sequence_sort_changed_iter(iter: PGSequenceIter; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer); cdecl; external;
procedure g_sequence_sort_iter(seq: PGSequence; cmp_func: TGSequenceIterCompareFunc; cmp_data: gpointer); cdecl; external;
procedure g_sequence_swap(a: PGSequenceIter; b: PGSequenceIter); cdecl; external;
procedure g_set_application_name(application_name: Pgchar); cdecl; external;
procedure g_set_error(err: PPGError; domain: TGQuark; code: gint; format: Pgchar; args: array of const); cdecl; external;
procedure g_set_error_literal(err: PPGError; domain: TGQuark; code: gint; message: Pgchar); cdecl; external;
procedure g_set_prgname(prgname: Pgchar); cdecl; external;
procedure g_slice_free1(block_size: gsize; mem_block: gpointer); cdecl; external;
procedure g_slice_free_chain_with_offset(block_size: gsize; mem_chain: gpointer; next_offset: gsize); cdecl; external;
procedure g_slice_set_config(ckey: TGSliceConfig; value: gint64); cdecl; external;
procedure g_slist_foreach(list: PGSList; func: TGFunc; user_data: gpointer); cdecl; external;
procedure g_slist_free(list: PGSList); cdecl; external;
procedure g_slist_free_1(list: PGSList); cdecl; external;
procedure g_slist_free_full(list: PGSList; free_func: TGDestroyNotify); cdecl; external;
procedure g_source_add_child_source(source: PGSource; child_source: PGSource); cdecl; external;
procedure g_source_add_poll(source: PGSource; fd: PGPollFD); cdecl; external;
procedure g_source_destroy(source: PGSource); cdecl; external;
procedure g_source_modify_unix_fd(source: PGSource; tag: gpointer; new_events: TGIOCondition); cdecl; external;
procedure g_source_remove_child_source(source: PGSource; child_source: PGSource); cdecl; external;
procedure g_source_remove_poll(source: PGSource; fd: PGPollFD); cdecl; external;
procedure g_source_remove_unix_fd(source: PGSource; tag: gpointer); cdecl; external;
procedure g_source_set_callback(source: PGSource; func: TGSourceFunc; data: gpointer; notify: TGDestroyNotify); cdecl; external;
procedure g_source_set_callback_indirect(source: PGSource; callback_data: gpointer; callback_funcs: PGSourceCallbackFuncs); cdecl; external;
procedure g_source_set_can_recurse(source: PGSource; can_recurse: gboolean); cdecl; external;
procedure g_source_set_funcs(source: PGSource; funcs: PGSourceFuncs); cdecl; external;
procedure g_source_set_name(source: PGSource; name: Pgchar); cdecl; external;
procedure g_source_set_name_by_id(tag: guint; name: Pgchar); cdecl; external;
procedure g_source_set_priority(source: PGSource; priority: gint); cdecl; external;
procedure g_source_set_ready_time(source: PGSource; ready_time: gint64); cdecl; external;
procedure g_source_unref(source: PGSource); cdecl; external;
procedure g_spawn_close_pid(pid: TGPid); cdecl; external;
procedure g_strfreev(str_array: PPgchar); cdecl; external;
procedure g_string_append_printf(string_: PGString; format: Pgchar; args: array of const); cdecl; external;
procedure g_string_append_vprintf(string_: PGString; format: Pgchar; args: Tva_list); cdecl; external;
procedure g_string_chunk_clear(chunk: PGStringChunk); cdecl; external;
procedure g_string_chunk_free(chunk: PGStringChunk); cdecl; external;
procedure g_string_printf(string_: PGString; format: Pgchar; args: array of const); cdecl; external;
procedure g_string_vprintf(string_: PGString; format: Pgchar; args: Tva_list); cdecl; external;
procedure g_test_add_data_func(testpath: Pgchar; test_data: Pgpointer; test_func: TGTestDataFunc); cdecl; external;
procedure g_test_add_data_func_full(testpath: Pgchar; test_data: gpointer; test_func: TGTestDataFunc; data_free_func: TGDestroyNotify); cdecl; external;
procedure g_test_add_func(testpath: Pgchar; test_func: TGTestFunc); cdecl; external;
procedure g_test_add_vtable(testpath: Pgchar; data_size: gsize; test_data: Pgpointer; data_setup: TGTestFixtureFunc; data_test: TGTestFixtureFunc; data_teardown: TGTestFixtureFunc); cdecl; external;
procedure g_test_assert_expected_messages_internal(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar); cdecl; external;
procedure g_test_bug(bug_uri_snippet: Pgchar); cdecl; external;
procedure g_test_bug_base(uri_pattern: Pgchar); cdecl; external;
procedure g_test_expect_message(log_domain: Pgchar; log_level: TGLogLevelFlags; pattern: Pgchar); cdecl; external;
procedure g_test_fail; cdecl; external;
procedure g_test_init(argc: Pgint; argv: PPPgchar; args: array of const); cdecl; external;
procedure g_test_log_buffer_free(tbuffer: PGTestLogBuffer); cdecl; external;
procedure g_test_log_buffer_push(tbuffer: PGTestLogBuffer; n_bytes: guint; bytes: Pguint8); cdecl; external;
procedure g_test_log_msg_free(tmsg: PGTestLogMsg); cdecl; external;
procedure g_test_log_set_fatal_handler(log_func: TGTestLogFatalFunc; user_data: gpointer); cdecl; external;
procedure g_test_maximized_result(maximized_quantity: gdouble; format: Pgchar; args: array of const); cdecl; external;
procedure g_test_message(format: Pgchar; args: array of const); cdecl; external;
procedure g_test_minimized_result(minimized_quantity: gdouble; format: Pgchar; args: array of const); cdecl; external;
procedure g_test_queue_destroy(destroy_func: TGDestroyNotify; destroy_data: gpointer); cdecl; external;
procedure g_test_queue_free(gfree_pointer: gpointer); cdecl; external;
procedure g_test_suite_add(suite: PGTestSuite; test_case: PGTestCase); cdecl; external;
procedure g_test_suite_add_suite(suite: PGTestSuite; nestedsuite: PGTestSuite); cdecl; external;
procedure g_test_timer_start; cdecl; external;
procedure g_test_trap_assertions(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; assertion_flags: guint64; pattern: Pgchar); cdecl; external;
procedure g_thread_exit(retval: gpointer); cdecl; external;
procedure g_thread_pool_free(pool: PGThreadPool; immediate: gboolean; wait_: gboolean); cdecl; external;
procedure g_thread_pool_set_max_idle_time(interval: guint); cdecl; external;
procedure g_thread_pool_set_max_unused_threads(max_threads: gint); cdecl; external;
procedure g_thread_pool_set_sort_function(pool: PGThreadPool; func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_thread_pool_stop_unused_threads; cdecl; external;
procedure g_thread_unref(thread: PGThread); cdecl; external;
procedure g_thread_yield; cdecl; external;
procedure g_time_val_add(time_: PGTimeVal; microseconds: glong); cdecl; external;
procedure g_time_zone_unref(tz: PGTimeZone); cdecl; external;
procedure g_timer_continue(timer: PGTimer); cdecl; external;
procedure g_timer_destroy(timer: PGTimer); cdecl; external;
procedure g_timer_reset(timer: PGTimer); cdecl; external;
procedure g_timer_start(timer: PGTimer); cdecl; external;
procedure g_timer_stop(timer: PGTimer); cdecl; external;
procedure g_trash_stack_push(stack_p: PPGTrashStack; data_p: gpointer); cdecl; external;
procedure g_tree_destroy(tree: PGTree); cdecl; external;
procedure g_tree_foreach(tree: PGTree; func: TGTraverseFunc; user_data: gpointer); cdecl; external;
procedure g_tree_insert(tree: PGTree; key: gpointer; value: gpointer); cdecl; external;
procedure g_tree_replace(tree: PGTree; key: gpointer; value: gpointer); cdecl; external;
procedure g_tree_unref(tree: PGTree); cdecl; external;
procedure g_unicode_canonical_ordering(string_: Pgunichar; len: gsize); cdecl; external;
procedure g_unsetenv(variable: Pgchar); cdecl; external;
procedure g_usleep(microseconds: gulong); cdecl; external;
procedure g_variant_builder_add(builder: PGVariantBuilder; format_string: Pgchar; args: array of const); cdecl; external;
procedure g_variant_builder_add_parsed(builder: PGVariantBuilder; format: Pgchar; args: array of const); cdecl; external;
procedure g_variant_builder_add_value(builder: PGVariantBuilder; value: PGVariant); cdecl; external;
procedure g_variant_builder_clear(builder: PGVariantBuilder); cdecl; external;
procedure g_variant_builder_close(builder: PGVariantBuilder); cdecl; external;
procedure g_variant_builder_init(builder: PGVariantBuilder; type_: PGVariantType); cdecl; external;
procedure g_variant_builder_open(builder: PGVariantBuilder; type_: PGVariantType); cdecl; external;
procedure g_variant_builder_unref(builder: PGVariantBuilder); cdecl; external;
procedure g_variant_get(value: PGVariant; format_string: Pgchar; args: array of const); cdecl; external;
procedure g_variant_get_child(value: PGVariant; index_: gsize; format_string: Pgchar; args: array of const); cdecl; external;
procedure g_variant_get_va(value: PGVariant; format_string: Pgchar; endptr: PPgchar; app: Pva_list); cdecl; external;
procedure g_variant_iter_free(iter: PGVariantIter); cdecl; external;
procedure g_variant_store(value: PGVariant; data: gpointer); cdecl; external;
procedure g_variant_type_free(type_: PGVariantType); cdecl; external;
procedure g_variant_unref(value: PGVariant); cdecl; external;
procedure g_warn_message(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; warnexpr: Pgchar); cdecl; external;
implementation
function TGArray.append_vals(array_: Pgpointer; data: Pgpointer; len: guint): Pgpointer; cdecl;
begin
  Result := GLib2.g_array_append_vals(array_, data, len);
end;

function TGArray.free(array_: Pgpointer; free_segment: gboolean): Pgchar; cdecl;
begin
  Result := GLib2.g_array_free(array_, free_segment);
end;

function TGArray.get_element_size(array_: Pgpointer): guint; cdecl;
begin
  Result := GLib2.g_array_get_element_size(array_);
end;

function TGArray.insert_vals(array_: Pgpointer; index_: guint; data: Pgpointer; len: guint): Pgpointer; cdecl;
begin
  Result := GLib2.g_array_insert_vals(array_, index_, data, len);
end;

function TGArray.new(zero_terminated: gboolean; clear_: gboolean; element_size: guint): Pgpointer; cdecl;
begin
  Result := GLib2.g_array_new(zero_terminated, clear_, element_size);
end;

function TGArray.prepend_vals(array_: Pgpointer; data: Pgpointer; len: guint): Pgpointer; cdecl;
begin
  Result := GLib2.g_array_prepend_vals(array_, data, len);
end;

function TGArray.ref(array_: Pgpointer): Pgpointer; cdecl;
begin
  Result := GLib2.g_array_ref(array_);
end;

function TGArray.remove_index(array_: Pgpointer; index_: guint): Pgpointer; cdecl;
begin
  Result := GLib2.g_array_remove_index(array_, index_);
end;

function TGArray.remove_index_fast(array_: Pgpointer; index_: guint): Pgpointer; cdecl;
begin
  Result := GLib2.g_array_remove_index_fast(array_, index_);
end;

function TGArray.remove_range(array_: Pgpointer; index_: guint; length: guint): Pgpointer; cdecl;
begin
  Result := GLib2.g_array_remove_range(array_, index_, length);
end;

procedure TGArray.set_clear_func(array_: Pgpointer; clear_func: TGDestroyNotify); cdecl;
begin
  GLib2.g_array_set_clear_func(array_, clear_func);
end;

function TGArray.set_size(array_: Pgpointer; length: guint): Pgpointer; cdecl;
begin
  Result := GLib2.g_array_set_size(array_, length);
end;

function TGArray.sized_new(zero_terminated: gboolean; clear_: gboolean; element_size: guint; reserved_size: guint): Pgpointer; cdecl;
begin
  Result := GLib2.g_array_sized_new(zero_terminated, clear_, element_size, reserved_size);
end;

procedure TGArray.sort(array_: Pgpointer; compare_func: TGCompareFunc); cdecl;
begin
  GLib2.g_array_sort(array_, compare_func);
end;

procedure TGArray.sort_with_data(array_: Pgpointer; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_array_sort_with_data(array_, compare_func, user_data);
end;

procedure TGArray.unref(array_: Pgpointer); cdecl;
begin
  GLib2.g_array_unref(array_);
end;

function TGAsyncQueue.length: gint; cdecl;
begin
  Result := GLib2.g_async_queue_length(@self);
end;

function TGAsyncQueue.length_unlocked: gint; cdecl;
begin
  Result := GLib2.g_async_queue_length_unlocked(@self);
end;

procedure TGAsyncQueue.lock; cdecl;
begin
  GLib2.g_async_queue_lock(@self);
end;

function TGAsyncQueue.pop: gpointer; cdecl;
begin
  Result := GLib2.g_async_queue_pop(@self);
end;

function TGAsyncQueue.pop_unlocked: gpointer; cdecl;
begin
  Result := GLib2.g_async_queue_pop_unlocked(@self);
end;

procedure TGAsyncQueue.push(data: gpointer); cdecl;
begin
  GLib2.g_async_queue_push(@self, data);
end;

procedure TGAsyncQueue.push_sorted(data: gpointer; func: TGCompareDataFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_async_queue_push_sorted(@self, data, func, user_data);
end;

procedure TGAsyncQueue.push_sorted_unlocked(data: gpointer; func: TGCompareDataFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_async_queue_push_sorted_unlocked(@self, data, func, user_data);
end;

procedure TGAsyncQueue.push_unlocked(data: gpointer); cdecl;
begin
  GLib2.g_async_queue_push_unlocked(@self, data);
end;

function TGAsyncQueue.ref: PGAsyncQueue; cdecl;
begin
  Result := GLib2.g_async_queue_ref(@self);
end;

procedure TGAsyncQueue.sort(func: TGCompareDataFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_async_queue_sort(@self, func, user_data);
end;

procedure TGAsyncQueue.sort_unlocked(func: TGCompareDataFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_async_queue_sort_unlocked(@self, func, user_data);
end;

function TGAsyncQueue.timeout_pop(timeout: guint64): gpointer; cdecl;
begin
  Result := GLib2.g_async_queue_timeout_pop(@self, timeout);
end;

function TGAsyncQueue.timeout_pop_unlocked(timeout: guint64): gpointer; cdecl;
begin
  Result := GLib2.g_async_queue_timeout_pop_unlocked(@self, timeout);
end;

function TGAsyncQueue.try_pop: gpointer; cdecl;
begin
  Result := GLib2.g_async_queue_try_pop(@self);
end;

function TGAsyncQueue.try_pop_unlocked: gpointer; cdecl;
begin
  Result := GLib2.g_async_queue_try_pop_unlocked(@self);
end;

procedure TGAsyncQueue.unlock; cdecl;
begin
  GLib2.g_async_queue_unlock(@self);
end;

procedure TGAsyncQueue.unref; cdecl;
begin
  GLib2.g_async_queue_unref(@self);
end;

function TGAsyncQueue.new: PGAsyncQueue; cdecl;
begin
  Result := GLib2.g_async_queue_new();
end;

function TGAsyncQueue.new_full(item_free_func: TGDestroyNotify): PGAsyncQueue; cdecl;
begin
  Result := GLib2.g_async_queue_new_full(item_free_func);
end;

procedure TGTimeVal.add(microseconds: glong); cdecl;
begin
  GLib2.g_time_val_add(@self, microseconds);
end;

function TGTimeVal.to_iso8601: Pgchar; cdecl;
begin
  Result := GLib2.g_time_val_to_iso8601(@self);
end;

function TGTimeVal.from_iso8601(iso_date: Pgchar; time_: PGTimeVal): gboolean; cdecl;
begin
  Result := GLib2.g_time_val_from_iso8601(iso_date, time_);
end;

procedure TGBookmarkFile.add_application(uri: Pgchar; name: Pgchar; exec: Pgchar); cdecl;
begin
  GLib2.g_bookmark_file_add_application(@self, uri, name, exec);
end;

procedure TGBookmarkFile.add_group(uri: Pgchar; group: Pgchar); cdecl;
begin
  GLib2.g_bookmark_file_add_group(@self, uri, group);
end;

procedure TGBookmarkFile.free; cdecl;
begin
  GLib2.g_bookmark_file_free(@self);
end;

function TGBookmarkFile.get_added(uri: Pgchar; error: PPGError): glong; cdecl;
begin
  Result := GLib2.g_bookmark_file_get_added(@self, uri, error);
end;

function TGBookmarkFile.get_app_info(uri: Pgchar; name: Pgchar; exec: PPgchar; count: Pguint; stamp: Pglong; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_get_app_info(@self, uri, name, exec, count, stamp, error);
end;

function TGBookmarkFile.get_applications(uri: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl;
begin
  Result := GLib2.g_bookmark_file_get_applications(@self, uri, length, error);
end;

function TGBookmarkFile.get_description(uri: Pgchar; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_bookmark_file_get_description(@self, uri, error);
end;

function TGBookmarkFile.get_groups(uri: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl;
begin
  Result := GLib2.g_bookmark_file_get_groups(@self, uri, length, error);
end;

function TGBookmarkFile.get_icon(uri: Pgchar; href: PPgchar; mime_type: PPgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_get_icon(@self, uri, href, mime_type, error);
end;

function TGBookmarkFile.get_is_private(uri: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_get_is_private(@self, uri, error);
end;

function TGBookmarkFile.get_mime_type(uri: Pgchar; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_bookmark_file_get_mime_type(@self, uri, error);
end;

function TGBookmarkFile.get_modified(uri: Pgchar; error: PPGError): glong; cdecl;
begin
  Result := GLib2.g_bookmark_file_get_modified(@self, uri, error);
end;

function TGBookmarkFile.get_size: gint; cdecl;
begin
  Result := GLib2.g_bookmark_file_get_size(@self);
end;

function TGBookmarkFile.get_title(uri: Pgchar; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_bookmark_file_get_title(@self, uri, error);
end;

function TGBookmarkFile.get_uris(length: Pgsize): PPgchar; cdecl;
begin
  Result := GLib2.g_bookmark_file_get_uris(@self, length);
end;

function TGBookmarkFile.get_visited(uri: Pgchar; error: PPGError): glong; cdecl;
begin
  Result := GLib2.g_bookmark_file_get_visited(@self, uri, error);
end;

function TGBookmarkFile.has_application(uri: Pgchar; name: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_has_application(@self, uri, name, error);
end;

function TGBookmarkFile.has_group(uri: Pgchar; group: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_has_group(@self, uri, group, error);
end;

function TGBookmarkFile.has_item(uri: Pgchar): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_has_item(@self, uri);
end;

function TGBookmarkFile.load_from_data(data: Pgchar; length: gsize; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_load_from_data(@self, data, length, error);
end;

function TGBookmarkFile.load_from_data_dirs(file_: Pgchar; full_path: PPgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_load_from_data_dirs(@self, file_, full_path, error);
end;

function TGBookmarkFile.load_from_file(filename: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_load_from_file(@self, filename, error);
end;

function TGBookmarkFile.move_item(old_uri: Pgchar; new_uri: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_move_item(@self, old_uri, new_uri, error);
end;

function TGBookmarkFile.remove_application(uri: Pgchar; name: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_remove_application(@self, uri, name, error);
end;

function TGBookmarkFile.remove_group(uri: Pgchar; group: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_remove_group(@self, uri, group, error);
end;

function TGBookmarkFile.remove_item(uri: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_remove_item(@self, uri, error);
end;

procedure TGBookmarkFile.set_added(uri: Pgchar; added: glong); cdecl;
begin
  GLib2.g_bookmark_file_set_added(@self, uri, added);
end;

function TGBookmarkFile.set_app_info(uri: Pgchar; name: Pgchar; exec: Pgchar; count: gint; stamp: glong; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_set_app_info(@self, uri, name, exec, count, stamp, error);
end;

procedure TGBookmarkFile.set_description(uri: Pgchar; description: Pgchar); cdecl;
begin
  GLib2.g_bookmark_file_set_description(@self, uri, description);
end;

procedure TGBookmarkFile.set_groups(uri: Pgchar; groups: PPgchar; length: gsize); cdecl;
begin
  GLib2.g_bookmark_file_set_groups(@self, uri, groups, length);
end;

procedure TGBookmarkFile.set_icon(uri: Pgchar; href: Pgchar; mime_type: Pgchar); cdecl;
begin
  GLib2.g_bookmark_file_set_icon(@self, uri, href, mime_type);
end;

procedure TGBookmarkFile.set_is_private(uri: Pgchar; is_private: gboolean); cdecl;
begin
  GLib2.g_bookmark_file_set_is_private(@self, uri, is_private);
end;

procedure TGBookmarkFile.set_mime_type(uri: Pgchar; mime_type: Pgchar); cdecl;
begin
  GLib2.g_bookmark_file_set_mime_type(@self, uri, mime_type);
end;

procedure TGBookmarkFile.set_modified(uri: Pgchar; modified: glong); cdecl;
begin
  GLib2.g_bookmark_file_set_modified(@self, uri, modified);
end;

procedure TGBookmarkFile.set_title(uri: Pgchar; title: Pgchar); cdecl;
begin
  GLib2.g_bookmark_file_set_title(@self, uri, title);
end;

procedure TGBookmarkFile.set_visited(uri: Pgchar; visited: glong); cdecl;
begin
  GLib2.g_bookmark_file_set_visited(@self, uri, visited);
end;

function TGBookmarkFile.to_data(length: Pgsize; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_bookmark_file_to_data(@self, length, error);
end;

function TGBookmarkFile.to_file(filename: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_bookmark_file_to_file(@self, filename, error);
end;

function TGBookmarkFile.error_quark: TGQuark; cdecl;
begin
  Result := GLib2.g_bookmark_file_error_quark();
end;

function TGBookmarkFile.new: PGBookmarkFile; cdecl;
begin
  Result := GLib2.g_bookmark_file_new();
end;

function TGError.new_literal(domain: TGQuark; code: gint; message: Pgchar): PGError; cdecl;
begin
  Result := GLib2.g_error_new_literal(domain, code, message);
end;

function TGError.copy: PGError; cdecl;
begin
  Result := GLib2.g_error_copy(@self);
end;

procedure TGError.free; cdecl;
begin
  GLib2.g_error_free(@self);
end;

function TGError.matches(domain: TGQuark; code: gint): gboolean; cdecl;
begin
  Result := GLib2.g_error_matches(@self, domain, code);
end;

function TGBytes.new(data: guint8; size: gsize): PGBytes; cdecl;
begin
  Result := GLib2.g_bytes_new(data, size);
end;

function TGBytes.new_static(data: guint8; size: gsize): PGBytes; cdecl;
begin
  Result := GLib2.g_bytes_new_static(data, size);
end;

function TGBytes.new_take(data: guint8; size: gsize): PGBytes; cdecl;
begin
  Result := GLib2.g_bytes_new_take(data, size);
end;

function TGBytes.new_with_free_func(data: gpointer; size: gsize; free_func: TGDestroyNotify; user_data: gpointer): PGBytes; cdecl;
begin
  Result := GLib2.g_bytes_new_with_free_func(data, size, free_func, user_data);
end;

function TGBytes.compare(bytes2: PGBytes): gint; cdecl;
begin
  Result := GLib2.g_bytes_compare(@self, bytes2);
end;

function TGBytes.equal(bytes2: PGBytes): gboolean; cdecl;
begin
  Result := GLib2.g_bytes_equal(@self, bytes2);
end;

function TGBytes.get_data(size: Pgsize): guint8; cdecl;
begin
  Result := GLib2.g_bytes_get_data(@self, size);
end;

function TGBytes.get_size: gsize; cdecl;
begin
  Result := GLib2.g_bytes_get_size(@self);
end;

function TGBytes.hash: guint; cdecl;
begin
  Result := GLib2.g_bytes_hash(@self);
end;

function TGBytes.new_from_bytes(offset: gsize; length: gsize): PGBytes; cdecl;
begin
  Result := GLib2.g_bytes_new_from_bytes(@self, offset, length);
end;

function TGBytes.ref: PGBytes; cdecl;
begin
  Result := GLib2.g_bytes_ref(@self);
end;

procedure TGBytes.unref; cdecl;
begin
  GLib2.g_bytes_unref(@self);
end;

function TGBytes.unref_to_array: Pguint8; cdecl;
begin
  Result := GLib2.g_bytes_unref_to_array(@self);
end;

function TGBytes.unref_to_data(size: Pgsize): gpointer; cdecl;
begin
  Result := GLib2.g_bytes_unref_to_data(@self, size);
end;

function TGByteArray.append(array_: Pguint8; data: Pguint8; len: guint): Pguint8; cdecl;
begin
  Result := GLib2.g_byte_array_append(array_, data, len);
end;

function TGByteArray.free(array_: Pguint8; free_segment: gboolean): Pguint8; cdecl;
begin
  Result := GLib2.g_byte_array_free(array_, free_segment);
end;

function TGByteArray.free_to_bytes(array_: Pguint8): PGBytes; cdecl;
begin
  Result := GLib2.g_byte_array_free_to_bytes(array_);
end;

function TGByteArray.new: Pguint8; cdecl;
begin
  Result := GLib2.g_byte_array_new();
end;

function TGByteArray.new_take(data: Pguint8; len: gsize): Pguint8; cdecl;
begin
  Result := GLib2.g_byte_array_new_take(data, len);
end;

function TGByteArray.prepend(array_: Pguint8; data: Pguint8; len: guint): Pguint8; cdecl;
begin
  Result := GLib2.g_byte_array_prepend(array_, data, len);
end;

function TGByteArray.ref(array_: Pguint8): Pguint8; cdecl;
begin
  Result := GLib2.g_byte_array_ref(array_);
end;

function TGByteArray.remove_index(array_: Pguint8; index_: guint): Pguint8; cdecl;
begin
  Result := GLib2.g_byte_array_remove_index(array_, index_);
end;

function TGByteArray.remove_index_fast(array_: Pguint8; index_: guint): Pguint8; cdecl;
begin
  Result := GLib2.g_byte_array_remove_index_fast(array_, index_);
end;

function TGByteArray.remove_range(array_: Pguint8; index_: guint; length: guint): Pguint8; cdecl;
begin
  Result := GLib2.g_byte_array_remove_range(array_, index_, length);
end;

function TGByteArray.set_size(array_: Pguint8; length: guint): Pguint8; cdecl;
begin
  Result := GLib2.g_byte_array_set_size(array_, length);
end;

function TGByteArray.sized_new(reserved_size: guint): Pguint8; cdecl;
begin
  Result := GLib2.g_byte_array_sized_new(reserved_size);
end;

procedure TGByteArray.sort(array_: Pguint8; compare_func: TGCompareFunc); cdecl;
begin
  GLib2.g_byte_array_sort(array_, compare_func);
end;

procedure TGByteArray.sort_with_data(array_: Pguint8; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_byte_array_sort_with_data(array_, compare_func, user_data);
end;

procedure TGByteArray.unref(array_: Pguint8); cdecl;
begin
  GLib2.g_byte_array_unref(array_);
end;

function TGChecksum.new(checksum_type: TGChecksumType): PGChecksum; cdecl;
begin
  Result := GLib2.g_checksum_new(checksum_type);
end;

function TGChecksum.copy: PGChecksum; cdecl;
begin
  Result := GLib2.g_checksum_copy(@self);
end;

procedure TGChecksum.free; cdecl;
begin
  GLib2.g_checksum_free(@self);
end;

procedure TGChecksum.get_digest(buffer: Pguint8; digest_len: Pgsize); cdecl;
begin
  GLib2.g_checksum_get_digest(@self, buffer, digest_len);
end;

function TGChecksum.get_string: Pgchar; cdecl;
begin
  Result := GLib2.g_checksum_get_string(@self);
end;

procedure TGChecksum.reset; cdecl;
begin
  GLib2.g_checksum_reset(@self);
end;

procedure TGChecksum.update(data: Pguint8; length: gssize); cdecl;
begin
  GLib2.g_checksum_update(@self, data, length);
end;

function TGChecksum.type_get_length(checksum_type: TGChecksumType): gssize; cdecl;
begin
  Result := GLib2.g_checksum_type_get_length(checksum_type);
end;

procedure TGCond.broadcast; cdecl;
begin
  GLib2.g_cond_broadcast(@self);
end;

procedure TGCond.clear; cdecl;
begin
  GLib2.g_cond_clear(@self);
end;

procedure TGCond.init; cdecl;
begin
  GLib2.g_cond_init(@self);
end;

procedure TGCond.signal; cdecl;
begin
  GLib2.g_cond_signal(@self);
end;

procedure TGCond.wait(mutex: PGMutex); cdecl;
begin
  GLib2.g_cond_wait(@self, mutex);
end;

function TGCond.wait_until(mutex: PGMutex; end_time: gint64): gboolean; cdecl;
begin
  Result := GLib2.g_cond_wait_until(@self, mutex, end_time);
end;

function TGDate.new: PGDate; cdecl;
begin
  Result := GLib2.g_date_new();
end;

function TGDate.new_dmy(day: TGDateDay; month: TGDateMonth; year: TGDateYear): PGDate; cdecl;
begin
  Result := GLib2.g_date_new_dmy(day, month, year);
end;

function TGDate.new_julian(julian_day: guint32): PGDate; cdecl;
begin
  Result := GLib2.g_date_new_julian(julian_day);
end;

procedure TGDate.add_days(n_days: guint); cdecl;
begin
  GLib2.g_date_add_days(@self, n_days);
end;

procedure TGDate.add_months(n_months: guint); cdecl;
begin
  GLib2.g_date_add_months(@self, n_months);
end;

procedure TGDate.add_years(n_years: guint); cdecl;
begin
  GLib2.g_date_add_years(@self, n_years);
end;

procedure TGDate.clamp(min_date: PGDate; max_date: PGDate); cdecl;
begin
  GLib2.g_date_clamp(@self, min_date, max_date);
end;

procedure TGDate.clear(n_dates: guint); cdecl;
begin
  GLib2.g_date_clear(@self, n_dates);
end;

function TGDate.compare(rhs: PGDate): gint; cdecl;
begin
  Result := GLib2.g_date_compare(@self, rhs);
end;

function TGDate.days_between(date2: PGDate): gint; cdecl;
begin
  Result := GLib2.g_date_days_between(@self, date2);
end;

procedure TGDate.free; cdecl;
begin
  GLib2.g_date_free(@self);
end;

function TGDate.get_day: TGDateDay; cdecl;
begin
  Result := GLib2.g_date_get_day(@self);
end;

function TGDate.get_day_of_year: guint; cdecl;
begin
  Result := GLib2.g_date_get_day_of_year(@self);
end;

function TGDate.get_iso8601_week_of_year: guint; cdecl;
begin
  Result := GLib2.g_date_get_iso8601_week_of_year(@self);
end;

function TGDate.get_julian: guint32; cdecl;
begin
  Result := GLib2.g_date_get_julian(@self);
end;

function TGDate.get_monday_week_of_year: guint; cdecl;
begin
  Result := GLib2.g_date_get_monday_week_of_year(@self);
end;

function TGDate.get_month: TGDateMonth; cdecl;
begin
  Result := GLib2.g_date_get_month(@self);
end;

function TGDate.get_sunday_week_of_year: guint; cdecl;
begin
  Result := GLib2.g_date_get_sunday_week_of_year(@self);
end;

function TGDate.get_weekday: TGDateWeekday; cdecl;
begin
  Result := GLib2.g_date_get_weekday(@self);
end;

function TGDate.get_year: TGDateYear; cdecl;
begin
  Result := GLib2.g_date_get_year(@self);
end;

function TGDate.is_first_of_month: gboolean; cdecl;
begin
  Result := GLib2.g_date_is_first_of_month(@self);
end;

function TGDate.is_last_of_month: gboolean; cdecl;
begin
  Result := GLib2.g_date_is_last_of_month(@self);
end;

procedure TGDate.order(date2: PGDate); cdecl;
begin
  GLib2.g_date_order(@self, date2);
end;

procedure TGDate.set_day(day: TGDateDay); cdecl;
begin
  GLib2.g_date_set_day(@self, day);
end;

procedure TGDate.set_dmy(day: TGDateDay; month: TGDateMonth; y: TGDateYear); cdecl;
begin
  GLib2.g_date_set_dmy(@self, day, month, y);
end;

procedure TGDate.set_julian(julian_date: guint32); cdecl;
begin
  GLib2.g_date_set_julian(@self, julian_date);
end;

procedure TGDate.set_month(month: TGDateMonth); cdecl;
begin
  GLib2.g_date_set_month(@self, month);
end;

procedure TGDate.set_parse(str: Pgchar); cdecl;
begin
  GLib2.g_date_set_parse(@self, str);
end;

procedure TGDate.set_time_t(timet: glong); cdecl;
begin
  GLib2.g_date_set_time_t(@self, timet);
end;

procedure TGDate.set_time_val(timeval: PGTimeVal); cdecl;
begin
  GLib2.g_date_set_time_val(@self, timeval);
end;

procedure TGDate.set_year(year: TGDateYear); cdecl;
begin
  GLib2.g_date_set_year(@self, year);
end;

procedure TGDate.subtract_days(n_days: guint); cdecl;
begin
  GLib2.g_date_subtract_days(@self, n_days);
end;

procedure TGDate.subtract_months(n_months: guint); cdecl;
begin
  GLib2.g_date_subtract_months(@self, n_months);
end;

procedure TGDate.subtract_years(n_years: guint); cdecl;
begin
  GLib2.g_date_subtract_years(@self, n_years);
end;

procedure TGDate.to_struct_tm(tm: Pgpointer); cdecl;
begin
  GLib2.g_date_to_struct_tm(@self, tm);
end;

function TGDate.valid: gboolean; cdecl;
begin
  Result := GLib2.g_date_valid(@self);
end;

function TGDate.get_days_in_month(month: TGDateMonth; year: TGDateYear): guint8; cdecl;
begin
  Result := GLib2.g_date_get_days_in_month(month, year);
end;

function TGDate.get_monday_weeks_in_year(year: TGDateYear): guint8; cdecl;
begin
  Result := GLib2.g_date_get_monday_weeks_in_year(year);
end;

function TGDate.get_sunday_weeks_in_year(year: TGDateYear): guint8; cdecl;
begin
  Result := GLib2.g_date_get_sunday_weeks_in_year(year);
end;

function TGDate.is_leap_year(year: TGDateYear): gboolean; cdecl;
begin
  Result := GLib2.g_date_is_leap_year(year);
end;

function TGDate.strftime(s: Pgchar; slen: gsize; format: Pgchar; date: PGDate): gsize; cdecl;
begin
  Result := GLib2.g_date_strftime(s, slen, format, date);
end;

function TGDate.valid_day(day: TGDateDay): gboolean; cdecl;
begin
  Result := GLib2.g_date_valid_day(day);
end;

function TGDate.valid_dmy(day: TGDateDay; month: TGDateMonth; year: TGDateYear): gboolean; cdecl;
begin
  Result := GLib2.g_date_valid_dmy(day, month, year);
end;

function TGDate.valid_julian(julian_date: guint32): gboolean; cdecl;
begin
  Result := GLib2.g_date_valid_julian(julian_date);
end;

function TGDate.valid_month(month: TGDateMonth): gboolean; cdecl;
begin
  Result := GLib2.g_date_valid_month(month);
end;

function TGDate.valid_weekday(weekday: TGDateWeekday): gboolean; cdecl;
begin
  Result := GLib2.g_date_valid_weekday(weekday);
end;

function TGDate.valid_year(year: TGDateYear): gboolean; cdecl;
begin
  Result := GLib2.g_date_valid_year(year);
end;

function TGDateTime.new(tz: PGTimeZone; year: gint; month: gint; day: gint; hour: gint; minute: gint; seconds: gdouble): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_new(tz, year, month, day, hour, minute, seconds);
end;

function TGDateTime.new_from_timeval_local(tv: PGTimeVal): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_new_from_timeval_local(tv);
end;

function TGDateTime.new_from_timeval_utc(tv: PGTimeVal): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_new_from_timeval_utc(tv);
end;

function TGDateTime.new_from_unix_local(t: gint64): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_new_from_unix_local(t);
end;

function TGDateTime.new_from_unix_utc(t: gint64): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_new_from_unix_utc(t);
end;

function TGDateTime.new_local(year: gint; month: gint; day: gint; hour: gint; minute: gint; seconds: gdouble): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_new_local(year, month, day, hour, minute, seconds);
end;

function TGDateTime.new_now(tz: PGTimeZone): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_new_now(tz);
end;

function TGDateTime.new_now_local: PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_new_now_local();
end;

function TGDateTime.new_now_utc: PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_new_now_utc();
end;

function TGDateTime.new_utc(year: gint; month: gint; day: gint; hour: gint; minute: gint; seconds: gdouble): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_new_utc(year, month, day, hour, minute, seconds);
end;

function TGDateTime.add(timespan: TGTimeSpan): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_add(@self, timespan);
end;

function TGDateTime.add_days(days: gint): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_add_days(@self, days);
end;

function TGDateTime.add_full(years: gint; months: gint; days: gint; hours: gint; minutes: gint; seconds: gdouble): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_add_full(@self, years, months, days, hours, minutes, seconds);
end;

function TGDateTime.add_hours(hours: gint): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_add_hours(@self, hours);
end;

function TGDateTime.add_minutes(minutes: gint): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_add_minutes(@self, minutes);
end;

function TGDateTime.add_months(months: gint): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_add_months(@self, months);
end;

function TGDateTime.add_seconds(seconds: gdouble): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_add_seconds(@self, seconds);
end;

function TGDateTime.add_weeks(weeks: gint): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_add_weeks(@self, weeks);
end;

function TGDateTime.add_years(years: gint): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_add_years(@self, years);
end;

function TGDateTime.difference(begin_: PGDateTime): TGTimeSpan; cdecl;
begin
  Result := GLib2.g_date_time_difference(@self, begin_);
end;

function TGDateTime.format(format: Pgchar): Pgchar; cdecl;
begin
  Result := GLib2.g_date_time_format(@self, format);
end;

function TGDateTime.get_day_of_month: gint; cdecl;
begin
  Result := GLib2.g_date_time_get_day_of_month(@self);
end;

function TGDateTime.get_day_of_week: gint; cdecl;
begin
  Result := GLib2.g_date_time_get_day_of_week(@self);
end;

function TGDateTime.get_day_of_year: gint; cdecl;
begin
  Result := GLib2.g_date_time_get_day_of_year(@self);
end;

function TGDateTime.get_hour: gint; cdecl;
begin
  Result := GLib2.g_date_time_get_hour(@self);
end;

function TGDateTime.get_microsecond: gint; cdecl;
begin
  Result := GLib2.g_date_time_get_microsecond(@self);
end;

function TGDateTime.get_minute: gint; cdecl;
begin
  Result := GLib2.g_date_time_get_minute(@self);
end;

function TGDateTime.get_month: gint; cdecl;
begin
  Result := GLib2.g_date_time_get_month(@self);
end;

function TGDateTime.get_second: gint; cdecl;
begin
  Result := GLib2.g_date_time_get_second(@self);
end;

function TGDateTime.get_seconds: gdouble; cdecl;
begin
  Result := GLib2.g_date_time_get_seconds(@self);
end;

function TGDateTime.get_timezone_abbreviation: Pgchar; cdecl;
begin
  Result := GLib2.g_date_time_get_timezone_abbreviation(@self);
end;

function TGDateTime.get_utc_offset: TGTimeSpan; cdecl;
begin
  Result := GLib2.g_date_time_get_utc_offset(@self);
end;

function TGDateTime.get_week_numbering_year: gint; cdecl;
begin
  Result := GLib2.g_date_time_get_week_numbering_year(@self);
end;

function TGDateTime.get_week_of_year: gint; cdecl;
begin
  Result := GLib2.g_date_time_get_week_of_year(@self);
end;

function TGDateTime.get_year: gint; cdecl;
begin
  Result := GLib2.g_date_time_get_year(@self);
end;

procedure TGDateTime.get_ymd(year: Pgint; month: Pgint; day: Pgint); cdecl;
begin
  GLib2.g_date_time_get_ymd(@self, year, month, day);
end;

function TGDateTime.is_daylight_savings: gboolean; cdecl;
begin
  Result := GLib2.g_date_time_is_daylight_savings(@self);
end;

function TGDateTime.ref: PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_ref(@self);
end;

function TGDateTime.to_local: PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_to_local(@self);
end;

function TGDateTime.to_timeval(tv: PGTimeVal): gboolean; cdecl;
begin
  Result := GLib2.g_date_time_to_timeval(@self, tv);
end;

function TGDateTime.to_timezone(tz: PGTimeZone): PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_to_timezone(@self, tz);
end;

function TGDateTime.to_unix: gint64; cdecl;
begin
  Result := GLib2.g_date_time_to_unix(@self);
end;

function TGDateTime.to_utc: PGDateTime; cdecl;
begin
  Result := GLib2.g_date_time_to_utc(@self);
end;

procedure TGDateTime.unref; cdecl;
begin
  GLib2.g_date_time_unref(@self);
end;

function TGDateTime.compare(dt1: Pgpointer; dt2: Pgpointer): gint; cdecl;
begin
  Result := GLib2.g_date_time_compare(dt1, dt2);
end;

function TGDateTime.equal(dt1: Pgpointer; dt2: Pgpointer): gboolean; cdecl;
begin
  Result := GLib2.g_date_time_equal(dt1, dt2);
end;

function TGDateTime.hash(datetime: Pgpointer): guint; cdecl;
begin
  Result := GLib2.g_date_time_hash(datetime);
end;

function TGTimeZone.new(identifier: Pgchar): PGTimeZone; cdecl;
begin
  Result := GLib2.g_time_zone_new(identifier);
end;

function TGTimeZone.new_local: PGTimeZone; cdecl;
begin
  Result := GLib2.g_time_zone_new_local();
end;

function TGTimeZone.new_utc: PGTimeZone; cdecl;
begin
  Result := GLib2.g_time_zone_new_utc();
end;

function TGTimeZone.adjust_time(type_: TGTimeType; time_: Pgint64): gint; cdecl;
begin
  Result := GLib2.g_time_zone_adjust_time(@self, type_, time_);
end;

function TGTimeZone.find_interval(type_: TGTimeType; time_: gint64): gint; cdecl;
begin
  Result := GLib2.g_time_zone_find_interval(@self, type_, time_);
end;

function TGTimeZone.get_abbreviation(interval: gint): Pgchar; cdecl;
begin
  Result := GLib2.g_time_zone_get_abbreviation(@self, interval);
end;

function TGTimeZone.get_offset(interval: gint): gint32; cdecl;
begin
  Result := GLib2.g_time_zone_get_offset(@self, interval);
end;

function TGTimeZone.is_dst(interval: gint): gboolean; cdecl;
begin
  Result := GLib2.g_time_zone_is_dst(@self, interval);
end;

function TGTimeZone.ref: PGTimeZone; cdecl;
begin
  Result := GLib2.g_time_zone_ref(@self);
end;

procedure TGTimeZone.unref; cdecl;
begin
  GLib2.g_time_zone_unref(@self);
end;

procedure TGDir.close; cdecl;
begin
  GLib2.g_dir_close(@self);
end;

function TGDir.read_name: Pgchar; cdecl;
begin
  Result := GLib2.g_dir_read_name(@self);
end;

procedure TGDir.rewind; cdecl;
begin
  GLib2.g_dir_rewind(@self);
end;

function TGDir.make_tmp(tmpl: Pgchar; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_dir_make_tmp(tmpl, error);
end;

function TGDir.open(path: Pgchar; flags: guint; error: PPGError): PGDir; cdecl;
begin
  Result := GLib2.g_dir_open(path, flags, error);
end;

procedure TGHashTable.add(hash_table: PGHashTable; key: gpointer); cdecl;
begin
  GLib2.g_hash_table_add(hash_table, key);
end;

function TGHashTable.contains(hash_table: PGHashTable; key: Pgpointer): gboolean; cdecl;
begin
  Result := GLib2.g_hash_table_contains(hash_table, key);
end;

procedure TGHashTable.destroy_(hash_table: PGHashTable); cdecl;
begin
  GLib2.g_hash_table_destroy(hash_table);
end;

function TGHashTable.find(hash_table: PGHashTable; predicate: TGHRFunc; user_data: gpointer): gpointer; cdecl;
begin
  Result := GLib2.g_hash_table_find(hash_table, predicate, user_data);
end;

procedure TGHashTable.foreach(hash_table: PGHashTable; func: TGHFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_hash_table_foreach(hash_table, func, user_data);
end;

function TGHashTable.foreach_remove(hash_table: PGHashTable; func: TGHRFunc; user_data: gpointer): guint; cdecl;
begin
  Result := GLib2.g_hash_table_foreach_remove(hash_table, func, user_data);
end;

function TGHashTable.foreach_steal(hash_table: PGHashTable; func: TGHRFunc; user_data: gpointer): guint; cdecl;
begin
  Result := GLib2.g_hash_table_foreach_steal(hash_table, func, user_data);
end;

function TGHashTable.get_keys(hash_table: PGHashTable): PGList; cdecl;
begin
  Result := GLib2.g_hash_table_get_keys(hash_table);
end;

function TGHashTable.get_values(hash_table: PGHashTable): PGList; cdecl;
begin
  Result := GLib2.g_hash_table_get_values(hash_table);
end;

procedure TGHashTable.insert(hash_table: PGHashTable; key: gpointer; value: gpointer); cdecl;
begin
  GLib2.g_hash_table_insert(hash_table, key, value);
end;

function TGHashTable.lookup(hash_table: PGHashTable; key: Pgpointer): gpointer; cdecl;
begin
  Result := GLib2.g_hash_table_lookup(hash_table, key);
end;

function TGHashTable.lookup_extended(hash_table: PGHashTable; lookup_key: Pgpointer; orig_key: Pgpointer; value: Pgpointer): gboolean; cdecl;
begin
  Result := GLib2.g_hash_table_lookup_extended(hash_table, lookup_key, orig_key, value);
end;

function TGHashTable.new(hash_func: TGHashFunc; key_equal_func: TGEqualFunc): PGHashTable; cdecl;
begin
  Result := GLib2.g_hash_table_new(hash_func, key_equal_func);
end;

function TGHashTable.new_full(hash_func: TGHashFunc; key_equal_func: TGEqualFunc; key_destroy_func: TGDestroyNotify; value_destroy_func: TGDestroyNotify): PGHashTable; cdecl;
begin
  Result := GLib2.g_hash_table_new_full(hash_func, key_equal_func, key_destroy_func, value_destroy_func);
end;

function TGHashTable.ref(hash_table: PGHashTable): PGHashTable; cdecl;
begin
  Result := GLib2.g_hash_table_ref(hash_table);
end;

function TGHashTable.remove(hash_table: PGHashTable; key: Pgpointer): gboolean; cdecl;
begin
  Result := GLib2.g_hash_table_remove(hash_table, key);
end;

procedure TGHashTable.remove_all(hash_table: PGHashTable); cdecl;
begin
  GLib2.g_hash_table_remove_all(hash_table);
end;

procedure TGHashTable.replace(hash_table: PGHashTable; key: gpointer; value: gpointer); cdecl;
begin
  GLib2.g_hash_table_replace(hash_table, key, value);
end;

function TGHashTable.size(hash_table: PGHashTable): guint; cdecl;
begin
  Result := GLib2.g_hash_table_size(hash_table);
end;

function TGHashTable.steal(hash_table: PGHashTable; key: Pgpointer): gboolean; cdecl;
begin
  Result := GLib2.g_hash_table_steal(hash_table, key);
end;

procedure TGHashTable.steal_all(hash_table: PGHashTable); cdecl;
begin
  GLib2.g_hash_table_steal_all(hash_table);
end;

procedure TGHashTable.unref(hash_table: PGHashTable); cdecl;
begin
  GLib2.g_hash_table_unref(hash_table);
end;

function TGList.alloc: PGList; cdecl;
begin
  Result := GLib2.g_list_alloc();
end;

function TGList.append(list: PGList; data: gpointer): PGList; cdecl;
begin
  Result := GLib2.g_list_append(list, data);
end;

function TGList.concat(list1: PGList; list2: PGList): PGList; cdecl;
begin
  Result := GLib2.g_list_concat(list1, list2);
end;

function TGList.copy(list: PGList): PGList; cdecl;
begin
  Result := GLib2.g_list_copy(list);
end;

function TGList.copy_deep(list: PGList; func: TGCopyFunc; user_data: gpointer): PGList; cdecl;
begin
  Result := GLib2.g_list_copy_deep(list, func, user_data);
end;

function TGList.delete_link(list: PGList; link_: PGList): PGList; cdecl;
begin
  Result := GLib2.g_list_delete_link(list, link_);
end;

function TGList.find(list: PGList; data: Pgpointer): PGList; cdecl;
begin
  Result := GLib2.g_list_find(list, data);
end;

function TGList.find_custom(list: PGList; data: Pgpointer; func: TGCompareFunc): PGList; cdecl;
begin
  Result := GLib2.g_list_find_custom(list, data, func);
end;

function TGList.first(list: PGList): PGList; cdecl;
begin
  Result := GLib2.g_list_first(list);
end;

procedure TGList.foreach(list: PGList; func: TGFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_list_foreach(list, func, user_data);
end;

procedure TGList.free(list: PGList); cdecl;
begin
  GLib2.g_list_free(list);
end;

procedure TGList.free_1(list: PGList); cdecl;
begin
  GLib2.g_list_free_1(list);
end;

procedure TGList.free_full(list: PGList; free_func: TGDestroyNotify); cdecl;
begin
  GLib2.g_list_free_full(list, free_func);
end;

function TGList.index(list: PGList; data: Pgpointer): gint; cdecl;
begin
  Result := GLib2.g_list_index(list, data);
end;

function TGList.insert(list: PGList; data: gpointer; position: gint): PGList; cdecl;
begin
  Result := GLib2.g_list_insert(list, data, position);
end;

function TGList.insert_before(list: PGList; sibling: PGList; data: gpointer): PGList; cdecl;
begin
  Result := GLib2.g_list_insert_before(list, sibling, data);
end;

function TGList.insert_sorted(list: PGList; data: gpointer; func: TGCompareFunc): PGList; cdecl;
begin
  Result := GLib2.g_list_insert_sorted(list, data, func);
end;

function TGList.insert_sorted_with_data(list: PGList; data: gpointer; func: TGCompareDataFunc; user_data: gpointer): PGList; cdecl;
begin
  Result := GLib2.g_list_insert_sorted_with_data(list, data, func, user_data);
end;

function TGList.last(list: PGList): PGList; cdecl;
begin
  Result := GLib2.g_list_last(list);
end;

function TGList.length(list: PGList): guint; cdecl;
begin
  Result := GLib2.g_list_length(list);
end;

function TGList.nth(list: PGList; n: guint): PGList; cdecl;
begin
  Result := GLib2.g_list_nth(list, n);
end;

function TGList.nth_data(list: PGList; n: guint): gpointer; cdecl;
begin
  Result := GLib2.g_list_nth_data(list, n);
end;

function TGList.nth_prev(list: PGList; n: guint): PGList; cdecl;
begin
  Result := GLib2.g_list_nth_prev(list, n);
end;

function TGList.position(list: PGList; llink: PGList): gint; cdecl;
begin
  Result := GLib2.g_list_position(list, llink);
end;

function TGList.prepend(list: PGList; data: gpointer): PGList; cdecl;
begin
  Result := GLib2.g_list_prepend(list, data);
end;

function TGList.remove(list: PGList; data: Pgpointer): PGList; cdecl;
begin
  Result := GLib2.g_list_remove(list, data);
end;

function TGList.remove_all(list: PGList; data: Pgpointer): PGList; cdecl;
begin
  Result := GLib2.g_list_remove_all(list, data);
end;

function TGList.remove_link(list: PGList; llink: PGList): PGList; cdecl;
begin
  Result := GLib2.g_list_remove_link(list, llink);
end;

function TGList.reverse(list: PGList): PGList; cdecl;
begin
  Result := GLib2.g_list_reverse(list);
end;

function TGList.sort(list: PGList; compare_func: TGCompareFunc): PGList; cdecl;
begin
  Result := GLib2.g_list_sort(list, compare_func);
end;

function TGList.sort_with_data(list: PGList; compare_func: TGCompareDataFunc; user_data: gpointer): PGList; cdecl;
begin
  Result := GLib2.g_list_sort_with_data(list, compare_func, user_data);
end;

function TGHashTableIter.get_hash_table: PGHashTable; cdecl;
begin
  Result := GLib2.g_hash_table_iter_get_hash_table(@self);
end;

procedure TGHashTableIter.init(hash_table: PGHashTable); cdecl;
begin
  GLib2.g_hash_table_iter_init(@self, hash_table);
end;

function TGHashTableIter.next(key: Pgpointer; value: Pgpointer): gboolean; cdecl;
begin
  Result := GLib2.g_hash_table_iter_next(@self, key, value);
end;

procedure TGHashTableIter.remove; cdecl;
begin
  GLib2.g_hash_table_iter_remove(@self);
end;

procedure TGHashTableIter.replace(value: gpointer); cdecl;
begin
  GLib2.g_hash_table_iter_replace(@self, value);
end;

procedure TGHashTableIter.steal; cdecl;
begin
  GLib2.g_hash_table_iter_steal(@self);
end;

function TGHmac.copy: PGHmac; cdecl;
begin
  Result := GLib2.g_hmac_copy(@self);
end;

procedure TGHmac.get_digest(buffer: Pguint8; digest_len: Pgsize); cdecl;
begin
  GLib2.g_hmac_get_digest(@self, buffer, digest_len);
end;

function TGHmac.get_string: Pgchar; cdecl;
begin
  Result := GLib2.g_hmac_get_string(@self);
end;

function TGHmac.ref: PGHmac; cdecl;
begin
  Result := GLib2.g_hmac_ref(@self);
end;

procedure TGHmac.unref; cdecl;
begin
  GLib2.g_hmac_unref(@self);
end;

procedure TGHmac.update(data: Pguint8; length: gssize); cdecl;
begin
  GLib2.g_hmac_update(@self, data, length);
end;

function TGHmac.new(digest_type: TGChecksumType; key: Pguint8; key_len: gsize): PGHmac; cdecl;
begin
  Result := GLib2.g_hmac_new(digest_type, key, key_len);
end;

function TGHook.compare_ids(sibling: PGHook): gint; cdecl;
begin
  Result := GLib2.g_hook_compare_ids(@self, sibling);
end;

function TGHook.alloc(hook_list: PGHookList): PGHook; cdecl;
begin
  Result := GLib2.g_hook_alloc(hook_list);
end;

function TGHook.destroy_(hook_list: PGHookList; hook_id: gulong): gboolean; cdecl;
begin
  Result := GLib2.g_hook_destroy(hook_list, hook_id);
end;

procedure TGHook.destroy_link(hook_list: PGHookList; hook: PGHook); cdecl;
begin
  GLib2.g_hook_destroy_link(hook_list, hook);
end;

function TGHook.find(hook_list: PGHookList; need_valids: gboolean; func: TGHookFindFunc; data: gpointer): PGHook; cdecl;
begin
  Result := GLib2.g_hook_find(hook_list, need_valids, func, data);
end;

function TGHook.find_data(hook_list: PGHookList; need_valids: gboolean; data: gpointer): PGHook; cdecl;
begin
  Result := GLib2.g_hook_find_data(hook_list, need_valids, data);
end;

function TGHook.find_func(hook_list: PGHookList; need_valids: gboolean; func: gpointer): PGHook; cdecl;
begin
  Result := GLib2.g_hook_find_func(hook_list, need_valids, func);
end;

function TGHook.find_func_data(hook_list: PGHookList; need_valids: gboolean; func: gpointer; data: gpointer): PGHook; cdecl;
begin
  Result := GLib2.g_hook_find_func_data(hook_list, need_valids, func, data);
end;

function TGHook.first_valid(hook_list: PGHookList; may_be_in_call: gboolean): PGHook; cdecl;
begin
  Result := GLib2.g_hook_first_valid(hook_list, may_be_in_call);
end;

procedure TGHook.free(hook_list: PGHookList; hook: PGHook); cdecl;
begin
  GLib2.g_hook_free(hook_list, hook);
end;

function TGHook.get(hook_list: PGHookList; hook_id: gulong): PGHook; cdecl;
begin
  Result := GLib2.g_hook_get(hook_list, hook_id);
end;

procedure TGHook.insert_before(hook_list: PGHookList; sibling: PGHook; hook: PGHook); cdecl;
begin
  GLib2.g_hook_insert_before(hook_list, sibling, hook);
end;

procedure TGHook.insert_sorted(hook_list: PGHookList; hook: PGHook; func: TGHookCompareFunc); cdecl;
begin
  GLib2.g_hook_insert_sorted(hook_list, hook, func);
end;

function TGHook.next_valid(hook_list: PGHookList; hook: PGHook; may_be_in_call: gboolean): PGHook; cdecl;
begin
  Result := GLib2.g_hook_next_valid(hook_list, hook, may_be_in_call);
end;

procedure TGHook.prepend(hook_list: PGHookList; hook: PGHook); cdecl;
begin
  GLib2.g_hook_prepend(hook_list, hook);
end;

function TGHook.ref(hook_list: PGHookList; hook: PGHook): PGHook; cdecl;
begin
  Result := GLib2.g_hook_ref(hook_list, hook);
end;

procedure TGHook.unref(hook_list: PGHookList; hook: PGHook); cdecl;
begin
  GLib2.g_hook_unref(hook_list, hook);
end;

procedure TGHookList.clear; cdecl;
begin
  GLib2.g_hook_list_clear(@self);
end;

procedure TGHookList.init(hook_size: guint); cdecl;
begin
  GLib2.g_hook_list_init(@self, hook_size);
end;

procedure TGHookList.invoke(may_recurse: gboolean); cdecl;
begin
  GLib2.g_hook_list_invoke(@self, may_recurse);
end;

procedure TGHookList.invoke_check(may_recurse: gboolean); cdecl;
begin
  GLib2.g_hook_list_invoke_check(@self, may_recurse);
end;

procedure TGHookList.marshal(may_recurse: gboolean; marshaller: TGHookMarshaller; marshal_data: gpointer); cdecl;
begin
  GLib2.g_hook_list_marshal(@self, may_recurse, marshaller, marshal_data);
end;

procedure TGHookList.marshal_check(may_recurse: gboolean; marshaller: TGHookCheckMarshaller; marshal_data: gpointer); cdecl;
begin
  GLib2.g_hook_list_marshal_check(@self, may_recurse, marshaller, marshal_data);
end;

function TGIConv.g_iconv(inbuf: PPgchar; inbytes_left: Pgsize; outbuf: PPgchar; outbytes_left: Pgsize): gsize; cdecl;
begin
  Result := GLib2.g_iconv(self, inbuf, inbytes_left, outbuf, outbytes_left);
end;

function TGIConv.close: gint; cdecl;
begin
  Result := GLib2.g_iconv_close(self);
end;

function TGIConv.open(to_codeset: Pgchar; from_codeset: Pgchar): TGIConv; cdecl;
begin
  Result := GLib2.g_iconv_open(to_codeset, from_codeset);
end;

function TGString.append(val: Pgchar): PGString; cdecl;
begin
  Result := GLib2.g_string_append(@self, val);
end;

function TGString.append_c(c: gchar): PGString; cdecl;
begin
  Result := GLib2.g_string_append_c(@self, c);
end;

function TGString.append_len(val: Pgchar; len: gssize): PGString; cdecl;
begin
  Result := GLib2.g_string_append_len(@self, val, len);
end;

function TGString.append_unichar(wc: gunichar): PGString; cdecl;
begin
  Result := GLib2.g_string_append_unichar(@self, wc);
end;

function TGString.append_uri_escaped(unescaped: Pgchar; reserved_chars_allowed: Pgchar; allow_utf8: gboolean): PGString; cdecl;
begin
  Result := GLib2.g_string_append_uri_escaped(@self, unescaped, reserved_chars_allowed, allow_utf8);
end;

function TGString.ascii_down: PGString; cdecl;
begin
  Result := GLib2.g_string_ascii_down(@self);
end;

function TGString.ascii_up: PGString; cdecl;
begin
  Result := GLib2.g_string_ascii_up(@self);
end;

function TGString.assign(rval: Pgchar): PGString; cdecl;
begin
  Result := GLib2.g_string_assign(@self, rval);
end;

function TGString.equal(v2: PGString): gboolean; cdecl;
begin
  Result := GLib2.g_string_equal(@self, v2);
end;

function TGString.erase(pos: gssize; len: gssize): PGString; cdecl;
begin
  Result := GLib2.g_string_erase(@self, pos, len);
end;

function TGString.free(free_segment: gboolean): Pgchar; cdecl;
begin
  Result := GLib2.g_string_free(@self, free_segment);
end;

function TGString.free_to_bytes: PGBytes; cdecl;
begin
  Result := GLib2.g_string_free_to_bytes(@self);
end;

function TGString.hash: guint; cdecl;
begin
  Result := GLib2.g_string_hash(@self);
end;

function TGString.insert(pos: gssize; val: Pgchar): PGString; cdecl;
begin
  Result := GLib2.g_string_insert(@self, pos, val);
end;

function TGString.insert_c(pos: gssize; c: gchar): PGString; cdecl;
begin
  Result := GLib2.g_string_insert_c(@self, pos, c);
end;

function TGString.insert_len(pos: gssize; val: Pgchar; len: gssize): PGString; cdecl;
begin
  Result := GLib2.g_string_insert_len(@self, pos, val, len);
end;

function TGString.insert_unichar(pos: gssize; wc: gunichar): PGString; cdecl;
begin
  Result := GLib2.g_string_insert_unichar(@self, pos, wc);
end;

function TGString.overwrite(pos: gsize; val: Pgchar): PGString; cdecl;
begin
  Result := GLib2.g_string_overwrite(@self, pos, val);
end;

function TGString.overwrite_len(pos: gsize; val: Pgchar; len: gssize): PGString; cdecl;
begin
  Result := GLib2.g_string_overwrite_len(@self, pos, val, len);
end;

function TGString.prepend(val: Pgchar): PGString; cdecl;
begin
  Result := GLib2.g_string_prepend(@self, val);
end;

function TGString.prepend_c(c: gchar): PGString; cdecl;
begin
  Result := GLib2.g_string_prepend_c(@self, c);
end;

function TGString.prepend_len(val: Pgchar; len: gssize): PGString; cdecl;
begin
  Result := GLib2.g_string_prepend_len(@self, val, len);
end;

function TGString.prepend_unichar(wc: gunichar): PGString; cdecl;
begin
  Result := GLib2.g_string_prepend_unichar(@self, wc);
end;

function TGString.set_size(len: gsize): PGString; cdecl;
begin
  Result := GLib2.g_string_set_size(@self, len);
end;

function TGString.truncate(len: gsize): PGString; cdecl;
begin
  Result := GLib2.g_string_truncate(@self, len);
end;

function TGIOChannel.new_file(filename: Pgchar; mode: Pgchar; error: PPGError): PGIOChannel; cdecl;
begin
  Result := GLib2.g_io_channel_new_file(filename, mode, error);
end;

function TGIOChannel.unix_new(fd: gint): PGIOChannel; cdecl;
begin
  Result := GLib2.g_io_channel_unix_new(fd);
end;

function TGIOChannel.flush(error: PPGError): TGIOStatus; cdecl;
begin
  Result := GLib2.g_io_channel_flush(@self, error);
end;

function TGIOChannel.get_buffer_condition: TGIOCondition; cdecl;
begin
  Result := GLib2.g_io_channel_get_buffer_condition(@self);
end;

function TGIOChannel.get_buffer_size: gsize; cdecl;
begin
  Result := GLib2.g_io_channel_get_buffer_size(@self);
end;

function TGIOChannel.get_buffered: gboolean; cdecl;
begin
  Result := GLib2.g_io_channel_get_buffered(@self);
end;

function TGIOChannel.get_close_on_unref: gboolean; cdecl;
begin
  Result := GLib2.g_io_channel_get_close_on_unref(@self);
end;

function TGIOChannel.get_encoding: Pgchar; cdecl;
begin
  Result := GLib2.g_io_channel_get_encoding(@self);
end;

function TGIOChannel.get_flags: TGIOFlags; cdecl;
begin
  Result := GLib2.g_io_channel_get_flags(@self);
end;

function TGIOChannel.get_line_term(length: Pgint): Pgchar; cdecl;
begin
  Result := GLib2.g_io_channel_get_line_term(@self, length);
end;

procedure TGIOChannel.init; cdecl;
begin
  GLib2.g_io_channel_init(@self);
end;

function TGIOChannel.read_chars(buf: Pgchar; count: gsize; bytes_read: Pgsize; error: PPGError): TGIOStatus; cdecl;
begin
  Result := GLib2.g_io_channel_read_chars(@self, buf, count, bytes_read, error);
end;

function TGIOChannel.read_line(str_return: PPgchar; length: Pgsize; terminator_pos: Pgsize; error: PPGError): TGIOStatus; cdecl;
begin
  Result := GLib2.g_io_channel_read_line(@self, str_return, length, terminator_pos, error);
end;

function TGIOChannel.read_line_string(buffer: PGString; terminator_pos: Pgsize; error: PPGError): TGIOStatus; cdecl;
begin
  Result := GLib2.g_io_channel_read_line_string(@self, buffer, terminator_pos, error);
end;

function TGIOChannel.read_to_end(str_return: PPgchar; length: Pgsize; error: PPGError): TGIOStatus; cdecl;
begin
  Result := GLib2.g_io_channel_read_to_end(@self, str_return, length, error);
end;

function TGIOChannel.read_unichar(thechar: Pgunichar; error: PPGError): TGIOStatus; cdecl;
begin
  Result := GLib2.g_io_channel_read_unichar(@self, thechar, error);
end;

function TGIOChannel.ref: PGIOChannel; cdecl;
begin
  Result := GLib2.g_io_channel_ref(@self);
end;

function TGIOChannel.seek_position(offset: gint64; type_: TGSeekType; error: PPGError): TGIOStatus; cdecl;
begin
  Result := GLib2.g_io_channel_seek_position(@self, offset, type_, error);
end;

procedure TGIOChannel.set_buffer_size(size: gsize); cdecl;
begin
  GLib2.g_io_channel_set_buffer_size(@self, size);
end;

procedure TGIOChannel.set_buffered(buffered: gboolean); cdecl;
begin
  GLib2.g_io_channel_set_buffered(@self, buffered);
end;

procedure TGIOChannel.set_close_on_unref(do_close: gboolean); cdecl;
begin
  GLib2.g_io_channel_set_close_on_unref(@self, do_close);
end;

function TGIOChannel.set_encoding(encoding: Pgchar; error: PPGError): TGIOStatus; cdecl;
begin
  Result := GLib2.g_io_channel_set_encoding(@self, encoding, error);
end;

function TGIOChannel.set_flags(flags: TGIOFlags; error: PPGError): TGIOStatus; cdecl;
begin
  Result := GLib2.g_io_channel_set_flags(@self, flags, error);
end;

procedure TGIOChannel.set_line_term(line_term: Pgchar; length: gint); cdecl;
begin
  GLib2.g_io_channel_set_line_term(@self, line_term, length);
end;

function TGIOChannel.shutdown(flush: gboolean; error: PPGError): TGIOStatus; cdecl;
begin
  Result := GLib2.g_io_channel_shutdown(@self, flush, error);
end;

function TGIOChannel.unix_get_fd: gint; cdecl;
begin
  Result := GLib2.g_io_channel_unix_get_fd(@self);
end;

procedure TGIOChannel.unref; cdecl;
begin
  GLib2.g_io_channel_unref(@self);
end;

function TGIOChannel.write_chars(buf: Pgchar; count: gssize; bytes_written: Pgsize; error: PPGError): TGIOStatus; cdecl;
begin
  Result := GLib2.g_io_channel_write_chars(@self, buf, count, bytes_written, error);
end;

function TGIOChannel.write_unichar(thechar: gunichar; error: PPGError): TGIOStatus; cdecl;
begin
  Result := GLib2.g_io_channel_write_unichar(@self, thechar, error);
end;

function TGIOChannel.error_from_errno(en: gint): TGIOChannelError; cdecl;
begin
  Result := GLib2.g_io_channel_error_from_errno(en);
end;

function TGIOChannel.error_quark: TGQuark; cdecl;
begin
  Result := GLib2.g_io_channel_error_quark();
end;

function TGSource.new(source_funcs: PGSourceFuncs; struct_size: guint): PGSource; cdecl;
begin
  Result := GLib2.g_source_new(source_funcs, struct_size);
end;

procedure TGSource.add_child_source(child_source: PGSource); cdecl;
begin
  GLib2.g_source_add_child_source(@self, child_source);
end;

procedure TGSource.add_poll(fd: PGPollFD); cdecl;
begin
  GLib2.g_source_add_poll(@self, fd);
end;

function TGSource.add_unix_fd(fd: gint; events: TGIOCondition): gpointer; cdecl;
begin
  Result := GLib2.g_source_add_unix_fd(@self, fd, events);
end;

function TGSource.attach(context: PGMainContext): guint; cdecl;
begin
  Result := GLib2.g_source_attach(@self, context);
end;

procedure TGSource.destroy_; cdecl;
begin
  GLib2.g_source_destroy(@self);
end;

function TGSource.get_can_recurse: gboolean; cdecl;
begin
  Result := GLib2.g_source_get_can_recurse(@self);
end;

function TGSource.get_context: PGMainContext; cdecl;
begin
  Result := GLib2.g_source_get_context(@self);
end;

function TGSource.get_id: guint; cdecl;
begin
  Result := GLib2.g_source_get_id(@self);
end;

function TGSource.get_name: Pgchar; cdecl;
begin
  Result := GLib2.g_source_get_name(@self);
end;

function TGSource.get_priority: gint; cdecl;
begin
  Result := GLib2.g_source_get_priority(@self);
end;

function TGSource.get_ready_time: gint64; cdecl;
begin
  Result := GLib2.g_source_get_ready_time(@self);
end;

function TGSource.get_time: gint64; cdecl;
begin
  Result := GLib2.g_source_get_time(@self);
end;

function TGSource.is_destroyed: gboolean; cdecl;
begin
  Result := GLib2.g_source_is_destroyed(@self);
end;

procedure TGSource.modify_unix_fd(tag: gpointer; new_events: TGIOCondition); cdecl;
begin
  GLib2.g_source_modify_unix_fd(@self, tag, new_events);
end;

function TGSource.query_unix_fd(tag: gpointer): TGIOCondition; cdecl;
begin
  Result := GLib2.g_source_query_unix_fd(@self, tag);
end;

function TGSource.ref: PGSource; cdecl;
begin
  Result := GLib2.g_source_ref(@self);
end;

procedure TGSource.remove_child_source(child_source: PGSource); cdecl;
begin
  GLib2.g_source_remove_child_source(@self, child_source);
end;

procedure TGSource.remove_poll(fd: PGPollFD); cdecl;
begin
  GLib2.g_source_remove_poll(@self, fd);
end;

procedure TGSource.remove_unix_fd(tag: gpointer); cdecl;
begin
  GLib2.g_source_remove_unix_fd(@self, tag);
end;

procedure TGSource.set_callback(func: TGSourceFunc; data: gpointer; notify: TGDestroyNotify); cdecl;
begin
  GLib2.g_source_set_callback(@self, func, data, notify);
end;

procedure TGSource.set_callback_indirect(callback_data: gpointer; callback_funcs: PGSourceCallbackFuncs); cdecl;
begin
  GLib2.g_source_set_callback_indirect(@self, callback_data, callback_funcs);
end;

procedure TGSource.set_can_recurse(can_recurse: gboolean); cdecl;
begin
  GLib2.g_source_set_can_recurse(@self, can_recurse);
end;

procedure TGSource.set_funcs(funcs: PGSourceFuncs); cdecl;
begin
  GLib2.g_source_set_funcs(@self, funcs);
end;

procedure TGSource.set_name(name: Pgchar); cdecl;
begin
  GLib2.g_source_set_name(@self, name);
end;

procedure TGSource.set_priority(priority: gint); cdecl;
begin
  GLib2.g_source_set_priority(@self, priority);
end;

procedure TGSource.set_ready_time(ready_time: gint64); cdecl;
begin
  GLib2.g_source_set_ready_time(@self, ready_time);
end;

procedure TGSource.unref; cdecl;
begin
  GLib2.g_source_unref(@self);
end;

function TGSource.remove(tag: guint): gboolean; cdecl;
begin
  Result := GLib2.g_source_remove(tag);
end;

function TGSource.remove_by_funcs_user_data(funcs: PGSourceFuncs; user_data: gpointer): gboolean; cdecl;
begin
  Result := GLib2.g_source_remove_by_funcs_user_data(funcs, user_data);
end;

function TGSource.remove_by_user_data(user_data: gpointer): gboolean; cdecl;
begin
  Result := GLib2.g_source_remove_by_user_data(user_data);
end;

procedure TGSource.set_name_by_id(tag: guint; name: Pgchar); cdecl;
begin
  GLib2.g_source_set_name_by_id(tag, name);
end;

function TGKeyFile.new: PGKeyFile; cdecl;
begin
  Result := GLib2.g_key_file_new();
end;

procedure TGKeyFile.free; cdecl;
begin
  GLib2.g_key_file_free(@self);
end;

function TGKeyFile.get_boolean(group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_key_file_get_boolean(@self, group_name, key, error);
end;

function TGKeyFile.get_boolean_list(group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): Pgboolean; cdecl;
begin
  Result := GLib2.g_key_file_get_boolean_list(@self, group_name, key, length, error);
end;

function TGKeyFile.get_comment(group_name: Pgchar; key: Pgchar; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_key_file_get_comment(@self, group_name, key, error);
end;

function TGKeyFile.get_double(group_name: Pgchar; key: Pgchar; error: PPGError): gdouble; cdecl;
begin
  Result := GLib2.g_key_file_get_double(@self, group_name, key, error);
end;

function TGKeyFile.get_double_list(group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): Pgdouble; cdecl;
begin
  Result := GLib2.g_key_file_get_double_list(@self, group_name, key, length, error);
end;

function TGKeyFile.get_groups(length: Pgsize): PPgchar; cdecl;
begin
  Result := GLib2.g_key_file_get_groups(@self, length);
end;

function TGKeyFile.get_int64(group_name: Pgchar; key: Pgchar; error: PPGError): gint64; cdecl;
begin
  Result := GLib2.g_key_file_get_int64(@self, group_name, key, error);
end;

function TGKeyFile.get_integer(group_name: Pgchar; key: Pgchar; error: PPGError): gint; cdecl;
begin
  Result := GLib2.g_key_file_get_integer(@self, group_name, key, error);
end;

function TGKeyFile.get_integer_list(group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): Pgint; cdecl;
begin
  Result := GLib2.g_key_file_get_integer_list(@self, group_name, key, length, error);
end;

function TGKeyFile.get_keys(group_name: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl;
begin
  Result := GLib2.g_key_file_get_keys(@self, group_name, length, error);
end;

function TGKeyFile.get_locale_string(group_name: Pgchar; key: Pgchar; locale: Pgchar; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_key_file_get_locale_string(@self, group_name, key, locale, error);
end;

function TGKeyFile.get_locale_string_list(group_name: Pgchar; key: Pgchar; locale: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl;
begin
  Result := GLib2.g_key_file_get_locale_string_list(@self, group_name, key, locale, length, error);
end;

function TGKeyFile.get_start_group: Pgchar; cdecl;
begin
  Result := GLib2.g_key_file_get_start_group(@self);
end;

function TGKeyFile.get_string(group_name: Pgchar; key: Pgchar; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_key_file_get_string(@self, group_name, key, error);
end;

function TGKeyFile.get_string_list(group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl;
begin
  Result := GLib2.g_key_file_get_string_list(@self, group_name, key, length, error);
end;

function TGKeyFile.get_uint64(group_name: Pgchar; key: Pgchar; error: PPGError): guint64; cdecl;
begin
  Result := GLib2.g_key_file_get_uint64(@self, group_name, key, error);
end;

function TGKeyFile.get_value(group_name: Pgchar; key: Pgchar; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_key_file_get_value(@self, group_name, key, error);
end;

function TGKeyFile.has_group(group_name: Pgchar): gboolean; cdecl;
begin
  Result := GLib2.g_key_file_has_group(@self, group_name);
end;

function TGKeyFile.has_key(group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_key_file_has_key(@self, group_name, key, error);
end;

function TGKeyFile.load_from_data(data: Pgchar; length: gsize; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_key_file_load_from_data(@self, data, length, flags, error);
end;

function TGKeyFile.load_from_data_dirs(file_: Pgchar; full_path: PPgchar; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_key_file_load_from_data_dirs(@self, file_, full_path, flags, error);
end;

function TGKeyFile.load_from_dirs(file_: Pgchar; search_dirs: PPgchar; full_path: PPgchar; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_key_file_load_from_dirs(@self, file_, search_dirs, full_path, flags, error);
end;

function TGKeyFile.load_from_file(file_: Pgchar; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_key_file_load_from_file(@self, file_, flags, error);
end;

function TGKeyFile.ref: PGKeyFile; cdecl;
begin
  Result := GLib2.g_key_file_ref(@self);
end;

function TGKeyFile.remove_comment(group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_key_file_remove_comment(@self, group_name, key, error);
end;

function TGKeyFile.remove_group(group_name: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_key_file_remove_group(@self, group_name, error);
end;

function TGKeyFile.remove_key(group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_key_file_remove_key(@self, group_name, key, error);
end;

procedure TGKeyFile.set_boolean(group_name: Pgchar; key: Pgchar; value: gboolean); cdecl;
begin
  GLib2.g_key_file_set_boolean(@self, group_name, key, value);
end;

procedure TGKeyFile.set_boolean_list(group_name: Pgchar; key: Pgchar; list: gboolean; length: gsize); cdecl;
begin
  GLib2.g_key_file_set_boolean_list(@self, group_name, key, list, length);
end;

function TGKeyFile.set_comment(group_name: Pgchar; key: Pgchar; comment: Pgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_key_file_set_comment(@self, group_name, key, comment, error);
end;

procedure TGKeyFile.set_double(group_name: Pgchar; key: Pgchar; value: gdouble); cdecl;
begin
  GLib2.g_key_file_set_double(@self, group_name, key, value);
end;

procedure TGKeyFile.set_double_list(group_name: Pgchar; key: Pgchar; list: gdouble; length: gsize); cdecl;
begin
  GLib2.g_key_file_set_double_list(@self, group_name, key, list, length);
end;

procedure TGKeyFile.set_int64(group_name: Pgchar; key: Pgchar; value: gint64); cdecl;
begin
  GLib2.g_key_file_set_int64(@self, group_name, key, value);
end;

procedure TGKeyFile.set_integer(group_name: Pgchar; key: Pgchar; value: gint); cdecl;
begin
  GLib2.g_key_file_set_integer(@self, group_name, key, value);
end;

procedure TGKeyFile.set_integer_list(group_name: Pgchar; key: Pgchar; list: gint; length: gsize); cdecl;
begin
  GLib2.g_key_file_set_integer_list(@self, group_name, key, list, length);
end;

procedure TGKeyFile.set_list_separator(separator: gchar); cdecl;
begin
  GLib2.g_key_file_set_list_separator(@self, separator);
end;

procedure TGKeyFile.set_locale_string(group_name: Pgchar; key: Pgchar; locale: Pgchar; string_: Pgchar); cdecl;
begin
  GLib2.g_key_file_set_locale_string(@self, group_name, key, locale, string_);
end;

procedure TGKeyFile.set_locale_string_list(group_name: Pgchar; key: Pgchar; locale: Pgchar; list: Pgchar; length: gsize); cdecl;
begin
  GLib2.g_key_file_set_locale_string_list(@self, group_name, key, locale, list, length);
end;

procedure TGKeyFile.set_string(group_name: Pgchar; key: Pgchar; string_: Pgchar); cdecl;
begin
  GLib2.g_key_file_set_string(@self, group_name, key, string_);
end;

procedure TGKeyFile.set_string_list(group_name: Pgchar; key: Pgchar; list: Pgchar; length: gsize); cdecl;
begin
  GLib2.g_key_file_set_string_list(@self, group_name, key, list, length);
end;

procedure TGKeyFile.set_uint64(group_name: Pgchar; key: Pgchar; value: guint64); cdecl;
begin
  GLib2.g_key_file_set_uint64(@self, group_name, key, value);
end;

procedure TGKeyFile.set_value(group_name: Pgchar; key: Pgchar; value: Pgchar); cdecl;
begin
  GLib2.g_key_file_set_value(@self, group_name, key, value);
end;

function TGKeyFile.to_data(length: Pgsize; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_key_file_to_data(@self, length, error);
end;

procedure TGKeyFile.unref; cdecl;
begin
  GLib2.g_key_file_unref(@self);
end;

function TGKeyFile.error_quark: TGQuark; cdecl;
begin
  Result := GLib2.g_key_file_error_quark();
end;

function TGMainContext.new: PGMainContext; cdecl;
begin
  Result := GLib2.g_main_context_new();
end;

function TGMainContext.acquire: gboolean; cdecl;
begin
  Result := GLib2.g_main_context_acquire(@self);
end;

procedure TGMainContext.add_poll(fd: PGPollFD; priority: gint); cdecl;
begin
  GLib2.g_main_context_add_poll(@self, fd, priority);
end;

function TGMainContext.check(max_priority: gint; fds: PGPollFD; n_fds: gint): gint; cdecl;
begin
  Result := GLib2.g_main_context_check(@self, max_priority, fds, n_fds);
end;

procedure TGMainContext.dispatch; cdecl;
begin
  GLib2.g_main_context_dispatch(@self);
end;

function TGMainContext.find_source_by_funcs_user_data(funcs: PGSourceFuncs; user_data: gpointer): PGSource; cdecl;
begin
  Result := GLib2.g_main_context_find_source_by_funcs_user_data(@self, funcs, user_data);
end;

function TGMainContext.find_source_by_id(source_id: guint): PGSource; cdecl;
begin
  Result := GLib2.g_main_context_find_source_by_id(@self, source_id);
end;

function TGMainContext.find_source_by_user_data(user_data: gpointer): PGSource; cdecl;
begin
  Result := GLib2.g_main_context_find_source_by_user_data(@self, user_data);
end;

function TGMainContext.get_poll_func: TGPollFunc; cdecl;
begin
  Result := GLib2.g_main_context_get_poll_func(@self);
end;

procedure TGMainContext.invoke(function_: TGSourceFunc; data: gpointer); cdecl;
begin
  GLib2.g_main_context_invoke(@self, function_, data);
end;

procedure TGMainContext.invoke_full(priority: gint; function_: TGSourceFunc; data: gpointer; notify: TGDestroyNotify); cdecl;
begin
  GLib2.g_main_context_invoke_full(@self, priority, function_, data, notify);
end;

function TGMainContext.is_owner: gboolean; cdecl;
begin
  Result := GLib2.g_main_context_is_owner(@self);
end;

function TGMainContext.iteration(may_block: gboolean): gboolean; cdecl;
begin
  Result := GLib2.g_main_context_iteration(@self, may_block);
end;

function TGMainContext.pending: gboolean; cdecl;
begin
  Result := GLib2.g_main_context_pending(@self);
end;

procedure TGMainContext.pop_thread_default; cdecl;
begin
  GLib2.g_main_context_pop_thread_default(@self);
end;

function TGMainContext.prepare(priority: Pgint): gboolean; cdecl;
begin
  Result := GLib2.g_main_context_prepare(@self, priority);
end;

procedure TGMainContext.push_thread_default; cdecl;
begin
  GLib2.g_main_context_push_thread_default(@self);
end;

function TGMainContext.query(max_priority: gint; timeout_: Pgint; fds: PGPollFD; n_fds: gint): gint; cdecl;
begin
  Result := GLib2.g_main_context_query(@self, max_priority, timeout_, fds, n_fds);
end;

function TGMainContext.ref: PGMainContext; cdecl;
begin
  Result := GLib2.g_main_context_ref(@self);
end;

procedure TGMainContext.release; cdecl;
begin
  GLib2.g_main_context_release(@self);
end;

procedure TGMainContext.remove_poll(fd: PGPollFD); cdecl;
begin
  GLib2.g_main_context_remove_poll(@self, fd);
end;

procedure TGMainContext.set_poll_func(func: TGPollFunc); cdecl;
begin
  GLib2.g_main_context_set_poll_func(@self, func);
end;

procedure TGMainContext.unref; cdecl;
begin
  GLib2.g_main_context_unref(@self);
end;

function TGMainContext.wait(cond: PGCond; mutex: PGMutex): gboolean; cdecl;
begin
  Result := GLib2.g_main_context_wait(@self, cond, mutex);
end;

procedure TGMainContext.wakeup; cdecl;
begin
  GLib2.g_main_context_wakeup(@self);
end;

function TGMainContext.default_: PGMainContext; cdecl;
begin
  Result := GLib2.g_main_context_default();
end;

function TGMainContext.get_thread_default: PGMainContext; cdecl;
begin
  Result := GLib2.g_main_context_get_thread_default();
end;

function TGMainContext.ref_thread_default: PGMainContext; cdecl;
begin
  Result := GLib2.g_main_context_ref_thread_default();
end;

function TGMainLoop.new(context: PGMainContext; is_running: gboolean): PGMainLoop; cdecl;
begin
  Result := GLib2.g_main_loop_new(context, is_running);
end;

function TGMainLoop.get_context: PGMainContext; cdecl;
begin
  Result := GLib2.g_main_loop_get_context(@self);
end;

function TGMainLoop.is_running: gboolean; cdecl;
begin
  Result := GLib2.g_main_loop_is_running(@self);
end;

procedure TGMainLoop.quit; cdecl;
begin
  GLib2.g_main_loop_quit(@self);
end;

function TGMainLoop.ref: PGMainLoop; cdecl;
begin
  Result := GLib2.g_main_loop_ref(@self);
end;

procedure TGMainLoop.run; cdecl;
begin
  GLib2.g_main_loop_run(@self);
end;

procedure TGMainLoop.unref; cdecl;
begin
  GLib2.g_main_loop_unref(@self);
end;

function TGMappedFile.get_bytes: PGBytes; cdecl;
begin
  Result := GLib2.g_mapped_file_get_bytes(@self);
end;

function TGMappedFile.get_contents: Pgchar; cdecl;
begin
  Result := GLib2.g_mapped_file_get_contents(@self);
end;

function TGMappedFile.get_length: gsize; cdecl;
begin
  Result := GLib2.g_mapped_file_get_length(@self);
end;

function TGMappedFile.ref: PGMappedFile; cdecl;
begin
  Result := GLib2.g_mapped_file_ref(@self);
end;

procedure TGMappedFile.unref; cdecl;
begin
  GLib2.g_mapped_file_unref(@self);
end;

function TGMappedFile.new(filename: Pgchar; writable: gboolean; error: PPGError): PGMappedFile; cdecl;
begin
  Result := GLib2.g_mapped_file_new(filename, writable, error);
end;

function TGMappedFile.new_from_fd(fd: gint; writable: gboolean; error: PPGError): PGMappedFile; cdecl;
begin
  Result := GLib2.g_mapped_file_new_from_fd(fd, writable, error);
end;

function TGMarkupParseContext.new(parser: PGMarkupParser; flags: TGMarkupParseFlags; user_data: gpointer; user_data_dnotify: TGDestroyNotify): PGMarkupParseContext; cdecl;
begin
  Result := GLib2.g_markup_parse_context_new(parser, flags, user_data, user_data_dnotify);
end;

function TGMarkupParseContext.end_parse(error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_markup_parse_context_end_parse(@self, error);
end;

procedure TGMarkupParseContext.free; cdecl;
begin
  GLib2.g_markup_parse_context_free(@self);
end;

function TGMarkupParseContext.get_element: Pgchar; cdecl;
begin
  Result := GLib2.g_markup_parse_context_get_element(@self);
end;

function TGMarkupParseContext.get_element_stack: PGSList; cdecl;
begin
  Result := GLib2.g_markup_parse_context_get_element_stack(@self);
end;

procedure TGMarkupParseContext.get_position(line_number: Pgint; char_number: Pgint); cdecl;
begin
  GLib2.g_markup_parse_context_get_position(@self, line_number, char_number);
end;

function TGMarkupParseContext.get_user_data: gpointer; cdecl;
begin
  Result := GLib2.g_markup_parse_context_get_user_data(@self);
end;

function TGMarkupParseContext.parse(text: Pgchar; text_len: gssize; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_markup_parse_context_parse(@self, text, text_len, error);
end;

function TGMarkupParseContext.pop: gpointer; cdecl;
begin
  Result := GLib2.g_markup_parse_context_pop(@self);
end;

procedure TGMarkupParseContext.push(parser: PGMarkupParser; user_data: gpointer); cdecl;
begin
  GLib2.g_markup_parse_context_push(@self, parser, user_data);
end;

function TGMarkupParseContext.ref: PGMarkupParseContext; cdecl;
begin
  Result := GLib2.g_markup_parse_context_ref(@self);
end;

procedure TGMarkupParseContext.unref; cdecl;
begin
  GLib2.g_markup_parse_context_unref(@self);
end;

function TGSList.alloc: PGSList; cdecl;
begin
  Result := GLib2.g_slist_alloc();
end;

function TGSList.append(list: PGSList; data: gpointer): PGSList; cdecl;
begin
  Result := GLib2.g_slist_append(list, data);
end;

function TGSList.concat(list1: PGSList; list2: PGSList): PGSList; cdecl;
begin
  Result := GLib2.g_slist_concat(list1, list2);
end;

function TGSList.copy(list: PGSList): PGSList; cdecl;
begin
  Result := GLib2.g_slist_copy(list);
end;

function TGSList.copy_deep(list: PGSList; func: TGCopyFunc; user_data: gpointer): PGSList; cdecl;
begin
  Result := GLib2.g_slist_copy_deep(list, func, user_data);
end;

function TGSList.delete_link(list: PGSList; link_: PGSList): PGSList; cdecl;
begin
  Result := GLib2.g_slist_delete_link(list, link_);
end;

function TGSList.find(list: PGSList; data: Pgpointer): PGSList; cdecl;
begin
  Result := GLib2.g_slist_find(list, data);
end;

function TGSList.find_custom(list: PGSList; data: Pgpointer; func: TGCompareFunc): PGSList; cdecl;
begin
  Result := GLib2.g_slist_find_custom(list, data, func);
end;

procedure TGSList.foreach(list: PGSList; func: TGFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_slist_foreach(list, func, user_data);
end;

procedure TGSList.free(list: PGSList); cdecl;
begin
  GLib2.g_slist_free(list);
end;

procedure TGSList.free_1(list: PGSList); cdecl;
begin
  GLib2.g_slist_free_1(list);
end;

procedure TGSList.free_full(list: PGSList; free_func: TGDestroyNotify); cdecl;
begin
  GLib2.g_slist_free_full(list, free_func);
end;

function TGSList.index(list: PGSList; data: Pgpointer): gint; cdecl;
begin
  Result := GLib2.g_slist_index(list, data);
end;

function TGSList.insert(list: PGSList; data: gpointer; position: gint): PGSList; cdecl;
begin
  Result := GLib2.g_slist_insert(list, data, position);
end;

function TGSList.insert_before(slist: PGSList; sibling: PGSList; data: gpointer): PGSList; cdecl;
begin
  Result := GLib2.g_slist_insert_before(slist, sibling, data);
end;

function TGSList.insert_sorted(list: PGSList; data: gpointer; func: TGCompareFunc): PGSList; cdecl;
begin
  Result := GLib2.g_slist_insert_sorted(list, data, func);
end;

function TGSList.insert_sorted_with_data(list: PGSList; data: gpointer; func: TGCompareDataFunc; user_data: gpointer): PGSList; cdecl;
begin
  Result := GLib2.g_slist_insert_sorted_with_data(list, data, func, user_data);
end;

function TGSList.last(list: PGSList): PGSList; cdecl;
begin
  Result := GLib2.g_slist_last(list);
end;

function TGSList.length(list: PGSList): guint; cdecl;
begin
  Result := GLib2.g_slist_length(list);
end;

function TGSList.nth(list: PGSList; n: guint): PGSList; cdecl;
begin
  Result := GLib2.g_slist_nth(list, n);
end;

function TGSList.nth_data(list: PGSList; n: guint): gpointer; cdecl;
begin
  Result := GLib2.g_slist_nth_data(list, n);
end;

function TGSList.position(list: PGSList; llink: PGSList): gint; cdecl;
begin
  Result := GLib2.g_slist_position(list, llink);
end;

function TGSList.prepend(list: PGSList; data: gpointer): PGSList; cdecl;
begin
  Result := GLib2.g_slist_prepend(list, data);
end;

function TGSList.remove(list: PGSList; data: Pgpointer): PGSList; cdecl;
begin
  Result := GLib2.g_slist_remove(list, data);
end;

function TGSList.remove_all(list: PGSList; data: Pgpointer): PGSList; cdecl;
begin
  Result := GLib2.g_slist_remove_all(list, data);
end;

function TGSList.remove_link(list: PGSList; link_: PGSList): PGSList; cdecl;
begin
  Result := GLib2.g_slist_remove_link(list, link_);
end;

function TGSList.reverse(list: PGSList): PGSList; cdecl;
begin
  Result := GLib2.g_slist_reverse(list);
end;

function TGSList.sort(list: PGSList; compare_func: TGCompareFunc): PGSList; cdecl;
begin
  Result := GLib2.g_slist_sort(list, compare_func);
end;

function TGSList.sort_with_data(list: PGSList; compare_func: TGCompareDataFunc; user_data: gpointer): PGSList; cdecl;
begin
  Result := GLib2.g_slist_sort_with_data(list, compare_func, user_data);
end;

function TGMatchInfo.expand_references(string_to_expand: Pgchar; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_match_info_expand_references(@self, string_to_expand, error);
end;

function TGMatchInfo.fetch(match_num: gint): Pgchar; cdecl;
begin
  Result := GLib2.g_match_info_fetch(@self, match_num);
end;

function TGMatchInfo.fetch_all: PPgchar; cdecl;
begin
  Result := GLib2.g_match_info_fetch_all(@self);
end;

function TGMatchInfo.fetch_named(name: Pgchar): Pgchar; cdecl;
begin
  Result := GLib2.g_match_info_fetch_named(@self, name);
end;

function TGMatchInfo.fetch_named_pos(name: Pgchar; start_pos: Pgint; end_pos: Pgint): gboolean; cdecl;
begin
  Result := GLib2.g_match_info_fetch_named_pos(@self, name, start_pos, end_pos);
end;

function TGMatchInfo.fetch_pos(match_num: gint; start_pos: Pgint; end_pos: Pgint): gboolean; cdecl;
begin
  Result := GLib2.g_match_info_fetch_pos(@self, match_num, start_pos, end_pos);
end;

procedure TGMatchInfo.free; cdecl;
begin
  GLib2.g_match_info_free(@self);
end;

function TGMatchInfo.get_match_count: gint; cdecl;
begin
  Result := GLib2.g_match_info_get_match_count(@self);
end;

function TGMatchInfo.get_regex: PGRegex; cdecl;
begin
  Result := GLib2.g_match_info_get_regex(@self);
end;

function TGMatchInfo.get_string: Pgchar; cdecl;
begin
  Result := GLib2.g_match_info_get_string(@self);
end;

function TGMatchInfo.is_partial_match: gboolean; cdecl;
begin
  Result := GLib2.g_match_info_is_partial_match(@self);
end;

function TGMatchInfo.matches: gboolean; cdecl;
begin
  Result := GLib2.g_match_info_matches(@self);
end;

function TGMatchInfo.next(error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_match_info_next(@self, error);
end;

function TGMatchInfo.ref: PGMatchInfo; cdecl;
begin
  Result := GLib2.g_match_info_ref(@self);
end;

procedure TGMatchInfo.unref; cdecl;
begin
  GLib2.g_match_info_unref(@self);
end;

function TGRegex.new(pattern: Pgchar; compile_options: TGRegexCompileFlags; match_options: TGRegexMatchFlags; error: PPGError): PGRegex; cdecl;
begin
  Result := GLib2.g_regex_new(pattern, compile_options, match_options, error);
end;

function TGRegex.get_capture_count: gint; cdecl;
begin
  Result := GLib2.g_regex_get_capture_count(@self);
end;

function TGRegex.get_compile_flags: TGRegexCompileFlags; cdecl;
begin
  Result := GLib2.g_regex_get_compile_flags(@self);
end;

function TGRegex.get_has_cr_or_lf: gboolean; cdecl;
begin
  Result := GLib2.g_regex_get_has_cr_or_lf(@self);
end;

function TGRegex.get_match_flags: TGRegexMatchFlags; cdecl;
begin
  Result := GLib2.g_regex_get_match_flags(@self);
end;

function TGRegex.get_max_backref: gint; cdecl;
begin
  Result := GLib2.g_regex_get_max_backref(@self);
end;

function TGRegex.get_pattern: Pgchar; cdecl;
begin
  Result := GLib2.g_regex_get_pattern(@self);
end;

function TGRegex.get_string_number(name: Pgchar): gint; cdecl;
begin
  Result := GLib2.g_regex_get_string_number(@self, name);
end;

function TGRegex.match(string_: Pgchar; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo): gboolean; cdecl;
begin
  Result := GLib2.g_regex_match(@self, string_, match_options, match_info);
end;

function TGRegex.match_all(string_: Pgchar; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo): gboolean; cdecl;
begin
  Result := GLib2.g_regex_match_all(@self, string_, match_options, match_info);
end;

function TGRegex.match_all_full(string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_regex_match_all_full(@self, string_, string_len, start_position, match_options, match_info, error);
end;

function TGRegex.match_full(string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_regex_match_full(@self, string_, string_len, start_position, match_options, match_info, error);
end;

function TGRegex.ref: PGRegex; cdecl;
begin
  Result := GLib2.g_regex_ref(@self);
end;

function TGRegex.replace(string_: Pgchar; string_len: gssize; start_position: gint; replacement: Pgchar; match_options: TGRegexMatchFlags; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_regex_replace(@self, string_, string_len, start_position, replacement, match_options, error);
end;

function TGRegex.replace_eval(string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; eval: TGRegexEvalCallback; user_data: gpointer; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_regex_replace_eval(@self, string_, string_len, start_position, match_options, eval, user_data, error);
end;

function TGRegex.replace_literal(string_: Pgchar; string_len: gssize; start_position: gint; replacement: Pgchar; match_options: TGRegexMatchFlags; error: PPGError): Pgchar; cdecl;
begin
  Result := GLib2.g_regex_replace_literal(@self, string_, string_len, start_position, replacement, match_options, error);
end;

function TGRegex.split(string_: Pgchar; match_options: TGRegexMatchFlags): PPgchar; cdecl;
begin
  Result := GLib2.g_regex_split(@self, string_, match_options);
end;

function TGRegex.split_full(string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; max_tokens: gint; error: PPGError): PPgchar; cdecl;
begin
  Result := GLib2.g_regex_split_full(@self, string_, string_len, start_position, match_options, max_tokens, error);
end;

procedure TGRegex.unref; cdecl;
begin
  GLib2.g_regex_unref(@self);
end;

function TGRegex.check_replacement(replacement: Pgchar; has_references: Pgboolean; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_regex_check_replacement(replacement, has_references, error);
end;

function TGRegex.error_quark: TGQuark; cdecl;
begin
  Result := GLib2.g_regex_error_quark();
end;

function TGRegex.escape_nul(string_: Pgchar; length: gint): Pgchar; cdecl;
begin
  Result := GLib2.g_regex_escape_nul(string_, length);
end;

function TGRegex.escape_string(string_: Pgchar; length: gint): Pgchar; cdecl;
begin
  Result := GLib2.g_regex_escape_string(string_, length);
end;

function TGRegex.match_simple(pattern: Pgchar; string_: Pgchar; compile_options: TGRegexCompileFlags; match_options: TGRegexMatchFlags): gboolean; cdecl;
begin
  Result := GLib2.g_regex_match_simple(pattern, string_, compile_options, match_options);
end;

function TGRegex.split_simple(pattern: Pgchar; string_: Pgchar; compile_options: TGRegexCompileFlags; match_options: TGRegexMatchFlags): PPgchar; cdecl;
begin
  Result := GLib2.g_regex_split_simple(pattern, string_, compile_options, match_options);
end;

function TGNode.child_index(data: gpointer): gint; cdecl;
begin
  Result := GLib2.g_node_child_index(@self, data);
end;

function TGNode.child_position(child: PGNode): gint; cdecl;
begin
  Result := GLib2.g_node_child_position(@self, child);
end;

procedure TGNode.children_foreach(flags: TGTraverseFlags; func: TGNodeForeachFunc; data: gpointer); cdecl;
begin
  GLib2.g_node_children_foreach(@self, flags, func, data);
end;

function TGNode.copy: PGNode; cdecl;
begin
  Result := GLib2.g_node_copy(@self);
end;

function TGNode.copy_deep(copy_func: TGCopyFunc; data: gpointer): PGNode; cdecl;
begin
  Result := GLib2.g_node_copy_deep(@self, copy_func, data);
end;

function TGNode.depth: guint; cdecl;
begin
  Result := GLib2.g_node_depth(@self);
end;

procedure TGNode.destroy_; cdecl;
begin
  GLib2.g_node_destroy(@self);
end;

function TGNode.find(order: TGTraverseType; flags: TGTraverseFlags; data: gpointer): PGNode; cdecl;
begin
  Result := GLib2.g_node_find(@self, order, flags, data);
end;

function TGNode.find_child(flags: TGTraverseFlags; data: gpointer): PGNode; cdecl;
begin
  Result := GLib2.g_node_find_child(@self, flags, data);
end;

function TGNode.first_sibling: PGNode; cdecl;
begin
  Result := GLib2.g_node_first_sibling(@self);
end;

function TGNode.get_root: PGNode; cdecl;
begin
  Result := GLib2.g_node_get_root(@self);
end;

function TGNode.insert(position: gint; node: PGNode): PGNode; cdecl;
begin
  Result := GLib2.g_node_insert(@self, position, node);
end;

function TGNode.insert_after(sibling: PGNode; node: PGNode): PGNode; cdecl;
begin
  Result := GLib2.g_node_insert_after(@self, sibling, node);
end;

function TGNode.insert_before(sibling: PGNode; node: PGNode): PGNode; cdecl;
begin
  Result := GLib2.g_node_insert_before(@self, sibling, node);
end;

function TGNode.is_ancestor(descendant: PGNode): gboolean; cdecl;
begin
  Result := GLib2.g_node_is_ancestor(@self, descendant);
end;

function TGNode.last_child: PGNode; cdecl;
begin
  Result := GLib2.g_node_last_child(@self);
end;

function TGNode.last_sibling: PGNode; cdecl;
begin
  Result := GLib2.g_node_last_sibling(@self);
end;

function TGNode.max_height: guint; cdecl;
begin
  Result := GLib2.g_node_max_height(@self);
end;

function TGNode.n_children: guint; cdecl;
begin
  Result := GLib2.g_node_n_children(@self);
end;

function TGNode.n_nodes(flags: TGTraverseFlags): guint; cdecl;
begin
  Result := GLib2.g_node_n_nodes(@self, flags);
end;

function TGNode.nth_child(n: guint): PGNode; cdecl;
begin
  Result := GLib2.g_node_nth_child(@self, n);
end;

function TGNode.prepend(node: PGNode): PGNode; cdecl;
begin
  Result := GLib2.g_node_prepend(@self, node);
end;

procedure TGNode.reverse_children; cdecl;
begin
  GLib2.g_node_reverse_children(@self);
end;

procedure TGNode.traverse(order: TGTraverseType; flags: TGTraverseFlags; max_depth: gint; func: TGNodeTraverseFunc; data: gpointer); cdecl;
begin
  GLib2.g_node_traverse(@self, order, flags, max_depth, func, data);
end;

procedure TGNode.unlink; cdecl;
begin
  GLib2.g_node_unlink(@self);
end;

function TGNode.new(data: gpointer): PGNode; cdecl;
begin
  Result := GLib2.g_node_new(data);
end;

function TGOnce.impl(func: TGThreadFunc; arg: gpointer): gpointer; cdecl;
begin
  Result := GLib2.g_once_impl(@self, func, arg);
end;

function TGOnce.init_enter(location: Pgpointer): gboolean; cdecl;
begin
  Result := GLib2.g_once_init_enter(location);
end;

procedure TGOnce.init_leave(location: Pgpointer; result_: gsize); cdecl;
begin
  GLib2.g_once_init_leave(location, result_);
end;

procedure TGOptionContext.add_group(group: PGOptionGroup); cdecl;
begin
  GLib2.g_option_context_add_group(@self, group);
end;

procedure TGOptionContext.add_main_entries(entries: PGOptionEntry; translation_domain: Pgchar); cdecl;
begin
  GLib2.g_option_context_add_main_entries(@self, entries, translation_domain);
end;

procedure TGOptionContext.free; cdecl;
begin
  GLib2.g_option_context_free(@self);
end;

function TGOptionContext.get_description: Pgchar; cdecl;
begin
  Result := GLib2.g_option_context_get_description(@self);
end;

function TGOptionContext.get_help(main_help: gboolean; group: PGOptionGroup): Pgchar; cdecl;
begin
  Result := GLib2.g_option_context_get_help(@self, main_help, group);
end;

function TGOptionContext.get_help_enabled: gboolean; cdecl;
begin
  Result := GLib2.g_option_context_get_help_enabled(@self);
end;

function TGOptionContext.get_ignore_unknown_options: gboolean; cdecl;
begin
  Result := GLib2.g_option_context_get_ignore_unknown_options(@self);
end;

function TGOptionContext.get_main_group: PGOptionGroup; cdecl;
begin
  Result := GLib2.g_option_context_get_main_group(@self);
end;

function TGOptionContext.get_summary: Pgchar; cdecl;
begin
  Result := GLib2.g_option_context_get_summary(@self);
end;

function TGOptionContext.parse(argc: Pgint; argv: PPPgchar; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_option_context_parse(@self, argc, argv, error);
end;

procedure TGOptionContext.set_description(description: Pgchar); cdecl;
begin
  GLib2.g_option_context_set_description(@self, description);
end;

procedure TGOptionContext.set_help_enabled(help_enabled: gboolean); cdecl;
begin
  GLib2.g_option_context_set_help_enabled(@self, help_enabled);
end;

procedure TGOptionContext.set_ignore_unknown_options(ignore_unknown: gboolean); cdecl;
begin
  GLib2.g_option_context_set_ignore_unknown_options(@self, ignore_unknown);
end;

procedure TGOptionContext.set_main_group(group: PGOptionGroup); cdecl;
begin
  GLib2.g_option_context_set_main_group(@self, group);
end;

procedure TGOptionContext.set_summary(summary: Pgchar); cdecl;
begin
  GLib2.g_option_context_set_summary(@self, summary);
end;

procedure TGOptionContext.set_translate_func(func: TGTranslateFunc; data: gpointer; destroy_notify: TGDestroyNotify); cdecl;
begin
  GLib2.g_option_context_set_translate_func(@self, func, data, destroy_notify);
end;

procedure TGOptionContext.set_translation_domain(domain: Pgchar); cdecl;
begin
  GLib2.g_option_context_set_translation_domain(@self, domain);
end;

function TGOptionContext.new(parameter_string: Pgchar): PGOptionContext; cdecl;
begin
  Result := GLib2.g_option_context_new(parameter_string);
end;

procedure TGOptionGroup.add_entries(entries: PGOptionEntry); cdecl;
begin
  GLib2.g_option_group_add_entries(@self, entries);
end;

procedure TGOptionGroup.free; cdecl;
begin
  GLib2.g_option_group_free(@self);
end;

procedure TGOptionGroup.set_error_hook(error_func: TGOptionErrorFunc); cdecl;
begin
  GLib2.g_option_group_set_error_hook(@self, error_func);
end;

procedure TGOptionGroup.set_parse_hooks(pre_parse_func: TGOptionParseFunc; post_parse_func: TGOptionParseFunc); cdecl;
begin
  GLib2.g_option_group_set_parse_hooks(@self, pre_parse_func, post_parse_func);
end;

procedure TGOptionGroup.set_translate_func(func: TGTranslateFunc; data: gpointer; destroy_notify: TGDestroyNotify); cdecl;
begin
  GLib2.g_option_group_set_translate_func(@self, func, data, destroy_notify);
end;

procedure TGOptionGroup.set_translation_domain(domain: Pgchar); cdecl;
begin
  GLib2.g_option_group_set_translation_domain(@self, domain);
end;

function TGOptionGroup.new(name: Pgchar; description: Pgchar; help_description: Pgchar; user_data: gpointer; destroy_: TGDestroyNotify): PGOptionGroup; cdecl;
begin
  Result := GLib2.g_option_group_new(name, description, help_description, user_data, destroy_);
end;

function TGPatternSpec.equal(pspec2: PGPatternSpec): gboolean; cdecl;
begin
  Result := GLib2.g_pattern_spec_equal(@self, pspec2);
end;

procedure TGPatternSpec.free; cdecl;
begin
  GLib2.g_pattern_spec_free(@self);
end;

function TGPatternSpec.new(pattern: Pgchar): PGPatternSpec; cdecl;
begin
  Result := GLib2.g_pattern_spec_new(pattern);
end;

function TGPrivate.get: gpointer; cdecl;
begin
  Result := GLib2.g_private_get(@self);
end;

procedure TGPrivate.replace(value: gpointer); cdecl;
begin
  GLib2.g_private_replace(@self, value);
end;

procedure TGPrivate.set_(value: gpointer); cdecl;
begin
  GLib2.g_private_set(@self, value);
end;

procedure TGPtrArray.add(array_: Pgpointer; data: gpointer); cdecl;
begin
  GLib2.g_ptr_array_add(array_, data);
end;

procedure TGPtrArray.foreach(array_: Pgpointer; func: TGFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_ptr_array_foreach(array_, func, user_data);
end;

function TGPtrArray.free(array_: Pgpointer; free_seg: gboolean): Pgpointer; cdecl;
begin
  Result := GLib2.g_ptr_array_free(array_, free_seg);
end;

function TGPtrArray.new: Pgpointer; cdecl;
begin
  Result := GLib2.g_ptr_array_new();
end;

function TGPtrArray.new_full(reserved_size: guint; element_free_func: TGDestroyNotify): Pgpointer; cdecl;
begin
  Result := GLib2.g_ptr_array_new_full(reserved_size, element_free_func);
end;

function TGPtrArray.new_with_free_func(element_free_func: TGDestroyNotify): Pgpointer; cdecl;
begin
  Result := GLib2.g_ptr_array_new_with_free_func(element_free_func);
end;

function TGPtrArray.ref(array_: Pgpointer): Pgpointer; cdecl;
begin
  Result := GLib2.g_ptr_array_ref(array_);
end;

function TGPtrArray.remove(array_: Pgpointer; data: gpointer): gboolean; cdecl;
begin
  Result := GLib2.g_ptr_array_remove(array_, data);
end;

function TGPtrArray.remove_fast(array_: Pgpointer; data: gpointer): gboolean; cdecl;
begin
  Result := GLib2.g_ptr_array_remove_fast(array_, data);
end;

function TGPtrArray.remove_index(array_: Pgpointer; index_: guint): gpointer; cdecl;
begin
  Result := GLib2.g_ptr_array_remove_index(array_, index_);
end;

function TGPtrArray.remove_index_fast(array_: Pgpointer; index_: guint): gpointer; cdecl;
begin
  Result := GLib2.g_ptr_array_remove_index_fast(array_, index_);
end;

procedure TGPtrArray.remove_range(array_: Pgpointer; index_: guint; length: guint); cdecl;
begin
  GLib2.g_ptr_array_remove_range(array_, index_, length);
end;

procedure TGPtrArray.set_free_func(array_: Pgpointer; element_free_func: TGDestroyNotify); cdecl;
begin
  GLib2.g_ptr_array_set_free_func(array_, element_free_func);
end;

procedure TGPtrArray.set_size(array_: Pgpointer; length: gint); cdecl;
begin
  GLib2.g_ptr_array_set_size(array_, length);
end;

function TGPtrArray.sized_new(reserved_size: guint): Pgpointer; cdecl;
begin
  Result := GLib2.g_ptr_array_sized_new(reserved_size);
end;

procedure TGPtrArray.sort(array_: Pgpointer; compare_func: TGCompareFunc); cdecl;
begin
  GLib2.g_ptr_array_sort(array_, compare_func);
end;

procedure TGPtrArray.sort_with_data(array_: Pgpointer; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_ptr_array_sort_with_data(array_, compare_func, user_data);
end;

procedure TGPtrArray.unref(array_: Pgpointer); cdecl;
begin
  GLib2.g_ptr_array_unref(array_);
end;

procedure TGQueue.clear; cdecl;
begin
  GLib2.g_queue_clear(@self);
end;

function TGQueue.copy: PGQueue; cdecl;
begin
  Result := GLib2.g_queue_copy(@self);
end;

procedure TGQueue.delete_link(link_: PGList); cdecl;
begin
  GLib2.g_queue_delete_link(@self, link_);
end;

function TGQueue.find(data: Pgpointer): PGList; cdecl;
begin
  Result := GLib2.g_queue_find(@self, data);
end;

function TGQueue.find_custom(data: Pgpointer; func: TGCompareFunc): PGList; cdecl;
begin
  Result := GLib2.g_queue_find_custom(@self, data, func);
end;

procedure TGQueue.foreach(func: TGFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_queue_foreach(@self, func, user_data);
end;

procedure TGQueue.free; cdecl;
begin
  GLib2.g_queue_free(@self);
end;

procedure TGQueue.free_full(free_func: TGDestroyNotify); cdecl;
begin
  GLib2.g_queue_free_full(@self, free_func);
end;

function TGQueue.get_length: guint; cdecl;
begin
  Result := GLib2.g_queue_get_length(@self);
end;

function TGQueue.index(data: Pgpointer): gint; cdecl;
begin
  Result := GLib2.g_queue_index(@self, data);
end;

procedure TGQueue.init; cdecl;
begin
  GLib2.g_queue_init(@self);
end;

procedure TGQueue.insert_after(sibling: PGList; data: gpointer); cdecl;
begin
  GLib2.g_queue_insert_after(@self, sibling, data);
end;

procedure TGQueue.insert_before(sibling: PGList; data: gpointer); cdecl;
begin
  GLib2.g_queue_insert_before(@self, sibling, data);
end;

procedure TGQueue.insert_sorted(data: gpointer; func: TGCompareDataFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_queue_insert_sorted(@self, data, func, user_data);
end;

function TGQueue.is_empty: gboolean; cdecl;
begin
  Result := GLib2.g_queue_is_empty(@self);
end;

function TGQueue.link_index(link_: PGList): gint; cdecl;
begin
  Result := GLib2.g_queue_link_index(@self, link_);
end;

function TGQueue.peek_head: gpointer; cdecl;
begin
  Result := GLib2.g_queue_peek_head(@self);
end;

function TGQueue.peek_head_link: PGList; cdecl;
begin
  Result := GLib2.g_queue_peek_head_link(@self);
end;

function TGQueue.peek_nth(n: guint): gpointer; cdecl;
begin
  Result := GLib2.g_queue_peek_nth(@self, n);
end;

function TGQueue.peek_nth_link(n: guint): PGList; cdecl;
begin
  Result := GLib2.g_queue_peek_nth_link(@self, n);
end;

function TGQueue.peek_tail: gpointer; cdecl;
begin
  Result := GLib2.g_queue_peek_tail(@self);
end;

function TGQueue.peek_tail_link: PGList; cdecl;
begin
  Result := GLib2.g_queue_peek_tail_link(@self);
end;

function TGQueue.pop_head: gpointer; cdecl;
begin
  Result := GLib2.g_queue_pop_head(@self);
end;

function TGQueue.pop_head_link: PGList; cdecl;
begin
  Result := GLib2.g_queue_pop_head_link(@self);
end;

function TGQueue.pop_nth(n: guint): gpointer; cdecl;
begin
  Result := GLib2.g_queue_pop_nth(@self, n);
end;

function TGQueue.pop_nth_link(n: guint): PGList; cdecl;
begin
  Result := GLib2.g_queue_pop_nth_link(@self, n);
end;

function TGQueue.pop_tail: gpointer; cdecl;
begin
  Result := GLib2.g_queue_pop_tail(@self);
end;

function TGQueue.pop_tail_link: PGList; cdecl;
begin
  Result := GLib2.g_queue_pop_tail_link(@self);
end;

procedure TGQueue.push_head(data: gpointer); cdecl;
begin
  GLib2.g_queue_push_head(@self, data);
end;

procedure TGQueue.push_head_link(link_: PGList); cdecl;
begin
  GLib2.g_queue_push_head_link(@self, link_);
end;

procedure TGQueue.push_nth(data: gpointer; n: gint); cdecl;
begin
  GLib2.g_queue_push_nth(@self, data, n);
end;

procedure TGQueue.push_nth_link(n: gint; link_: PGList); cdecl;
begin
  GLib2.g_queue_push_nth_link(@self, n, link_);
end;

procedure TGQueue.push_tail(data: gpointer); cdecl;
begin
  GLib2.g_queue_push_tail(@self, data);
end;

procedure TGQueue.push_tail_link(link_: PGList); cdecl;
begin
  GLib2.g_queue_push_tail_link(@self, link_);
end;

function TGQueue.remove(data: Pgpointer): gboolean; cdecl;
begin
  Result := GLib2.g_queue_remove(@self, data);
end;

function TGQueue.remove_all(data: Pgpointer): guint; cdecl;
begin
  Result := GLib2.g_queue_remove_all(@self, data);
end;

procedure TGQueue.reverse; cdecl;
begin
  GLib2.g_queue_reverse(@self);
end;

procedure TGQueue.sort(compare_func: TGCompareDataFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_queue_sort(@self, compare_func, user_data);
end;

procedure TGQueue.unlink(link_: PGList); cdecl;
begin
  GLib2.g_queue_unlink(@self, link_);
end;

function TGQueue.new: PGQueue; cdecl;
begin
  Result := GLib2.g_queue_new();
end;

procedure TGRWLock.clear; cdecl;
begin
  GLib2.g_rw_lock_clear(@self);
end;

procedure TGRWLock.init; cdecl;
begin
  GLib2.g_rw_lock_init(@self);
end;

procedure TGRWLock.reader_lock; cdecl;
begin
  GLib2.g_rw_lock_reader_lock(@self);
end;

function TGRWLock.reader_trylock: gboolean; cdecl;
begin
  Result := GLib2.g_rw_lock_reader_trylock(@self);
end;

procedure TGRWLock.reader_unlock; cdecl;
begin
  GLib2.g_rw_lock_reader_unlock(@self);
end;

procedure TGRWLock.writer_lock; cdecl;
begin
  GLib2.g_rw_lock_writer_lock(@self);
end;

function TGRWLock.writer_trylock: gboolean; cdecl;
begin
  Result := GLib2.g_rw_lock_writer_trylock(@self);
end;

procedure TGRWLock.writer_unlock; cdecl;
begin
  GLib2.g_rw_lock_writer_unlock(@self);
end;

function TGRand.copy: PGRand; cdecl;
begin
  Result := GLib2.g_rand_copy(@self);
end;

function TGRand.double: gdouble; cdecl;
begin
  Result := GLib2.g_rand_double(@self);
end;

function TGRand.double_range(begin_: gdouble; end_: gdouble): gdouble; cdecl;
begin
  Result := GLib2.g_rand_double_range(@self, begin_, end_);
end;

procedure TGRand.free; cdecl;
begin
  GLib2.g_rand_free(@self);
end;

function TGRand.int: guint32; cdecl;
begin
  Result := GLib2.g_rand_int(@self);
end;

function TGRand.int_range(begin_: gint32; end_: gint32): gint32; cdecl;
begin
  Result := GLib2.g_rand_int_range(@self, begin_, end_);
end;

procedure TGRand.set_seed(seed: guint32); cdecl;
begin
  GLib2.g_rand_set_seed(@self, seed);
end;

procedure TGRand.set_seed_array(seed: Pguint32; seed_length: guint); cdecl;
begin
  GLib2.g_rand_set_seed_array(@self, seed, seed_length);
end;

function TGRand.new: PGRand; cdecl;
begin
  Result := GLib2.g_rand_new();
end;

function TGRand.new_with_seed(seed: guint32): PGRand; cdecl;
begin
  Result := GLib2.g_rand_new_with_seed(seed);
end;

function TGRand.new_with_seed_array(seed: Pguint32; seed_length: guint): PGRand; cdecl;
begin
  Result := GLib2.g_rand_new_with_seed_array(seed, seed_length);
end;

procedure TGRecMutex.clear; cdecl;
begin
  GLib2.g_rec_mutex_clear(@self);
end;

procedure TGRecMutex.init; cdecl;
begin
  GLib2.g_rec_mutex_init(@self);
end;

procedure TGRecMutex.lock; cdecl;
begin
  GLib2.g_rec_mutex_lock(@self);
end;

function TGRecMutex.trylock: gboolean; cdecl;
begin
  Result := GLib2.g_rec_mutex_trylock(@self);
end;

procedure TGRecMutex.unlock; cdecl;
begin
  GLib2.g_rec_mutex_unlock(@self);
end;

function TGScanner.cur_line: guint; cdecl;
begin
  Result := GLib2.g_scanner_cur_line(@self);
end;

function TGScanner.cur_position: guint; cdecl;
begin
  Result := GLib2.g_scanner_cur_position(@self);
end;

function TGScanner.cur_token: TGTokenType; cdecl;
begin
  Result := GLib2.g_scanner_cur_token(@self);
end;

function TGScanner.cur_value: TGTokenValue; cdecl;
begin
  Result := GLib2.g_scanner_cur_value(@self);
end;

procedure TGScanner.destroy_; cdecl;
begin
  GLib2.g_scanner_destroy(@self);
end;

function TGScanner.eof: gboolean; cdecl;
begin
  Result := GLib2.g_scanner_eof(@self);
end;

function TGScanner.get_next_token: TGTokenType; cdecl;
begin
  Result := GLib2.g_scanner_get_next_token(@self);
end;

procedure TGScanner.input_file(input_fd: gint); cdecl;
begin
  GLib2.g_scanner_input_file(@self, input_fd);
end;

procedure TGScanner.input_text(text: Pgchar; text_len: guint); cdecl;
begin
  GLib2.g_scanner_input_text(@self, text, text_len);
end;

function TGScanner.lookup_symbol(symbol: Pgchar): gpointer; cdecl;
begin
  Result := GLib2.g_scanner_lookup_symbol(@self, symbol);
end;

function TGScanner.peek_next_token: TGTokenType; cdecl;
begin
  Result := GLib2.g_scanner_peek_next_token(@self);
end;

procedure TGScanner.scope_add_symbol(scope_id: guint; symbol: Pgchar; value: gpointer); cdecl;
begin
  GLib2.g_scanner_scope_add_symbol(@self, scope_id, symbol, value);
end;

procedure TGScanner.scope_foreach_symbol(scope_id: guint; func: TGHFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_scanner_scope_foreach_symbol(@self, scope_id, func, user_data);
end;

function TGScanner.scope_lookup_symbol(scope_id: guint; symbol: Pgchar): gpointer; cdecl;
begin
  Result := GLib2.g_scanner_scope_lookup_symbol(@self, scope_id, symbol);
end;

procedure TGScanner.scope_remove_symbol(scope_id: guint; symbol: Pgchar); cdecl;
begin
  GLib2.g_scanner_scope_remove_symbol(@self, scope_id, symbol);
end;

function TGScanner.set_scope(scope_id: guint): guint; cdecl;
begin
  Result := GLib2.g_scanner_set_scope(@self, scope_id);
end;

procedure TGScanner.sync_file_offset; cdecl;
begin
  GLib2.g_scanner_sync_file_offset(@self);
end;

procedure TGScanner.unexp_token(expected_token: TGTokenType; identifier_spec: Pgchar; symbol_spec: Pgchar; symbol_name: Pgchar; message: Pgchar; is_error: gint); cdecl;
begin
  GLib2.g_scanner_unexp_token(@self, expected_token, identifier_spec, symbol_spec, symbol_name, message, is_error);
end;

function TGScanner.new(config_templ: PGScannerConfig): PGScanner; cdecl;
begin
  Result := GLib2.g_scanner_new(config_templ);
end;

function TGSequenceIter.compare(b: PGSequenceIter): gint; cdecl;
begin
  Result := GLib2.g_sequence_iter_compare(@self, b);
end;

function TGSequenceIter.get_position: gint; cdecl;
begin
  Result := GLib2.g_sequence_iter_get_position(@self);
end;

function TGSequenceIter.get_sequence: PGSequence; cdecl;
begin
  Result := GLib2.g_sequence_iter_get_sequence(@self);
end;

function TGSequenceIter.is_begin: gboolean; cdecl;
begin
  Result := GLib2.g_sequence_iter_is_begin(@self);
end;

function TGSequenceIter.is_end: gboolean; cdecl;
begin
  Result := GLib2.g_sequence_iter_is_end(@self);
end;

function TGSequenceIter.move(delta: gint): PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_iter_move(@self, delta);
end;

function TGSequenceIter.next: PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_iter_next(@self);
end;

function TGSequenceIter.prev: PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_iter_prev(@self);
end;

function TGSequence.append(data: gpointer): PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_append(@self, data);
end;

procedure TGSequence.foreach(func: TGFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_sequence_foreach(@self, func, user_data);
end;

procedure TGSequence.free; cdecl;
begin
  GLib2.g_sequence_free(@self);
end;

function TGSequence.get_begin_iter: PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_get_begin_iter(@self);
end;

function TGSequence.get_end_iter: PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_get_end_iter(@self);
end;

function TGSequence.get_iter_at_pos(pos: gint): PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_get_iter_at_pos(@self, pos);
end;

function TGSequence.get_length: gint; cdecl;
begin
  Result := GLib2.g_sequence_get_length(@self);
end;

function TGSequence.insert_sorted(data: gpointer; cmp_func: TGCompareDataFunc; cmp_data: gpointer): PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_insert_sorted(@self, data, cmp_func, cmp_data);
end;

function TGSequence.insert_sorted_iter(data: gpointer; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer): PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_insert_sorted_iter(@self, data, iter_cmp, cmp_data);
end;

function TGSequence.lookup(data: gpointer; cmp_func: TGCompareDataFunc; cmp_data: gpointer): PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_lookup(@self, data, cmp_func, cmp_data);
end;

function TGSequence.lookup_iter(data: gpointer; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer): PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_lookup_iter(@self, data, iter_cmp, cmp_data);
end;

function TGSequence.prepend(data: gpointer): PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_prepend(@self, data);
end;

function TGSequence.search(data: gpointer; cmp_func: TGCompareDataFunc; cmp_data: gpointer): PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_search(@self, data, cmp_func, cmp_data);
end;

function TGSequence.search_iter(data: gpointer; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer): PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_search_iter(@self, data, iter_cmp, cmp_data);
end;

procedure TGSequence.sort(cmp_func: TGCompareDataFunc; cmp_data: gpointer); cdecl;
begin
  GLib2.g_sequence_sort(@self, cmp_func, cmp_data);
end;

procedure TGSequence.sort_iter(cmp_func: TGSequenceIterCompareFunc; cmp_data: gpointer); cdecl;
begin
  GLib2.g_sequence_sort_iter(@self, cmp_func, cmp_data);
end;

procedure TGSequence.foreach_range(begin_: PGSequenceIter; end_: PGSequenceIter; func: TGFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_sequence_foreach_range(begin_, end_, func, user_data);
end;

function TGSequence.get(iter: PGSequenceIter): gpointer; cdecl;
begin
  Result := GLib2.g_sequence_get(iter);
end;

function TGSequence.insert_before(iter: PGSequenceIter; data: gpointer): PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_insert_before(iter, data);
end;

procedure TGSequence.move(src: PGSequenceIter; dest: PGSequenceIter); cdecl;
begin
  GLib2.g_sequence_move(src, dest);
end;

procedure TGSequence.move_range(dest: PGSequenceIter; begin_: PGSequenceIter; end_: PGSequenceIter); cdecl;
begin
  GLib2.g_sequence_move_range(dest, begin_, end_);
end;

function TGSequence.new(data_destroy: TGDestroyNotify): PGSequence; cdecl;
begin
  Result := GLib2.g_sequence_new(data_destroy);
end;

function TGSequence.range_get_midpoint(begin_: PGSequenceIter; end_: PGSequenceIter): PGSequenceIter; cdecl;
begin
  Result := GLib2.g_sequence_range_get_midpoint(begin_, end_);
end;

procedure TGSequence.remove(iter: PGSequenceIter); cdecl;
begin
  GLib2.g_sequence_remove(iter);
end;

procedure TGSequence.remove_range(begin_: PGSequenceIter; end_: PGSequenceIter); cdecl;
begin
  GLib2.g_sequence_remove_range(begin_, end_);
end;

procedure TGSequence.set_(iter: PGSequenceIter; data: gpointer); cdecl;
begin
  GLib2.g_sequence_set(iter, data);
end;

procedure TGSequence.sort_changed(iter: PGSequenceIter; cmp_func: TGCompareDataFunc; cmp_data: gpointer); cdecl;
begin
  GLib2.g_sequence_sort_changed(iter, cmp_func, cmp_data);
end;

procedure TGSequence.sort_changed_iter(iter: PGSequenceIter; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer); cdecl;
begin
  GLib2.g_sequence_sort_changed_iter(iter, iter_cmp, cmp_data);
end;

procedure TGSequence.swap(a: PGSequenceIter; b: PGSequenceIter); cdecl;
begin
  GLib2.g_sequence_swap(a, b);
end;

procedure TGStringChunk.clear; cdecl;
begin
  GLib2.g_string_chunk_clear(@self);
end;

procedure TGStringChunk.free; cdecl;
begin
  GLib2.g_string_chunk_free(@self);
end;

function TGStringChunk.insert(string_: Pgchar): Pgchar; cdecl;
begin
  Result := GLib2.g_string_chunk_insert(@self, string_);
end;

function TGStringChunk.insert_const(string_: Pgchar): Pgchar; cdecl;
begin
  Result := GLib2.g_string_chunk_insert_const(@self, string_);
end;

function TGStringChunk.insert_len(string_: Pgchar; len: gssize): Pgchar; cdecl;
begin
  Result := GLib2.g_string_chunk_insert_len(@self, string_, len);
end;

function TGStringChunk.new(size: gsize): PGStringChunk; cdecl;
begin
  Result := GLib2.g_string_chunk_new(size);
end;

procedure TGTestLogBuffer.free; cdecl;
begin
  GLib2.g_test_log_buffer_free(@self);
end;

function TGTestLogBuffer.pop: PGTestLogMsg; cdecl;
begin
  Result := GLib2.g_test_log_buffer_pop(@self);
end;

procedure TGTestLogBuffer.push(n_bytes: guint; bytes: Pguint8); cdecl;
begin
  GLib2.g_test_log_buffer_push(@self, n_bytes, bytes);
end;

function TGTestLogBuffer.new: PGTestLogBuffer; cdecl;
begin
  Result := GLib2.g_test_log_buffer_new();
end;

procedure TGTestLogMsg.free; cdecl;
begin
  GLib2.g_test_log_msg_free(@self);
end;

procedure TGTestSuite.add(test_case: PGTestCase); cdecl;
begin
  GLib2.g_test_suite_add(@self, test_case);
end;

procedure TGTestSuite.add_suite(nestedsuite: PGTestSuite); cdecl;
begin
  GLib2.g_test_suite_add_suite(@self, nestedsuite);
end;

function TGThread.new(name: Pgchar; func: TGThreadFunc; data: gpointer): PGThread; cdecl;
begin
  Result := GLib2.g_thread_new(name, func, data);
end;

function TGThread.try_new(name: Pgchar; func: TGThreadFunc; data: gpointer; error: PPGError): PGThread; cdecl;
begin
  Result := GLib2.g_thread_try_new(name, func, data, error);
end;

function TGThread.join: gpointer; cdecl;
begin
  Result := GLib2.g_thread_join(@self);
end;

function TGThread.ref: PGThread; cdecl;
begin
  Result := GLib2.g_thread_ref(@self);
end;

procedure TGThread.unref; cdecl;
begin
  GLib2.g_thread_unref(@self);
end;

function TGThread.error_quark: TGQuark; cdecl;
begin
  Result := GLib2.g_thread_error_quark();
end;

procedure TGThread.exit(retval: gpointer); cdecl;
begin
  GLib2.g_thread_exit(retval);
end;

function TGThread.self: PGThread; cdecl;
begin
  Result := GLib2.g_thread_self();
end;

procedure TGThread.yield; cdecl;
begin
  GLib2.g_thread_yield();
end;

procedure TGThreadPool.free(immediate: gboolean; wait_: gboolean); cdecl;
begin
  GLib2.g_thread_pool_free(@self, immediate, wait_);
end;

function TGThreadPool.get_max_threads: gint; cdecl;
begin
  Result := GLib2.g_thread_pool_get_max_threads(@self);
end;

function TGThreadPool.get_num_threads: guint; cdecl;
begin
  Result := GLib2.g_thread_pool_get_num_threads(@self);
end;

function TGThreadPool.push(data: gpointer; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_thread_pool_push(@self, data, error);
end;

function TGThreadPool.set_max_threads(max_threads: gint; error: PPGError): gboolean; cdecl;
begin
  Result := GLib2.g_thread_pool_set_max_threads(@self, max_threads, error);
end;

procedure TGThreadPool.set_sort_function(func: TGCompareDataFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_thread_pool_set_sort_function(@self, func, user_data);
end;

function TGThreadPool.unprocessed: guint; cdecl;
begin
  Result := GLib2.g_thread_pool_unprocessed(@self);
end;

function TGThreadPool.get_max_idle_time: guint; cdecl;
begin
  Result := GLib2.g_thread_pool_get_max_idle_time();
end;

function TGThreadPool.get_max_unused_threads: gint; cdecl;
begin
  Result := GLib2.g_thread_pool_get_max_unused_threads();
end;

function TGThreadPool.get_num_unused_threads: guint; cdecl;
begin
  Result := GLib2.g_thread_pool_get_num_unused_threads();
end;

function TGThreadPool.new(func: TGFunc; user_data: gpointer; max_threads: gint; exclusive: gboolean; error: PPGError): PGThreadPool; cdecl;
begin
  Result := GLib2.g_thread_pool_new(func, user_data, max_threads, exclusive, error);
end;

procedure TGThreadPool.set_max_idle_time(interval: guint); cdecl;
begin
  GLib2.g_thread_pool_set_max_idle_time(interval);
end;

procedure TGThreadPool.set_max_unused_threads(max_threads: gint); cdecl;
begin
  GLib2.g_thread_pool_set_max_unused_threads(max_threads);
end;

procedure TGThreadPool.stop_unused_threads; cdecl;
begin
  GLib2.g_thread_pool_stop_unused_threads();
end;

procedure TGTimer.continue; cdecl;
begin
  GLib2.g_timer_continue(@self);
end;

procedure TGTimer.destroy_; cdecl;
begin
  GLib2.g_timer_destroy(@self);
end;

function TGTimer.elapsed(microseconds: Pgulong): gdouble; cdecl;
begin
  Result := GLib2.g_timer_elapsed(@self, microseconds);
end;

procedure TGTimer.reset; cdecl;
begin
  GLib2.g_timer_reset(@self);
end;

procedure TGTimer.start; cdecl;
begin
  GLib2.g_timer_start(@self);
end;

procedure TGTimer.stop; cdecl;
begin
  GLib2.g_timer_stop(@self);
end;

function TGTimer.new: PGTimer; cdecl;
begin
  Result := GLib2.g_timer_new();
end;

function TGTrashStack.height(stack_p: PPGTrashStack): guint; cdecl;
begin
  Result := GLib2.g_trash_stack_height(stack_p);
end;

function TGTrashStack.peek(stack_p: PPGTrashStack): gpointer; cdecl;
begin
  Result := GLib2.g_trash_stack_peek(stack_p);
end;

function TGTrashStack.pop(stack_p: PPGTrashStack): gpointer; cdecl;
begin
  Result := GLib2.g_trash_stack_pop(stack_p);
end;

procedure TGTrashStack.push(stack_p: PPGTrashStack; data_p: gpointer); cdecl;
begin
  GLib2.g_trash_stack_push(stack_p, data_p);
end;

procedure TGTree.destroy_; cdecl;
begin
  GLib2.g_tree_destroy(@self);
end;

procedure TGTree.foreach(func: TGTraverseFunc; user_data: gpointer); cdecl;
begin
  GLib2.g_tree_foreach(@self, func, user_data);
end;

function TGTree.height: gint; cdecl;
begin
  Result := GLib2.g_tree_height(@self);
end;

procedure TGTree.insert(key: gpointer; value: gpointer); cdecl;
begin
  GLib2.g_tree_insert(@self, key, value);
end;

function TGTree.lookup(key: Pgpointer): gpointer; cdecl;
begin
  Result := GLib2.g_tree_lookup(@self, key);
end;

function TGTree.lookup_extended(lookup_key: Pgpointer; orig_key: Pgpointer; value: Pgpointer): gboolean; cdecl;
begin
  Result := GLib2.g_tree_lookup_extended(@self, lookup_key, orig_key, value);
end;

function TGTree.nnodes: gint; cdecl;
begin
  Result := GLib2.g_tree_nnodes(@self);
end;

function TGTree.ref: PGTree; cdecl;
begin
  Result := GLib2.g_tree_ref(@self);
end;

function TGTree.remove(key: Pgpointer): gboolean; cdecl;
begin
  Result := GLib2.g_tree_remove(@self, key);
end;

procedure TGTree.replace(key: gpointer; value: gpointer); cdecl;
begin
  GLib2.g_tree_replace(@self, key, value);
end;

function TGTree.search(search_func: TGCompareFunc; user_data: Pgpointer): gpointer; cdecl;
begin
  Result := GLib2.g_tree_search(@self, search_func, user_data);
end;

function TGTree.steal(key: Pgpointer): gboolean; cdecl;
begin
  Result := GLib2.g_tree_steal(@self, key);
end;

procedure TGTree.unref; cdecl;
begin
  GLib2.g_tree_unref(@self);
end;

function TGTree.new(key_compare_func: TGCompareFunc): PGTree; cdecl;
begin
  Result := GLib2.g_tree_new(key_compare_func);
end;

function TGTree.new_full(key_compare_func: TGCompareDataFunc; key_compare_data: gpointer; key_destroy_func: TGDestroyNotify; value_destroy_func: TGDestroyNotify): PGTree; cdecl;
begin
  Result := GLib2.g_tree_new_full(key_compare_func, key_compare_data, key_destroy_func, value_destroy_func);
end;

function TGTree.new_with_data(key_compare_func: TGCompareDataFunc; key_compare_data: gpointer): PGTree; cdecl;
begin
  Result := GLib2.g_tree_new_with_data(key_compare_func, key_compare_data);
end;

function TGVariant.new_array(child_type: PGVariantType; children: PPGVariant; n_children: gsize): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_array(child_type, children, n_children);
end;

function TGVariant.new_boolean(value: gboolean): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_boolean(value);
end;

function TGVariant.new_byte(value: guint8): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_byte(value);
end;

function TGVariant.new_bytestring(string_: Pgchar): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_bytestring(string_);
end;

function TGVariant.new_bytestring_array(strv: PPgchar; length: gssize): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_bytestring_array(strv, length);
end;

function TGVariant.new_dict_entry(key: PGVariant; value: PGVariant): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_dict_entry(key, value);
end;

function TGVariant.new_double(value: gdouble): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_double(value);
end;

function TGVariant.new_fixed_array(element_type: PGVariantType; elements: Pgpointer; n_elements: gsize; element_size: gsize): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_fixed_array(element_type, elements, n_elements, element_size);
end;

function TGVariant.new_from_bytes(type_: PGVariantType; bytes: PGBytes; trusted: gboolean): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_from_bytes(type_, bytes, trusted);
end;

function TGVariant.new_from_data(type_: PGVariantType; data: guint8; size: gsize; trusted: gboolean; notify: TGDestroyNotify; user_data: gpointer): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_from_data(type_, data, size, trusted, notify, user_data);
end;

function TGVariant.new_handle(value: gint32): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_handle(value);
end;

function TGVariant.new_int16(value: gint16): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_int16(value);
end;

function TGVariant.new_int32(value: gint32): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_int32(value);
end;

function TGVariant.new_int64(value: gint64): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_int64(value);
end;

function TGVariant.new_maybe(child_type: PGVariantType; child: PGVariant): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_maybe(child_type, child);
end;

function TGVariant.new_object_path(object_path: Pgchar): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_object_path(object_path);
end;

function TGVariant.new_objv(strv: PPgchar; length: gssize): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_objv(strv, length);
end;

function TGVariant.new_signature(signature: Pgchar): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_signature(signature);
end;

function TGVariant.new_string(string_: Pgchar): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_string(string_);
end;

function TGVariant.new_strv(strv: PPgchar; length: gssize): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_strv(strv, length);
end;

function TGVariant.new_tuple(children: PPGVariant; n_children: gsize): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_tuple(children, n_children);
end;

function TGVariant.new_uint16(value: guint16): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_uint16(value);
end;

function TGVariant.new_uint32(value: guint32): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_uint32(value);
end;

function TGVariant.new_uint64(value: guint64): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_uint64(value);
end;

function TGVariant.new_variant(value: PGVariant): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_new_variant(value);
end;

function TGVariant.byteswap: PGVariant; cdecl;
begin
  Result := GLib2.g_variant_byteswap(@self);
end;

function TGVariant.check_format_string(format_string: Pgchar; copy_only: gboolean): gboolean; cdecl;
begin
  Result := GLib2.g_variant_check_format_string(@self, format_string, copy_only);
end;

function TGVariant.classify: TGVariantClass; cdecl;
begin
  Result := GLib2.g_variant_classify(@self);
end;

function TGVariant.compare(two: PGVariant): gint; cdecl;
begin
  Result := GLib2.g_variant_compare(@self, two);
end;

function TGVariant.dup_bytestring(length: Pgsize): Pgchar; cdecl;
begin
  Result := GLib2.g_variant_dup_bytestring(@self, length);
end;

function TGVariant.dup_bytestring_array(length: Pgsize): PPgchar; cdecl;
begin
  Result := GLib2.g_variant_dup_bytestring_array(@self, length);
end;

function TGVariant.dup_objv(length: Pgsize): PPgchar; cdecl;
begin
  Result := GLib2.g_variant_dup_objv(@self, length);
end;

function TGVariant.dup_string(length: Pgsize): Pgchar; cdecl;
begin
  Result := GLib2.g_variant_dup_string(@self, length);
end;

function TGVariant.dup_strv(length: Pgsize): PPgchar; cdecl;
begin
  Result := GLib2.g_variant_dup_strv(@self, length);
end;

function TGVariant.equal(two: PGVariant): gboolean; cdecl;
begin
  Result := GLib2.g_variant_equal(@self, two);
end;

function TGVariant.get_boolean: gboolean; cdecl;
begin
  Result := GLib2.g_variant_get_boolean(@self);
end;

function TGVariant.get_byte: guint8; cdecl;
begin
  Result := GLib2.g_variant_get_byte(@self);
end;

function TGVariant.get_bytestring: Pgchar; cdecl;
begin
  Result := GLib2.g_variant_get_bytestring(@self);
end;

function TGVariant.get_bytestring_array(length: Pgsize): PPgchar; cdecl;
begin
  Result := GLib2.g_variant_get_bytestring_array(@self, length);
end;

function TGVariant.get_child_value(index_: gsize): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_get_child_value(@self, index_);
end;

function TGVariant.get_data: Pgpointer; cdecl;
begin
  Result := GLib2.g_variant_get_data(@self);
end;

function TGVariant.get_data_as_bytes: PGBytes; cdecl;
begin
  Result := GLib2.g_variant_get_data_as_bytes(@self);
end;

function TGVariant.get_double: gdouble; cdecl;
begin
  Result := GLib2.g_variant_get_double(@self);
end;

function TGVariant.get_fixed_array(n_elements: Pgsize; element_size: gsize): gpointer; cdecl;
begin
  Result := GLib2.g_variant_get_fixed_array(@self, n_elements, element_size);
end;

function TGVariant.get_handle: gint32; cdecl;
begin
  Result := GLib2.g_variant_get_handle(@self);
end;

function TGVariant.get_int16: gint16; cdecl;
begin
  Result := GLib2.g_variant_get_int16(@self);
end;

function TGVariant.get_int32: gint32; cdecl;
begin
  Result := GLib2.g_variant_get_int32(@self);
end;

function TGVariant.get_int64: gint64; cdecl;
begin
  Result := GLib2.g_variant_get_int64(@self);
end;

function TGVariant.get_maybe: PGVariant; cdecl;
begin
  Result := GLib2.g_variant_get_maybe(@self);
end;

function TGVariant.get_normal_form: PGVariant; cdecl;
begin
  Result := GLib2.g_variant_get_normal_form(@self);
end;

function TGVariant.get_objv(length: Pgsize): PPgchar; cdecl;
begin
  Result := GLib2.g_variant_get_objv(@self, length);
end;

function TGVariant.get_size: gsize; cdecl;
begin
  Result := GLib2.g_variant_get_size(@self);
end;

function TGVariant.get_string(length: Pgsize): Pgchar; cdecl;
begin
  Result := GLib2.g_variant_get_string(@self, length);
end;

function TGVariant.get_strv(length: Pgsize): PPgchar; cdecl;
begin
  Result := GLib2.g_variant_get_strv(@self, length);
end;

function TGVariant.get_type: PGVariantType; cdecl;
begin
  Result := GLib2.g_variant_get_type(@self);
end;

function TGVariant.get_type_string: Pgchar; cdecl;
begin
  Result := GLib2.g_variant_get_type_string(@self);
end;

function TGVariant.get_uint16: guint16; cdecl;
begin
  Result := GLib2.g_variant_get_uint16(@self);
end;

function TGVariant.get_uint32: guint32; cdecl;
begin
  Result := GLib2.g_variant_get_uint32(@self);
end;

function TGVariant.get_uint64: guint64; cdecl;
begin
  Result := GLib2.g_variant_get_uint64(@self);
end;

function TGVariant.get_variant: PGVariant; cdecl;
begin
  Result := GLib2.g_variant_get_variant(@self);
end;

function TGVariant.hash: guint; cdecl;
begin
  Result := GLib2.g_variant_hash(@self);
end;

function TGVariant.is_container: gboolean; cdecl;
begin
  Result := GLib2.g_variant_is_container(@self);
end;

function TGVariant.is_floating: gboolean; cdecl;
begin
  Result := GLib2.g_variant_is_floating(@self);
end;

function TGVariant.is_normal_form: gboolean; cdecl;
begin
  Result := GLib2.g_variant_is_normal_form(@self);
end;

function TGVariant.is_of_type(type_: PGVariantType): gboolean; cdecl;
begin
  Result := GLib2.g_variant_is_of_type(@self, type_);
end;

function TGVariant.iter_new: PGVariantIter; cdecl;
begin
  Result := GLib2.g_variant_iter_new(@self);
end;

function TGVariant.lookup_value(key: Pgchar; expected_type: PGVariantType): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_lookup_value(@self, key, expected_type);
end;

function TGVariant.n_children: gsize; cdecl;
begin
  Result := GLib2.g_variant_n_children(@self);
end;

function TGVariant.print(type_annotate: gboolean): Pgchar; cdecl;
begin
  Result := GLib2.g_variant_print(@self, type_annotate);
end;

function TGVariant.print_string(string_: PGString; type_annotate: gboolean): PGString; cdecl;
begin
  Result := GLib2.g_variant_print_string(@self, string_, type_annotate);
end;

function TGVariant.ref: PGVariant; cdecl;
begin
  Result := GLib2.g_variant_ref(@self);
end;

function TGVariant.ref_sink: PGVariant; cdecl;
begin
  Result := GLib2.g_variant_ref_sink(@self);
end;

procedure TGVariant.store(data: gpointer); cdecl;
begin
  GLib2.g_variant_store(@self, data);
end;

function TGVariant.take_ref: PGVariant; cdecl;
begin
  Result := GLib2.g_variant_take_ref(@self);
end;

procedure TGVariant.unref; cdecl;
begin
  GLib2.g_variant_unref(@self);
end;

function TGVariant.is_object_path(string_: Pgchar): gboolean; cdecl;
begin
  Result := GLib2.g_variant_is_object_path(string_);
end;

function TGVariant.is_signature(string_: Pgchar): gboolean; cdecl;
begin
  Result := GLib2.g_variant_is_signature(string_);
end;

function TGVariant.parse(type_: PGVariantType; text: Pgchar; limit: Pgchar; endptr: PPgchar; error: PPGError): PGVariant; cdecl;
begin
  Result := GLib2.g_variant_parse(type_, text, limit, endptr, error);
end;

function TGVariant.parser_get_error_quark: TGQuark; cdecl;
begin
  Result := GLib2.g_variant_parser_get_error_quark();
end;

function TGVariantType.new(type_string: Pgchar): PGVariantType; cdecl;
begin
  Result := GLib2.g_variant_type_new(type_string);
end;

function TGVariantType.new_array(element: PGVariantType): PGVariantType; cdecl;
begin
  Result := GLib2.g_variant_type_new_array(element);
end;

function TGVariantType.new_dict_entry(key: PGVariantType; value: PGVariantType): PGVariantType; cdecl;
begin
  Result := GLib2.g_variant_type_new_dict_entry(key, value);
end;

function TGVariantType.new_maybe(element: PGVariantType): PGVariantType; cdecl;
begin
  Result := GLib2.g_variant_type_new_maybe(element);
end;

function TGVariantType.new_tuple(items: PPGVariantType; length: gint): PGVariantType; cdecl;
begin
  Result := GLib2.g_variant_type_new_tuple(items, length);
end;

function TGVariantType.copy: PGVariantType; cdecl;
begin
  Result := GLib2.g_variant_type_copy(@self);
end;

function TGVariantType.dup_string: Pgchar; cdecl;
begin
  Result := GLib2.g_variant_type_dup_string(@self);
end;

function TGVariantType.element: PGVariantType; cdecl;
begin
  Result := GLib2.g_variant_type_element(@self);
end;

function TGVariantType.equal(type2: PGVariantType): gboolean; cdecl;
begin
  Result := GLib2.g_variant_type_equal(@self, type2);
end;

function TGVariantType.first: PGVariantType; cdecl;
begin
  Result := GLib2.g_variant_type_first(@self);
end;

procedure TGVariantType.free; cdecl;
begin
  GLib2.g_variant_type_free(@self);
end;

function TGVariantType.get_string_length: gsize; cdecl;
begin
  Result := GLib2.g_variant_type_get_string_length(@self);
end;

function TGVariantType.hash: guint; cdecl;
begin
  Result := GLib2.g_variant_type_hash(@self);
end;

function TGVariantType.is_array: gboolean; cdecl;
begin
  Result := GLib2.g_variant_type_is_array(@self);
end;

function TGVariantType.is_basic: gboolean; cdecl;
begin
  Result := GLib2.g_variant_type_is_basic(@self);
end;

function TGVariantType.is_container: gboolean; cdecl;
begin
  Result := GLib2.g_variant_type_is_container(@self);
end;

function TGVariantType.is_definite: gboolean; cdecl;
begin
  Result := GLib2.g_variant_type_is_definite(@self);
end;

function TGVariantType.is_dict_entry: gboolean; cdecl;
begin
  Result := GLib2.g_variant_type_is_dict_entry(@self);
end;

function TGVariantType.is_maybe: gboolean; cdecl;
begin
  Result := GLib2.g_variant_type_is_maybe(@self);
end;

function TGVariantType.is_subtype_of(supertype: PGVariantType): gboolean; cdecl;
begin
  Result := GLib2.g_variant_type_is_subtype_of(@self, supertype);
end;

function TGVariantType.is_tuple: gboolean; cdecl;
begin
  Result := GLib2.g_variant_type_is_tuple(@self);
end;

function TGVariantType.is_variant: gboolean; cdecl;
begin
  Result := GLib2.g_variant_type_is_variant(@self);
end;

function TGVariantType.key: PGVariantType; cdecl;
begin
  Result := GLib2.g_variant_type_key(@self);
end;

function TGVariantType.n_items: gsize; cdecl;
begin
  Result := GLib2.g_variant_type_n_items(@self);
end;

function TGVariantType.next: PGVariantType; cdecl;
begin
  Result := GLib2.g_variant_type_next(@self);
end;

function TGVariantType.peek_string: Pgchar; cdecl;
begin
  Result := GLib2.g_variant_type_peek_string(@self);
end;

function TGVariantType.value: PGVariantType; cdecl;
begin
  Result := GLib2.g_variant_type_value(@self);
end;

function TGVariantType.checked_(arg0: Pgchar): PGVariantType; cdecl;
begin
  Result := GLib2.g_variant_type_checked_(arg0);
end;

function TGVariantType.string_is_valid(type_string: Pgchar): gboolean; cdecl;
begin
  Result := GLib2.g_variant_type_string_is_valid(type_string);
end;

function TGVariantType.string_scan(string_: Pgchar; limit: Pgchar; endptr: PPgchar): gboolean; cdecl;
begin
  Result := GLib2.g_variant_type_string_scan(string_, limit, endptr);
end;

function TGVariantIter.copy: PGVariantIter; cdecl;
begin
  Result := GLib2.g_variant_iter_copy(@self);
end;

procedure TGVariantIter.free; cdecl;
begin
  GLib2.g_variant_iter_free(@self);
end;

function TGVariantIter.init(value: PGVariant): gsize; cdecl;
begin
  Result := GLib2.g_variant_iter_init(@self, value);
end;

function TGVariantIter.n_children: gsize; cdecl;
begin
  Result := GLib2.g_variant_iter_n_children(@self);
end;

function TGVariantIter.next_value: PGVariant; cdecl;
begin
  Result := GLib2.g_variant_iter_next_value(@self);
end;

function TGVariantBuilder.new(type_: PGVariantType): PGVariantBuilder; cdecl;
begin
  Result := GLib2.g_variant_builder_new(type_);
end;

procedure TGVariantBuilder.add_value(value: PGVariant); cdecl;
begin
  GLib2.g_variant_builder_add_value(@self, value);
end;

procedure TGVariantBuilder.clear; cdecl;
begin
  GLib2.g_variant_builder_clear(@self);
end;

procedure TGVariantBuilder.close; cdecl;
begin
  GLib2.g_variant_builder_close(@self);
end;

function TGVariantBuilder.end_: PGVariant; cdecl;
begin
  Result := GLib2.g_variant_builder_end(@self);
end;

procedure TGVariantBuilder.init(type_: PGVariantType); cdecl;
begin
  GLib2.g_variant_builder_init(@self, type_);
end;

procedure TGVariantBuilder.open(type_: PGVariantType); cdecl;
begin
  GLib2.g_variant_builder_open(@self, type_);
end;

function TGVariantBuilder.ref: PGVariantBuilder; cdecl;
begin
  Result := GLib2.g_variant_builder_ref(@self);
end;

procedure TGVariantBuilder.unref; cdecl;
begin
  GLib2.g_variant_builder_unref(@self);
end;

end.